<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>javascript 面向对象继承工具</title>
</head>
<body>
<script language="javascript">
// A simple helper that allows you to bind new functions to the
// prototype of an object
Function.prototype.method = function(name, func) {
this.prototype[name] = func;
return this;
};
// A (rather complex) function that allows you to gracefully inherit
// functions from other objects and be able to still call the 'parent'
// object's function
Function.method('inherits', function(parent) {
// Keep track of how many parent-levels deep we are
var depth = 0;
// Inherit the parent's methods
var proto = this.prototype = new parent();
// Create a new 'priveledged' function called 'uber', that when called
// executes any function that has been written over in the inheritance
this.method('uber', function uber(name) {
var func; // The function to be execute
var ret; // The return value of the function
var v = parent.prototype; // The parent's prototype
// If we're already within another 'uber' function
if (depth) {
// Go the necessary depth to find the orignal prototype
for ( var i = d; i > 0; i += 1 ) {
v = v.constructor.prototype;
}
// and get the function from that prototype
func = v[name];
// Otherwise, this is the first 'uber' call
} else {
// Get the function to execute from the prototype
func = proto[name];
// If the function was a part of this prototype
if ( func == this[name] ) {
// Go to the parent's prototype instead
func = v[name];
}
}
// Keep track of how 'deep' we are in the inheritance stack
depth += 1;
// Call the function to execute with all the arguments but the first
// (which holds the name of the function that we're executing)
ret = func.apply(this, Array.prototype.slice.apply(arguments, [1]));
// Reset the stack depth
depth -= 1;
// Return the return value of the execute function
return ret;
});
return this;
});
// A function for inheriting only a couple functions from a parent object,
// not every function using new parent()
Function.method('swiss', function(parent) {
// Go through all of the methods to inherit
for (var i = 1; i < arguments.length; i += 1) {
// The name of the method to import
var name = arguments[i];
// Import the method into this object's prototype
this.prototype[name] = parent.prototype[name];
}
return this;
});
// Create a new Person object constructor
function Person( name ) {
this.name = name;
}
// Add a new method to the Person object
Person.method( 'getName', function(){
return name;
});
// Create a new User object constructor
function User( name, password ) {
this.name = name;
this.password = password;
}
// Inherit all the methods from the Person object
User.inherits( Person );
// Add a new method to the User object
User.method( 'getPassword', function(){
return this.password;
});
// Overwrite the method created by the Person object,
// but call it again using the uber function
User.method( 'getName', function(){
return "My name is: " + this.uber('getName');
});
</script>
</body>
</html>
虽然自己初学 JavaScript 对这个util 工具脚本还不是很理解 同时也发现JavaScript真的很强大，很灵活，相对于java它真的太灵活了，但我相信随着我学习的深入及实践的增多，我会慢慢的理解它的！
分享到：
相关推荐
This brief book explains the advantages of the object model, inheritance, both classical and prototypical, and shows how these concepts can be implemented in JavaScript. It also shows how object ...
Classical Inheritance in JavaScript。 Crockford是JavaScript开发社区最知名的权威，是JSON、JSLint、JSMin和ADSafe之父，是《[removed] The Good Parts》的作者。 现在是Yahoo的资深JavaScript架构师，参与YUI的...
classical inheritance pattern allows inheritance by creating a blueprintlike form that objects follow during inheritance. However, the prototypal inheritance pattern means copying the objects and ...
The classical inheritance pattern allows inheritance by creating a blueprint-like form that objects follow during inheritance. However, the prototypal inheritance pattern means copying the objects ...
3. 使用IE运行Inheritance for Javascript.html文档之后，查看源代码，该代码说明了怎样在JavaScript实现类的继承：使用prototype inheritance（原型继承方式）和classical inheritance（古典继承方式）。...
If you want to write beautiful, structured, and maintainable JavaScript code, this guide shows you how to apply both classical and modern design patterns to the language. The patterns in this book ...
##Augment 简介The world's smallest and fastest classical JavaScript inheritance pattern, augment, is a seven line function which allows you to write CoffeeScript style classes with a flair of ...
### 三、组合继承（Classical Inheritance） 在JavaScript中，通常结合构造函数继承和原型继承来实现更完善的继承机制，如上例所示。这样，不仅可以继承构造函数的属性，还可以继承原型的属性和方法。 ### 四、...