JavaScript继承详解

面向对象与基于对象
在传统面向对象的语言中，有两个非常重要的概念 - 类和实例。 类定义了一类事物公共的行为和方法；而实例则是类的一个具体实现。 我们还知道，面向对象编程有三个重要的概念 - 封装、继承和多态。
但是在JavaScript的世界中，所有的这一切特性似乎都不存在。 因为JavaScript本身不是面向对象的语言，而是基于对象的语言。 这里面就有一些有趣的特性，比如JavaScript中所有事物都是对象， 包括字符串、数组、日期、数字，甚至是函数，比如下面这个例子：


1
2
3
4
5
6
7
8
9
10		 // 定义一个函数 - add
function add(a, b) {
    add.invokeTimes++;
    return a + b;
}
// 因为函数本身也是对象，这里为函数add定义一个属性，用来记录此函数被调用的次数
add.invokeTimes = 0;
add(1 + 1);
add(2 + 3);
console.log(add.invokeTimes); // 2



模拟JavaScript中类和继承在面向对象的语言中，我们使用类来创建一个自定义对象。然而JavaScript中所有事物都是对象，那么用什么办法来创建自定义对象呢？
这就需要引入另外一个概念 - 原型（prototype），我们可以简单的把prototype看做是一个模版，新创建的自定义对象都是这个模版（prototype）的一个拷贝 （实际上不是拷贝而是链接，只不过这种链接是不可见，给人们的感觉好像是拷贝）。
让我们看一下通过prototype创建自定义对象的一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14		 // 构造函数
   function Person(name, sex) {
       this.name = name;
       this.sex = sex;
   }
   // 定义Person的原型，原型中的属性可以被自定义对象引用
   Person.prototype = {
       getName: function() {
           return this.name;
       },
       getSex: function() {
           return this.sex;
       }
   }


这里我们把函数Person称为构造函数，也就是创建自定义对象的函数。可以看出，JavaScript通过构造函数和原型的方式模拟实现了类的功能。
创建自定义对象（实例化类）的代码：

1
2
3
4
5		 var zhang = new Person("ZhangSan", "man");
console.log(zhang.getName()); // "ZhangSan"
var chun = new Person("ChunHua", "woman");
console.log(chun.getName()); // "ChunHua"


当代码var zhang = new Person("ZhangSan", "man")执行时，其实内部做了如下几件事情：


  • 创建一个空白对象（new Object()）。
  • 拷贝Person.prototype中的属性（键值对）到这个空对象中（我们前面提到，内部实现时不是拷贝而是一个隐藏的链接）。
  • 将这个对象通过this关键字传递到构造函数中并执行构造函数。
  • 将这个对象赋值给变量zhang。


为了证明prototype模版并不是被拷贝到实例化的对象中，而是一种链接的方式，请看如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14		 function Person(name, sex) {
    this.name = name;
    this.sex = sex;
}
Person.prototype.age = 20;
var zhang = new Person("ZhangSan", "man");
console.log(zhang.age); // 20
// 覆盖prototype中的age属性
zhang.age = 19;
console.log(zhang.age); // 19
delete zhang.age;
// 在删除实例属性age后，此属性值又从prototype中获取
console.log(zhang.age); // 20


这种在JavaScript内部实现的隐藏的prototype链接，是JavaScript赖以生存的温润土壤， 也是模拟实现继承的基础。

如何在JavaScript中实现简单的继承？
下面的例子将创建一个雇员类Employee，它从Person继承了原型prototype中的所有属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14		 function Employee(name, sex, employeeID) {
    this.name = name;
    this.sex = sex;
    this.employeeID = employeeID;
}
// 将Employee的原型指向Person的一个实例
// 因为Person的实例可以调用Person原型中的方法, 所以Employee的实例也可以调用Person原型中的所有属性。
Employee.prototype = new Person();
Employee.prototype.getEmployeeID = function() {
    return this.employeeID;
};
var zhang = new Employee("ZhangSan", "man", "1234");
console.log(zhang.getName()); // "ZhangSan



上面关于继承的实现很粗糙，并且存在很多问题：


  • 在创建Employee构造函数和原型（以后简称类）时，就对Person进行了实例化，这是不合适的。
  • Employee的构造函数没法调用父类Person的构造函数，导致在Employee构造函数中对name和sex属性的重复赋值。
  • Employee中的函数会覆盖Person中的同名函数，没有重载的机制（和上一条是一个类型的问题）。
  • 创建JavaScript类的语法过于零散，不如C#/Java中的语法优雅。
  • 实现中有constructor属性的指向错误，这个会在第二篇文章中讨论。

我们会在第三章完善这个例子。

JavaScript继承的实现正因为JavaScript本身没有完整的类和继承的实现，并且我们也看到通过手工实现的方式存在很多问题， 因此对于这个富有挑战性的任务网上已经有很多实现了：


  • Douglas Crockford - Prototypal Inheritance in JavaScript
  • Douglas Crockford - Classical Inheritance in JavaScript
  • John Resig - Simple JavaScript Inheritance
  • Dean Edwards - A Base Class for JavaScript Inheritance
  • Prototype
  • Mootools
  • Extjs

这个系列的文章将会逐一深入分析这些实现，最终达到对JavaScript中如何实现类和继承有一个深入的了解。

下一章我们将会介绍在类实现中的相关知识，比如this、constructor、prototype等。

这一章我们将会重点介绍JavaScript中几个重要的属性（this、constructor、prototype）， 这些属性对于我们理解如何实现JavaScript中的类和继承起着至关重要的作用。


this
this表示当前对象，如果在全局作用范围内使用this，则指代当前页面对象window； 如果在函数中使用this，则this指代什么是根据运行时此函数在什么对象上被调用。 我们还可以使用apply和call两个全局方法来改变函数中this的具体指向。
先看一个在全局作用范围内使用this的例子：

  1.         <script type="text/javascript">
  2.             console.log(this === window);  // true
  3.             console.log(window.alert === this.alert);  // true
  4.             console.log(this.parseInt("021", 10));  // 10
  5.         </script>
复制代码

函数中的this是在运行时决定的，而不是函数定义时，如下：

  1.         // 定义一个全局函数
  2.         function foo() {
  3.             console.log(this.fruit);
  4.         }
  5.         // 定义一个全局变量，等价于window.fruit = "apple";
  6.         var fruit = "apple";
  7.         // 此时函数foo中this指向window对象
  8.         // 这种调用方式和window.foo();是完全等价的
  9.         foo();  // "apple"

  11.         // 自定义一个对象，并将此对象的属性foo指向全局函数foo
  12.         var pack = {
  13.             fruit: "orange",
  14.             foo: foo
  15.         };
  16.         // 此时函数foo中this指向window.pack对象
  17.         pack.foo(); // "orange"
  18.         
复制代码

全局函数apply和call可以用来改变函数中this的指向，如下：

  1.         // 定义一个全局函数
  2.         function foo() {
  3.             console.log(this.fruit);
  4.         }
  5.         
  6.         // 定义一个全局变量
  7.         var fruit = "apple";
  8.         // 自定义一个对象
  9.         var pack = {
  10.             fruit: "orange"
  11.         };
  12.         
  13.         // 等价于window.foo();
  14.         foo.apply(window);  // "apple"
  15.         // 此时foo中的this === pack
  16.         foo.apply(pack);    // "orange"
复制代码

注：apply和call两个函数的作用相同，唯一的区别是两个函数的参数定义不同。

因为在JavaScript中函数也是对象，所以我们可以看到如下有趣的例子：

  1.         // 定义一个全局函数
  2.         function foo() {
  3.             if (this === window) {
  4.                 console.log("this is window.");
  5.             }
  6.         }
  7.         
  8.         // 函数foo也是对象，所以可以定义foo的属性boo为一个函数
  9.         foo.boo = function() {
  10.             if (this === foo) {
  11.                 console.log("this is foo.");
  12.             } else if (this === window) {
  13.                 console.log("this is window.");
  14.             }
  15.         };
  16.         // 等价于window.foo();
  17.         foo();  // this is window.
  18.         
  19.         // 可以看到函数中this的指向调用函数的对象
  20.         foo.boo();  // this is foo.
  21.         
  22.         // 使用apply改变函数中this的指向
  23.         foo.boo.apply(window);  // this is window.
复制代码


prototype
我们已经在第一章中使用prototype模拟类和继承的实现。 prototype本质上还是一个JavaScript对象。 并且每个函数都有一个默认的prototype属性。
如果这个函数被用在创建自定义对象的场景中，我们称这个函数为构造函数。 比如下面一个简单的场景：


  1.         // 构造函数
  2.         function Person(name) {
  3.             this.name = name;
  4.         }
  5.         // 定义Person的原型，原型中的属性可以被自定义对象引用
  6.         Person.prototype = {
  7.             getName: function() {
  8.                 return this.name;
  9.             }
  10.         }
  11.         var zhang = new Person("ZhangSan");
  12.         console.log(zhang.getName());   // "ZhangSan"
复制代码

作为类比，我们考虑下JavaScript中的数据类型 - 字符串（String）、数字（Number）、数组（Array）、对象（Object）、日期（Date）等。 我们有理由相信，在JavaScript内部这些类型都是作为构造函数来实现的，比如：

  1.         // 定义数组的构造函数，作为JavaScript的一种预定义类型
  2.         function Array() {
  3.             // ...
  4.         }
  5.         
  6.         // 初始化数组的实例
  7.         var arr1 = new Array(1, 56, 34, 12);
  8.         // 但是，我们更倾向于如下的语法定义：
  9.         var arr2 = [1, 56, 34, 12];
  10.         
复制代码

同时对数组操作的很多方法（比如concat、join、push）应该也是在prototype属性中定义的。
实际上，JavaScript所有的固有数据类型都具有只读的prototype属性（这是可以理解的：因为如果修改了这些类型的prototype属性，则哪些预定义的方法就消失了）， 但是我们可以向其中添加自己的扩展方法。

  1.         // 向JavaScript固有类型Array扩展一个获取最小值的方法
  2.         Array.prototype.min = function() {
  3.             var min = this[0];
  4.             for (var i = 1; i < this.length; i++) {
  5.                 if (this[i] < min) {
  6.                     min = this[i];
  7.                 }
  8.             }
  9.             return min;
  10.         };
  11.         
  12.         // 在任意Array的实例上调用min方法
  13.         console.log([1, 56, 34, 12].min());  // 1
复制代码

注意：这里有一个陷阱，向Array的原型中添加扩展方法后，当使用for-in循环数组时，这个扩展方法也会被循环出来。
下面的代码说明这一点（假设已经向Array的原型中扩展了min方法）：

  1.         var arr = [1, 56, 34, 12];
  2.         var total = 0;
  3.         for (var i in arr) {
  4.             total += parseInt(arr[i], 10);
  5.         }
  6.         console.log(total);   // NaN
复制代码

解决方法也很简单：

  1.         var arr = [1, 56, 34, 12];
  2.         var total = 0;
  3.         for (var i in arr) {
  4.             if (arr.hasOwnProperty(i)) {
  5.                 total += parseInt(arr[i], 10);
  6.             }
  7.         }
  8.         console.log(total);   // 103
复制代码


constructor
constructor始终指向创建当前对象的构造函数。比如下面例子：

  2.         // 等价于 var foo = new Array(1, 56, 34, 12);
  3.         var arr = [1, 56, 34, 12];
  4.         console.log(arr.constructor === Array); // true
  5.         // 等价于 var foo = new Function();
  6.         var Foo = function() { };
  7.         console.log(Foo.constructor === Function); // true
  8.         // 由构造函数实例化一个obj对象
  9.         var obj = new Foo();
  10.         console.log(obj.constructor === Foo); // true
  11.         
  12.         // 将上面两段代码合起来，就得到下面的结论
  13.         console.log(obj.constructor.constructor === Function); // true
普通浏览复制代码保存代码打印代码
  1.         // 等价于 var foo = new Array(1, 56, 34, 12);
  2.         var arr = [1, 56, 34, 12];
  3.         console.log(arr.constructor === Array); // true
  4.         // 等价于 var foo = new Function();
  5.         var Foo = function() { };
  6.         console.log(Foo.constructor === Function); // true
  7.         // 由构造函数实例化一个obj对象
  8.         var obj = new Foo();
  9.         console.log(obj.constructor === Foo); // true
  10.         
  11.         // 将上面两段代码合起来，就得到下面的结论
  12.         console.log(obj.constructor.constructor === Function); // true


但是当constructor遇到prototype时，有趣的事情就发生了。
我们知道每个函数都有一个默认的属性prototype，而这个prototype的constructor默认指向这个函数。如下例所示：

  1.         function Person(name) {
  2.             this.name = name;
  3.         };
  4.         Person.prototype.getName = function() {
  5.             return this.name;
  6.         };
  7.         var p = new Person("ZhangSan");
  8.         
  9.         console.log(p.constructor === Person);  // true
  10.         console.log(Person.prototype.constructor === Person); // true
  11.         // 将上两行代码合并就得到如下结果
  12.         console.log(p.constructor.prototype.constructor === Person); // true
复制代码

当时当我们重新定义函数的prototype时（注意：和上例的区别，这里不是修改而是覆盖）， constructor的行为就有点奇怪了，如下示例：

  1.         function Person(name) {
  2.             this.name = name;
  3.         };
  4.         Person.prototype = {
  5.             getName: function() {
  6.                 return this.name;
  7.             }
  8.         };
  9.         var p = new Person("ZhangSan");
  10.         console.log(p.constructor === Person);  // false
  11.         console.log(Person.prototype.constructor === Person); // false
  12.         console.log(p.constructor.prototype.constructor === Person); // false
复制代码

为什么呢？
原来是因为覆盖Person.prototype时，等价于进行如下代码操作：

  1.         Person.prototype = new Object({
  2.             getName: function() {
  3.                 return this.name;
  4.             }
  5.         });
复制代码

而constructor始终指向创建自身的构造函数，所以此时Person.prototype.constructor === Object，即是：

  1.         function Person(name) {
  2.             this.name = name;
  3.         };
  4.         Person.prototype = {
  5.             getName: function() {
  6.                 return this.name;
  7.             }
  8.         };
  9.         var p = new Person("ZhangSan");
  10.         console.log(p.constructor === Object);  // true
  11.         console.log(Person.prototype.constructor === Object); // true
  12.         console.log(p.constructor.prototype.constructor === Object); // true
复制代码

怎么修正这种问题呢？方法也很简单，重新覆盖Person.prototype.constructor即可：

  1.         function Person(name) {
  2.             this.name = name;
  3.         };
  4.         Person.prototype = new Object({
  5.             getName: function() {
  6.                 return this.name;
  7.             }
  8.         });
  9.         Person.prototype.constructor = Person;
  10.         var p = new Person("ZhangSan");
  11.         console.log(p.constructor === Person);  // true
  12.         console.log(Person.prototype.constructor === Person); // true
  13.         console.log(p.constructor.prototype.constructor === Person); // true
复制代码


下一章我们将会对第一章提到的Person-Employee类和继承的实现进行完善。
在第一章中，我们使用构造函数和原型的方式在JavaScript的世界中实现了类和继承， 但是存在很多问题。这一章我们将会逐一分析这些问题，并给出解决方案。
注：本章中的jClass的实现参考了Simple JavaScript Inheritance的做法。
首先让我们来回顾一下第一章中介绍的例子：

  1. function Person(name) {
  2. this.name = name;
  3. }
  4. Person.prototype = {
  5. getName: function() {
  6. return this.name;
  7. }
  8. }

  10. function Employee(name, employeeID) {
  11. this.name = name;
  12. this.employeeID = employeeID;
  13. }
  14. Employee.prototype = new Person();
  15. Employee.prototype.getEmployeeID = function() {
  16. return this.employeeID;
  17. };
  18. var zhang = new Employee("ZhangSan", "1234");
  19. console.log(zhang.getName()); // "ZhangSan"
复制代码


修正constructor的指向错误
从上一篇文章中关于constructor的描述，我们知道Employee实例的constructor会有一个指向错误，如下所示：

  1. var zhang = new Employee("ZhangSan", "1234");
  2. console.log(zhang.constructor === Employee); // false
  3. console.log(zhang.constructor === Object); // true
复制代码

我们需要简单的修正：

  1. 我们需要简单的修正：
  2. function Employee(name, employeeID) {
  3. this.name = name;
  4. this.employeeID = employeeID;
  5. }
  6. Employee.prototype = new Person();
  7. Employee.prototype.constructor = Employee;
  8. Employee.prototype.getEmployeeID = function() {
  9. return this.employeeID;
  10. };
  11. var zhang = new Employee("ZhangSan", "1234");
  12. console.log(zhang.constructor === Employee); // true
  13. console.log(zhang.constructor === Object); // false
复制代码

创建Employee类时实例化Person是不合适的 但另一方面，我们又必须依赖于这种机制来实现继承。 解决办法是不在构造函数中初始化数据，而是提供一个原型方法（比如init）来初始化数据。

  1. // 空的构造函数
  2. function Person() {
  3. }
  4. Person.prototype = {
  5. init: function(name) {
  6. this.name = name;
  7. },
  8. getName: function() {
  9. return this.name;
  10. }
  11. }
  12. // 空的构造函数
  13. function Employee() {
  14. }
  15. // 创建类的阶段不会初始化父类的数据，因为Person是一个空的构造函数
  16. Employee.prototype = new Person();
  17. Employee.prototype.constructor = Employee;
  18. Employee.prototype.init = function(name, employeeID) {
  19. this.name = name;
  20. this.employeeID = employeeID;
  21. };
  22. Employee.prototype.getEmployeeID = function() {
  23. return this.employeeID;
  24. };
复制代码

这种方式下，必须在实例化一个对象后手工调用init函数，如下：

  1. var zhang = new Employee();
  2. zhang.init("ZhangSan", "1234");
  3. console.log(zhang.getName()); // "ZhangSan"
复制代码


如何自动调用init函数？
必须达到两个效果，构造类时不要调用init函数和实例化对象时自动调用init函数。看来我们需要在调用空的构造函数时有一个状态标示。

  1. // 创建一个全局的状态标示 - 当前是否处于类的构造阶段
  2. var initializing = false;
  3. function Person() {
  4. if (!initializing) {
  5. this.init.apply(this, arguments);
  6. }
  7. }
  8. Person.prototype = {
  9. init: function(name) {
  10. this.name = name;
  11. },
  12. getName: function() {
  13. return this.name;
  14. }
  15. }
  16. function Employee() {
  17. if (!initializing) {
  18. this.init.apply(this, arguments);
  19. }
  20. }
  21. // 标示当前进入类的创建阶段，不会调用init函数
  22. initializing = true;
  23. Employee.prototype = new Person();
  24. Employee.prototype.constructor = Employee;
  25. initializing = false;
  26. Employee.prototype.init = function(name, employeeID) {
  27. this.name = name;
  28. this.employeeID = employeeID;
  29. };
  30. Employee.prototype.getEmployeeID = function() {
  31. return this.employeeID;
  32. };

  34. // 初始化类实例时，自动调用类的原型函数init，并向init中传递参数
  35. var zhang = new Employee("ZhangSan", "1234");
  36. console.log(zhang.getName()); // "ZhangSan"
复制代码

但是这样就必须引入全局变量，这是一个不好的信号。

如何避免引入全局变量initializing？
我们需要引入一个全局的函数来简化类的创建过程，同时封装内部细节避免引入全局变量。

  1. // 当前是否处于创建类的阶段
  2. var initializing = false;
  3. function jClass(baseClass, prop) {
  4. // 只接受一个参数的情况 - jClass(prop)
  5. if (typeof (baseClass) === "object") {
  6. prop = baseClass;
  7. baseClass = null;
  8. }
  9. // 本次调用所创建的类（构造函数）
  10. function F() {
  11. // 如果当前处于实例化类的阶段，则调用init原型函数
  12. if (!initializing) {
  13. this.init.apply(this, arguments);
  14. }
  15. }
  16. // 如果此类需要从其它类扩展
  17. if (baseClass) {
  18. initializing = true;
  19. F.prototype = new baseClass();
  20. F.prototype.constructor = F;
  21. initializing = false;
  22. }
  23. // 覆盖父类的同名函数
  24. for (var name in prop) {
  25. if (prop.hasOwnProperty(name)) {
  26. F.prototype[name] = prop[name];
  27. }
  28. }
  29. return F;
  30. };
复制代码

使用jClass函数来创建类和继承类的方法：

  1. var Person = jClass({
  2. init: function(name) {
  3. this.name = name;
  4. },
  5. getName: function() {
  6. return this.name;
  7. }
  8. });
  9. var Employee = jClass(Person, {
  10. init: function(name, employeeID) {
  11. this.name = name;
  12. this.employeeID = employeeID;
  13. },
  14. getEmployeeID: function() {
  15. return this.employeeID;
  16. }
  17. });

  19. var zhang = new Employee("ZhangSan", "1234");
  20. console.log(zhang.getName()); // "ZhangSan"
复制代码

OK，现在创建类和实例化类的方式看起来优雅多了。 但是这里面还存在明显的瑕疵，Employee的初始化函数init无法调用父类的同名方法。

【如何调用父类的同名方法？】我们可以通过为实例化对象提供一个base的属性，来指向父类（构造函数）的原型，如下：

  1. // 当前是否处于创建类的阶段
  2. var initializing = false;
  3. function jClass(baseClass, prop) {
  4. // 只接受一个参数的情况 - jClass(prop)
  5. if (typeof (baseClass) === "object") {
  6. prop = baseClass;
  7. baseClass = null;
  8. }
  9. // 本次调用所创建的类（构造函数）
  10. function F() {
  11. // 如果当前处于实例化类的阶段，则调用init原型函数
  12. if (!initializing) {
  13. // 如果父类存在，则实例对象的base指向父类的原型
  14. // 这就提供了在实例对象中调用父类方法的途径
  15. if (baseClass) {
  16. this.base = baseClass.prototype;
  17. }
  18. this.init.apply(this, arguments);
  19. }
  20. }
  21. // 如果此类需要从其它类扩展
  22. if (baseClass) {
  23. initializing = true;
  24. F.prototype = new baseClass();
  25. F.prototype.constructor = F;
  26. initializing = false;
  27. }
  28. // 覆盖父类的同名函数
  29. for (var name in prop) {
  30. if (prop.hasOwnProperty(name)) {
  31. F.prototype[name] = prop[name];
  32. }
  33. }
  34. return F;
  35. };
复制代码

【调用方式】

  1. var Person = jClass({
  2. init: function(name) {
  3. this.name = name;
  4. },
  5. getName: function() {
  6. return this.name;
  7. }
  8. });
  9. var Employee = jClass(Person, {
  10. init: function(name, employeeID) {
  11. // 调用父类的原型函数init，注意使用apply函数修改init的this指向
  12. this.base.init.apply(this, [name]);
  13. this.employeeID = employeeID;
  14. },
  15. getEmployeeID: function() {
  16. return this.employeeID;
  17. },
  18. getName: function() {
  19. // 调用父类的原型函数getName
  20. return "Employee name: " + this.base.getName.apply(this);
  21. }
  22. });

  24. var zhang = new Employee("ZhangSan", "1234");
  25. console.log(zhang.getName()); // "Employee name: ZhangSan"
复制代码


目前为止，我们已经修正了在第一章手工实现继承的种种弊端。 通过我们自定义的jClass函数来创建类和子类，通过原型方法init初始化数据， 通过实例属性base来调用父类的原型函数。
唯一的缺憾是调用父类的代码太长，并且不好理解， 如果能够按照如下的方式调用岂不是更妙：

  1. var Employee = jClass(Person, {
  2. init: function(name, employeeID) {
  3. // 如果能够这样调用，就再好不过了
  4. this.base(name);
  5. this.employeeID = employeeID;
  6. }
  7. });
复制代码


优化jClass函数

  1. // 当前是否处于创建类的阶段
  2. var initializing = false;
  3. function jClass(baseClass, prop) {
  4. // 只接受一个参数的情况 - jClass(prop)
  5. if (typeof (baseClass) === "object") {
  6. prop = baseClass;
  7. baseClass = null;
  8. }
  9. // 本次调用所创建的类（构造函数）
  10. function F() {
  11. // 如果当前处于实例化类的阶段，则调用init原型函数
  12. if (!initializing) {
  13. // 如果父类存在，则实例对象的baseprototype指向父类的原型
  14. // 这就提供了在实例对象中调用父类方法的途径
  15. if (baseClass) {
  16. this.baseprototype = baseClass.prototype;
  17. }
  18. this.init.apply(this, arguments);
  19. }
  20. }
  21. // 如果此类需要从其它类扩展
  22. if (baseClass) {
  23. initializing = true;
  24. F.prototype = new baseClass();
  25. F.prototype.constructor = F;
  26. initializing = false;
  27. }
  28. // 覆盖父类的同名函数
  29. for (var name in prop) {
  30. if (prop.hasOwnProperty(name)) {
  31. // 如果此类继承自父类baseClass并且父类原型中存在同名函数name
  32. if (baseClass &&
  33. typeof (prop[name]) === "function" &&
  34. typeof (F.prototype[name]) === "function") {

  36. // 重定义函数name -
  37. // 首先在函数上下文设置this.base指向父类原型中的同名函数
  38. // 然后调用函数prop[name]，返回函数结果

  40. // 注意：这里的自执行函数创建了一个上下文，这个上下文返回另一个函数，
  41. // 此函数中可以应用此上下文中的变量，这就是闭包（Closure）。
  42. // 这是JavaScript框架开发中常用的技巧。
  43. F.prototype[name] = (function(name, fn) {
  44. return function() {
  45. this.base = baseClass.prototype[name];
  46. return fn.apply(this, arguments);
  47. };
  48. })(name, prop[name]);

  50. } else {
  51. F.prototype[name] = prop[name];
  52. }
  53. }
  54. }
  55. return F;
  56. };
复制代码

此时，创建类与子类以及调用方式都显得非常优雅，请看：

  1. var Person = jClass({
  2. init: function(name) {
  3. this.name = name;
  4. },
  5. getName: function() {
  6. return this.name;
  7. }
  8. });
  9. var Employee = jClass(Person, {
  10. init: function(name, employeeID) {
  11. this.base(name);
  12. this.employeeID = employeeID;
  13. },
  14. getEmployeeID: function() {
  15. return this.employeeID;
  16. },
  17. getName: function() {
  18. return "Employee name: " + this.base();
  19. }
  20. });

  22. var zhang = new Employee("ZhangSan", "1234");
  23. console.log(zhang.getName()); // "Employee name: ZhangSan"
复制代码

至此，我们已经创建了一个完善的函数jClass， 帮助我们在JavaScript中以比较优雅的方式实现类和继承。
在以后的章节中，我们会陆续分析网上一些比较流行的JavaScript类和继承的实现。 不过万变不离其宗，那些实现也无非把我们这章中提到的概念颠来簸去的“炒作”， 为的就是一种更优雅的调用方式。

在本章中，我们将分析Douglas Crockford关于JavaScript继承的一个实现 - Classical Inheritance in JavaScript。
Crockford是JavaScript开发社区最知名的权威，是JSON、JSLint、JSMin和ADSafe之父，是《JavaScript: The Good Parts》的作者。
现在是Yahoo的资深JavaScript架构师，参与YUI的设计开发。 这里有一篇文章详细介绍了Crockford的生平和著作。
当然Crockford也是我等小辈崇拜的对象。
调用方式 首先让我们看下使用Crockford式继承的调用方式：
注意：代码中的method、inherits、uber都是自定义的对象，我们会在后面的代码分析中详解。

  1.         // 定义Person类
  2.         function Person(name) {
  3.             this.name = name;
  4.         }
  5.         // 定义Person的原型方法
  6.         Person.method("getName", function() {
  7.             return this.name;
  8.         });  
  9.         
  10.         // 定义Employee类
  11.         function Employee(name, employeeID) {
  12.             this.name = name;
  13.             this.employeeID = employeeID;
  14.         }
  15.         // 指定Employee类从Person类继承
  16.         Employee.inherits(Person);
  17.         // 定义Employee的原型方法
  18.         Employee.method("getEmployeeID", function() {
  19.             return this.employeeID;
  20.         });
  21.         Employee.method("getName", function() {
  22.             // 注意，可以在子类中调用父类的原型方法
  23.             return "Employee name: " + this.uber("getName");
  24.         });
  25.         // 实例化子类
  26.         var zhang = new Employee("ZhangSan", "1234");
  27.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码
这里面有几处不得不提的硬伤：
  • 子类从父类继承的代码必须在子类和父类都定义好之后进行，并且必须在子类原型方法定义之前进行。
  • 虽然子类方法体中可以调用父类的方法，但是子类的构造函数无法调用父类的构造函数。
  • 代码的书写不够优雅，比如原型方法的定义以及调用父类的方法（不直观）。

当然Crockford的实现还支持子类中的方法调用带参数的父类方法，如下例子：
  1.         function Person(name) {
  2.             this.name = name;
  3.         }
  4.         Person.method("getName", function(prefix) {
  5.             return prefix + this.name;
  6.         });

  8.         function Employee(name, employeeID) {
  9.             this.name = name;
  10.             this.employeeID = employeeID;
  11.         }
  12.         Employee.inherits(Person);
  13.         Employee.method("getName", function() {
  14.             // 注意，uber的第一个参数是要调用父类的函数名称，后面的参数都是此函数的参数
  15.             // 个人觉得这样方式不如这样调用来的直观：this.uber("Employee name: ")
  16.             return this.uber("getName", "Employee name: ");
  17.         });
  18.         var zhang = new Employee("ZhangSan", "1234");
  19.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码

代码分析 首先method函数的定义就很简单了：
  2.         Function.prototype.method = function(name, func) {
  3.             // this指向当前函数，也即是typeof(this) === "function"
  4.             this.prototype[name] = func;
  5.             return this;
  6.         };
  7.         
普通浏览复制代码保存代码打印代码
  1.         Function.prototype.method = function(name, func) {
  2.             // this指向当前函数，也即是typeof(this) === "function"
  3.             this.prototype[name] = func;
  4.             return this;
  5.         };
  6.         
要特别注意这里this的指向。当我们看到this时，不能仅仅关注于当前函数，而应该想到当前函数的调用方式。 比如这个例子中的method我们不会通过new的方式调用，所以method中的this指向的是当前函数。

inherits函数的定义有点复杂：
  2.         Function.method('inherits', function (parent) {
  3.             // 关键是这一段：this.prototype = new parent()，这里实现了原型的引用
  4.             var d = {}, p = (this.prototype = new parent());
  5.             
  6.             // 只为子类的原型增加uber方法，这里的Closure是为了在调用uber函数时知道当前类的父类的原型（也即是变量 - v）
  7.             this.method('uber', function uber(name) {
  8.                 // 这里考虑到如果name是存在于Object.prototype中的函数名的情况
  9.                 // 比如 "toString" in {} === true
  10.                 if (!(name in d)) {
  11.                     // 通过d[name]计数，不理解具体的含义
  12.                     d[name] = 0;
  13.                 }        
  14.                 var f, r, t = d[name], v = parent.prototype;
  15.                 if (t) {
  16.                     while (t) {
  17.                         v = v.constructor.prototype;
  18.                         t -= 1;
  19.                     }
  20.                     f = v[name];
  21.                 } else {
  22.                     // 个人觉得这段代码有点繁琐，既然uber的含义就是父类的函数，那么f直接指向v[name]就可以了
  23.                     f = p[name];
  24.                     if (f == this[name]) {
  25.                         f = v[name];
  26.                     }
  27.                 }
  28.                 d[name] += 1;
  29.                 // 执行父类中的函数name，但是函数中this指向当前对象
  30.                 // 同时注意使用Array.prototype.slice.apply的方式对arguments进行截断（因为arguments不是标准的数组，没有slice方法）
  31.                 r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
  32.                 d[name] -= 1;
  33.                 return r;
  34.             });
  35.             return this;
  36.         });
普通浏览复制代码保存代码打印代码
  1.         Function.method('inherits', function (parent) {
  2.             // 关键是这一段：this.prototype = new parent()，这里实现了原型的引用
  3.             var d = {}, p = (this.prototype = new parent());
  4.             
  5.             // 只为子类的原型增加uber方法，这里的Closure是为了在调用uber函数时知道当前类的父类的原型（也即是变量 - v）
  6.             this.method('uber', function uber(name) {
  7.                 // 这里考虑到如果name是存在于Object.prototype中的函数名的情况
  8.                 // 比如 "toString" in {} === true
  9.                 if (!(name in d)) {
  10.                     // 通过d[name]计数，不理解具体的含义
  11.                     d[name] = 0;
  12.                 }        
  13.                 var f, r, t = d[name], v = parent.prototype;
  14.                 if (t) {
  15.                     while (t) {
  16.                         v = v.constructor.prototype;
  17.                         t -= 1;
  18.                     }
  19.                     f = v[name];
  20.                 } else {
  21.                     // 个人觉得这段代码有点繁琐，既然uber的含义就是父类的函数，那么f直接指向v[name]就可以了
  22.                     f = p[name];
  23.                     if (f == this[name]) {
  24.                         f = v[name];
  25.                     }
  26.                 }
  27.                 d[name] += 1;
  28.                 // 执行父类中的函数name，但是函数中this指向当前对象
  29.                 // 同时注意使用Array.prototype.slice.apply的方式对arguments进行截断（因为arguments不是标准的数组，没有slice方法）
  30.                 r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
  31.                 d[name] -= 1;
  32.                 return r;
  33.             });
  34.             return this;
  35.         });
注意，在inherits函数中还有一个小小的BUG，那就是没有重定义constructor的指向，所以会发生如下的错误：

  1.         var zhang = new Employee("ZhangSan", "1234");
  2.         console.log(zhang.getName());   // "Employee name: ZhangSan"
  3.         console.log(zhang.constructor === Employee);    // false
  4.         console.log(zhang.constructor === Person);      // true
复制代码

改进建议 根据前面的分析，个人觉得method函数必要性不大，反而容易混淆视线。 而inherits方法可以做一些瘦身（因为Crockford可能考虑更多的情况，原文中介绍了好几种使用inherits的方式，而我们只关注其中的一种）， 并修正了constructor的指向错误。
  2.         Function.prototype.inherits = function(parent) {
  3.             this.prototype = new parent();
  4.             this.prototype.constructor = this;
  5.             this.prototype.uber = function(name) {
  6.                 f = parent.prototype[name];
  7.                 return f.apply(this, Array.prototype.slice.call(arguments, 1));
  8.             };
  9.         };
  10.         
普通浏览复制代码保存代码打印代码
  1.         Function.prototype.inherits = function(parent) {
  2.             this.prototype = new parent();
  3.             this.prototype.constructor = this;
  4.             this.prototype.uber = function(name) {
  5.                 f = parent.prototype[name];
  6.                 return f.apply(this, Array.prototype.slice.call(arguments, 1));
  7.             };
  8.         };
  9.         
调用方式：
  1.         function Person(name) {
  2.             this.name = name;
  3.         }
  4.         Person.prototype.getName = function(prefix) {
  5.             return prefix + this.name;
  6.         };
  7.         function Employee(name, employeeID) {
  8.             this.name = name;
  9.             this.employeeID = employeeID;
  10.         }
  11.         Employee.inherits(Person);
  12.         Employee.prototype.getName = function() {
  13.             return this.uber("getName", "Employee name: ");
  14.         };
  15.         var zhang = new Employee("ZhangSan", "1234");
  16.         console.log(zhang.getName());   // "Employee name: ZhangSan"
  17.         console.log(zhang.constructor === Employee);   // true
复制代码
有点意思 在文章的结尾，Crockford居然放出了这样的话：
I have been writing JavaScript for 8 years now, and I have never once found need to use an uber function. The super idea is fairly important in the classical pattern, but it appears to be unnecessary in the prototypal and functional patterns. I now see my early attempts to support the classical model in JavaScript as a mistake.
可见Crockford对在JavaScript中实现面向对象的编程不赞成，并且声称JavaScript应该按照原型和函数的模式（the prototypal and functional patterns）进行编程。
不过就我个人而言，在复杂的场景中如果有面向对象的机制会方便的多。
但谁有能担保呢，即使像jQuery UI这样的项目也没用到继承，而另一方面，像Extjs、Qooxdoo则极力倡导一种面向对象的JavaScript。 甚至Cappuccino项目还发明一种Objective-J语言来实践面向对象的JavaScript。
在本章中，我们将分析John Resig关于JavaScript继承的一个实现 - Simple JavaScript Inheritance。
John Resig作为jQuery的创始人而声名在外。是《Pro JavaScript Techniques》的作者，而且Resig将会在今年秋天推出一本书《JavaScript Secrets》，非常期待。

调用方式 调用方式非常优雅：
注意：代码中的Class、extend、_super都是自定义的对象，我们会在后面的代码分析中详解。
  1.         var Person = Class.extend({
  2.             // init是构造函数
  3.             init: function(name) {
  4.                 this.name = name;
  5.             },
  6.             getName: function() {
  7.                 return this.name;
  8.             }
  9.         });
  10.         // Employee类从Person类继承
  11.         var Employee = Person.extend({
  12.             // init是构造函数
  13.             init: function(name, employeeID) {
  14.                 //  在构造函数中调用父类的构造函数
  15.                 this._super(name);
  16.                 this.employeeID = employeeID;
  17.             },
  18.             getEmployeeID: function() {
  19.                 return this.employeeID;
  20.             },
  21.             getName: function() {
  22.                 //  调用父类的方法
  23.                 return "Employee name: " + this._super();
  24.             }
  25.         });

  27.         var zhang = new Employee("ZhangSan", "1234");
  28.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码
说实话，对于完成本系列文章的目标-继承-而言，真找不到什么缺点。方法一如jQuery一样简洁明了。

代码分析 为了一个漂亮的调用方式，内部实现的确复杂了很多，不过这些也是值得的 - 一个人的思考带给了无数程序员快乐的微笑 - 嘿嘿，有点肉麻。
不过其中的一段代码的确迷惑我一段时间：
  1.         fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
复制代码
我曾在几天前的博客中写过一篇文章专门阐述这个问题，有兴趣可以向前翻一翻。
  2.         // 自执行的匿名函数创建一个上下文，避免引入全局变量
  3.         (function() {
  4.             // initializing变量用来标示当前是否处于类的创建阶段，
  5.             // - 在类的创建阶段是不能调用原型方法init的
  6.             // - 我们曾在本系列的第三篇文章中详细阐述了这个问题
  7.             // fnTest是一个正则表达式，可能的取值为（/\b_super\b/ 或 /.*/）
  8.             // - 对 /xyz/.test(function() { xyz; }) 的测试是为了检测浏览器是否支持test参数为函数的情况
  9.             // - 不过我对IE7.0,Chrome2.0,FF3.5进行了测试，此测试都返回true。
  10.             // - 所以我想这样对fnTest赋值大部分情况下也是对的：fnTest = /\b_super\b/;
  11.             var initializing = false, fnTest = /xyz/.test(function() { xyz; }) ? /\b_super\b/ : /.*/;
  12.             // 基类构造函数
  13.             // 这里的this是window，所以这整段代码就向外界开辟了一扇窗户 - window.Class
  14.             this.Class = function() { };
  15.             // 继承方法定义
  16.             Class.extend = function(prop) {
  17.                 // 这个地方很是迷惑人，还记得我在本系列的第二篇文章中提到的么
  18.                 // - this具体指向什么不是定义时能决定的，而是要看此函数是怎么被调用的
  19.                 // - 我们已经知道extend肯定是作为方法调用的，而不是作为构造函数
  20.                 // - 所以这里this指向的不是Object，而是Function（即是Class），那么this.prototype就是父类的原型对象
  21.                 // - 注意：_super指向父类的原型对象，我们会在后面的代码中多次碰见这个变量
  22.                 var _super = this.prototype;
  23.                 // 通过将子类的原型指向父类的一个实例对象来完成继承
  24.                 // - 注意：this是基类构造函数（即是Class）
  25.                 initializing = true;
  26.                 var prototype = new this();
  27.                 initializing = false;
  28.                 // 我觉得这段代码是经过作者优化过的，所以读起来非常生硬，我会在后面详解
  29.                 for (var name in prop) {
  30.                     prototype[name] = typeof prop[name] == "function" &&
  31.                         typeof _super[name] == "function" && fnTest.test(prop[name]) ?
  32.                         (function(name, fn) {
  33.                             return function() {
  34.                                 var tmp = this._super;
  35.                                 this._super = _super[name];
  36.                                 var ret = fn.apply(this, arguments);
  37.                                 this._super = tmp;
  38.                                 return ret;
  39.                             };
  40.                         })(name, prop[name]) :
  41.                         prop[name];
  42.                 }
  43.                 // 这个地方可以看出，Resig很会伪装哦
  44.                 // - 使用一个同名的局部变量来覆盖全局变量，很是迷惑人
  45.                 // - 如果你觉得拗口的话，完全可以使用另外一个名字，比如function F()来代替function Class()
  46.                 // - 注意：这里的Class不是在最外层定义的那个基类构造函数
  47.                 function Class() {
  48.                     // 在类的实例化时，调用原型方法init
  49.                     if (!initializing && this.init)
  50.                         this.init.apply(this, arguments);
  51.                 }
  52.                 // 子类的prototype指向父类的实例（完成继承的关键）
  53.                 Class.prototype = prototype;
  54.                 // 修正constructor指向错误
  55.                 Class.constructor = Class;
  56.                 // 子类自动获取extend方法，arguments.callee指向当前正在执行的函数
  57.                 Class.extend = arguments.callee;
  58.                 return Class;
  59.             };
  60.         })();
普通浏览复制代码保存代码打印代码
  1.         // 自执行的匿名函数创建一个上下文，避免引入全局变量
  2.         (function() {
  3.             // initializing变量用来标示当前是否处于类的创建阶段，
  4.             // - 在类的创建阶段是不能调用原型方法init的
  5.             // - 我们曾在本系列的第三篇文章中详细阐述了这个问题
  6.             // fnTest是一个正则表达式，可能的取值为（/\b_super\b/ 或 /.*/）
  7.             // - 对 /xyz/.test(function() { xyz; }) 的测试是为了检测浏览器是否支持test参数为函数的情况
  8.             // - 不过我对IE7.0,Chrome2.0,FF3.5进行了测试，此测试都返回true。
  9.             // - 所以我想这样对fnTest赋值大部分情况下也是对的：fnTest = /\b_super\b/;
  10.             var initializing = false, fnTest = /xyz/.test(function() { xyz; }) ? /\b_super\b/ : /.*/;
  11.             // 基类构造函数
  12.             // 这里的this是window，所以这整段代码就向外界开辟了一扇窗户 - window.Class
  13.             this.Class = function() { };
  14.             // 继承方法定义
  15.             Class.extend = function(prop) {
  16.                 // 这个地方很是迷惑人，还记得我在本系列的第二篇文章中提到的么
  17.                 // - this具体指向什么不是定义时能决定的，而是要看此函数是怎么被调用的
  18.                 // - 我们已经知道extend肯定是作为方法调用的，而不是作为构造函数
  19.                 // - 所以这里this指向的不是Object，而是Function（即是Class），那么this.prototype就是父类的原型对象
  20.                 // - 注意：_super指向父类的原型对象，我们会在后面的代码中多次碰见这个变量
  21.                 var _super = this.prototype;
  22.                 // 通过将子类的原型指向父类的一个实例对象来完成继承
  23.                 // - 注意：this是基类构造函数（即是Class）
  24.                 initializing = true;
  25.                 var prototype = new this();
  26.                 initializing = false;
  27.                 // 我觉得这段代码是经过作者优化过的，所以读起来非常生硬，我会在后面详解
  28.                 for (var name in prop) {
  29.                     prototype[name] = typeof prop[name] == "function" &&
  30.                         typeof _super[name] == "function" && fnTest.test(prop[name]) ?
  31.                         (function(name, fn) {
  32.                             return function() {
  33.                                 var tmp = this._super;
  34.                                 this._super = _super[name];
  35.                                 var ret = fn.apply(this, arguments);
  36.                                 this._super = tmp;
  37.                                 return ret;
  38.                             };
  39.                         })(name, prop[name]) :
  40.                         prop[name];
  41.                 }
  42.                 // 这个地方可以看出，Resig很会伪装哦
  43.                 // - 使用一个同名的局部变量来覆盖全局变量，很是迷惑人
  44.                 // - 如果你觉得拗口的话，完全可以使用另外一个名字，比如function F()来代替function Class()
  45.                 // - 注意：这里的Class不是在最外层定义的那个基类构造函数
  46.                 function Class() {
  47.                     // 在类的实例化时，调用原型方法init
  48.                     if (!initializing && this.init)
  49.                         this.init.apply(this, arguments);
  50.                 }
  51.                 // 子类的prototype指向父类的实例（完成继承的关键）
  52.                 Class.prototype = prototype;
  53.                 // 修正constructor指向错误
  54.                 Class.constructor = Class;
  55.                 // 子类自动获取extend方法，arguments.callee指向当前正在执行的函数
  56.                 Class.extend = arguments.callee;
  57.                 return Class;
  58.             };
  59.         })();
下面我会对其中的for-in循环进行解读，把自执行的匿名方法用一个局部函数来替换， 这样有利于我们看清真相：
  1.         (function() {
  2.             var initializing = false, fnTest = /xyz/.test(function() { xyz; }) ? /\b_super\b/ : /.*/;
  3.             this.Class = function() { };
  4.             Class.extend = function(prop) {
  5.                 var _super = this.prototype;
  6.                 initializing = true;
  7.                 var prototype = new this();
  8.                 initializing = false;

  10.                 // 如果父类和子类有同名方法，并且子类中此方法（name）通过_super调用了父类方法
  11.                 // - 则重新定义此方法
  12.                 function fn(name, fn) {
  13.                     return function() {
  14.                         // 将实例方法_super保护起来。
  15.                         // 个人觉得这个地方没有必要，因为每次调用这样的函数时都会对this._super重新定义。
  16.                         var tmp = this._super;
  17.                         // 在执行子类的实例方法name时，添加另外一个实例方法_super，此方法指向父类的同名方法
  18.                         this._super = _super[name];
  19.                         // 执行子类的方法name，注意在方法体内this._super可以调用父类的同名方法
  20.                         var ret = fn.apply(this, arguments);
  21.                         this._super = tmp;
  22.                         
  23.                         // 返回执行结果
  24.                         return ret;
  25.                     };
  26.                 }
  27.                 // 拷贝prop中的所有属性到子类原型中
  28.                 for (var name in prop) {
  29.                     // 如果prop和父类中存在同名的函数，并且此函数中使用了_super方法，则对此方法进行特殊处理 - fn
  30.                     // 否则将此方法prop[name]直接赋值给子类的原型
  31.                     if (typeof prop[name] === "function" &&
  32.                             typeof _super[name] === "function" && fnTest.test(prop[name])) {
  33.                         prototype[name] = fn(name, prop[name]);
  34.                     } else {
  35.                         prototype[name] = prop[name];
  36.                     }
  37.                 }

  39.                 function Class() {
  40.                     if (!initializing && this.init) {
  41.                         this.init.apply(this, arguments);
  42.                     }
  43.                 }
  44.                 Class.prototype = prototype;
  45.                 Class.constructor = Class;
  46.                 Class.extend = arguments.callee;
  47.                 return Class;
  48.             };
  49.         })();
复制代码
写到这里，大家是否觉得Resig的实现和我们在第三章一步一步实现的jClass很类似。 其实在写这一系列的文章之前，我已经对prototype、mootools、extjs、 jQuery-Simple-Inheritance、Crockford-Classical-Inheritance这些实现有一定的了解，并且大部分都在实际项目中使用过。 在第三章中实现jClass也参考了Resig的实现，在此向Resig表示感谢。
下来我们就把jClass改造成和这里的Class具有相同的行为。

我们的实现 将我们在第三章实现的jClass改造成目前John Resig所写的形式相当简单，只需要修改其中的两三行就行了
  1.         (function() {
  2.             // 当前是否处于创建类的阶段
  3.             var initializing = false;
  4.             jClass = function() { };
  5.             jClass.extend = function(prop) {
  6.                 // 如果调用当前函数的对象（这里是函数）不是Class，则是父类
  7.                 var baseClass = null;
  8.                 if (this !== jClass) {
  9.                     baseClass = this;
  10.                 }
  11.                 // 本次调用所创建的类（构造函数）
  12.                 function F() {
  13.                     // 如果当前处于实例化类的阶段，则调用init原型函数
  14.                     if (!initializing) {
  15.                         // 如果父类存在，则实例对象的baseprototype指向父类的原型
  16.                         // 这就提供了在实例对象中调用父类方法的途径
  17.                         if (baseClass) {
  18.                             this._superprototype = baseClass.prototype;
  19.                         }
  20.                         this.init.apply(this, arguments);
  21.                     }
  22.                 }
  23.                 // 如果此类需要从其它类扩展
  24.                 if (baseClass) {
  25.                     initializing = true;
  26.                     F.prototype = new baseClass();
  27.                     F.prototype.constructor = F;
  28.                     initializing = false;
  29.                 }
  30.                 // 新创建的类自动附加extend函数
  31.                 F.extend = arguments.callee;

  33.                 // 覆盖父类的同名函数
  34.                 for (var name in prop) {
  35.                     if (prop.hasOwnProperty(name)) {
  36.                         // 如果此类继承自父类baseClass并且父类原型中存在同名函数name
  37.                         if (baseClass &&
  38.                         typeof (prop[name]) === "function" &&
  39.                         typeof (F.prototype[name]) === "function" &&
  40.                         /\b_super\b/.test(prop[name])) {
  41.                             // 重定义函数name -
  42.                             // 首先在函数上下文设置this._super指向父类原型中的同名函数
  43.                             // 然后调用函数prop[name]，返回函数结果
  44.                             // 注意：这里的自执行函数创建了一个上下文，这个上下文返回另一个函数，
  45.                             // 此函数中可以应用此上下文中的变量，这就是闭包（Closure）。
  46.                             // 这是JavaScript框架开发中常用的技巧。
  47.                             F.prototype[name] = (function(name, fn) {
  48.                                 return function() {
  49.                                     this._super = baseClass.prototype[name];
  50.                                     return fn.apply(this, arguments);
  51.                                 };
  52.                             })(name, prop[name]);
  53.                         } else {
  54.                             F.prototype[name] = prop[name];
  55.                         }
  56.                     }
  57.                 }
  58.                 return F;
  59.             };
  60.         })();
  61.         // 经过改造的jClass
  62.         var Person = jClass.extend({
  63.             init: function(name) {
  64.                 this.name = name;
  65.             },
  66.             getName: function(prefix) {
  67.                 return prefix + this.name;
  68.             }
  69.         });
  70.         var Employee = Person.extend({
  71.             init: function(name, employeeID) {
  72.                 //  调用父类的方法
  73.                 this._super(name);
  74.                 this.employeeID = employeeID;
  75.             },
  76.             getEmployeeIDName: function() {
  77.                 // 注意：我们还可以通过这种方式调用父类中的其他函数
  78.                 var name = this._superprototype.getName.call(this, "Employee name: ");
  79.                 return name + ", Employee ID: " + this.employeeID;
  80.             },
  81.             getName: function() {
  82.                 //  调用父类的方法
  83.                 return this._super("Employee name: ");
  84.             }
  85.         });

  87.         var zhang = new Employee("ZhangSan", "1234");
  88.         console.log(zhang.getName());   // "Employee name: ZhangSan"
  89.         console.log(zhang.getEmployeeIDName()); // "Employee name: ZhangSan, Employee ID: 1234"
  90.         
复制代码
JUST COOL!

 

在本章中，我们将分析Prototypejs中关于JavaScript继承的实现。
Prototypejs是最早的JavaScript类库，可以说是JavaScript类库的鼻祖。 我在几年前接触的第一个JavaScript类库就是这位，因此Prototypejs有着广泛的群众基础。

不过当年Prototypejs中的关于继承的实现相当的简单，源代码就寥寥几行，我们来看下。
早期Prototypejs中继承的实现

  1.         var Class = {
  2.             // Class.create仅仅返回另外一个函数，此函数执行时将调用原型方法initialize
  3.             create: function() {
  4.                 return function() {
  5.                     this.initialize.apply(this, arguments);
  6.                 }
  7.             }
  8.         };
  9.         
  10.         // 对象的扩展
  11.         Object.extend = function(destination, source) {
  12.             for (var property in source) {
  13.                 destination[property] = source[property];
  14.             }
  15.             return destination;
  16.         };
  17.         
复制代码

调用方式：

  1.         var Person = Class.create();
  2.         Person.prototype = {
  3.             initialize: function(name) {
  4.                 this.name = name;
  5.             },
  6.             getName: function(prefix) {
  7.                 return prefix + this.name;
  8.             }
  9.         };

  11.         var Employee = Class.create();
  12.         Employee.prototype = Object.extend(new Person(), {
  13.             initialize: function(name, employeeID) {
  14.                 this.name = name;
  15.                 this.employeeID = employeeID;
  16.             },
  17.             getName: function() {
  18.                 return "Employee name: " + this.name;
  19.             }
  20.         });


  23.         var zhang = new Employee("ZhangSan", "1234");
  24.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码

很原始的感觉对吧，在子类函数中没有提供调用父类函数的途径。

Prototypejs 1.6以后的继承实现 首先来看下调用方式：

  1.         // 通过Class.create创建一个新类
  2.         var Person = Class.create({
  3.             // initialize是构造函数
  4.             initialize: function(name) {
  5.                 this.name = name;
  6.             },
  7.             getName: function(prefix) {
  8.                 return prefix + this.name;
  9.             }
  10.         });
  11.         
  12.         // Class.create的第一个参数是要继承的父类
  13.         var Employee = Class.create(Person, {
  14.             // 通过将子类函数的第一个参数设为$super来引用父类的同名函数
  15.             // 比较有创意，不过内部实现应该比较复杂，至少要用一个闭包来设置$super的上下文this指向当前对象
  16.             initialize: function($super, name, employeeID) {
  17.                 $super(name);
  18.                 this.employeeID = employeeID;
  19.             },
  20.             getName: function($super) {
  21.                 return $super("Employee name: ");
  22.             }
  23.         });


  26.         var zhang = new Employee("ZhangSan", "1234");
  27.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码

这里我们将Prototypejs 1.6.0.3中继承实现单独取出来， 那些不想引用整个prototype库而只想使用prototype式继承的朋友， 可以直接把下面代码拷贝出来保存为JS文件就行了。

  2.         var Prototype = {
  3.             emptyFunction: function() { }
  4.         };

  6.         var Class = {
  7.             create: function() {
  8.                 var parent = null, properties = $A(arguments);
  9.                 if (Object.isFunction(properties[0]))
  10.                     parent = properties.shift();

  12.                 function klass() {
  13.                     this.initialize.apply(this, arguments);
  14.                 }

  16.                 Object.extend(klass, Class.Methods);
  17.                 klass.superclass = parent;
  18.                 klass.subclasses = [];

  20.                 if (parent) {
  21.                     var subclass = function() { };
  22.                     subclass.prototype = parent.prototype;
  23.                     klass.prototype = new subclass;
  24.                     parent.subclasses.push(klass);
  25.                 }

  27.                 for (var i = 0; i < properties.length; i++)
  28.                     klass.addMethods(properties[i]);

  30.                 if (!klass.prototype.initialize)
  31.                     klass.prototype.initialize = Prototype.emptyFunction;

  33.                 klass.prototype.constructor = klass;

  35.                 return klass;
  36.             }
  37.         };

  39.         Class.Methods = {
  40.             addMethods: function(source) {
  41.                 var ancestor = this.superclass && this.superclass.prototype;
  42.                 var properties = Object.keys(source);

  44.                 if (!Object.keys({ toString: true }).length)
  45.                     properties.push("toString", "valueOf");

  47.                 for (var i = 0, length = properties.length; i < length; i++) {
  48.                     var property = properties[i], value = source[property];
  49.                     if (ancestor && Object.isFunction(value) && value.argumentNames().first() == "$super") {
  50.                         var method = value;
  51.                         value = (function(m) {
  52.                             return function() { return ancestor[m].apply(this, arguments) };
  53.                         })(property).wrap(method);

  55.                         value.valueOf = method.valueOf.bind(method);
  56.                         value.toString = method.toString.bind(method);
  57.                     }
  58.                     this.prototype[property] = value;
  59.                 }

  61.                 return this;
  62.             }
  63.         };

  65.         Object.extend = function(destination, source) {
  66.             for (var property in source)
  67.                 destination[property] = source[property];
  68.             return destination;
  69.         };

  71.         function $A(iterable) {
  72.             if (!iterable) return [];
  73.             if (iterable.toArray) return iterable.toArray();
  74.             var length = iterable.length || 0, results = new Array(length);
  75.             while (length--) results[length] = iterable[length];
  76.             return results;
  77.         }

  79.         Object.extend(Object, {
  80.             keys: function(object) {
  81.                 var keys = [];
  82.                 for (var property in object)
  83.                     keys.push(property);
  84.                 return keys;
  85.             },
  86.             isFunction: function(object) {
  87.                 return typeof object == "function";
  88.             },
  89.             isUndefined: function(object) {
  90.                 return typeof object == "undefined";
  91.             }
  92.         });

  94.         Object.extend(Function.prototype, {
  95.             argumentNames: function() {
  96.                 var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1].replace(/\s+/g, '').split(',');
  97.                 return names.length == 1 && !names[0] ? [] : names;
  98.             },
  99.             bind: function() {
  100.                 if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
  101.                 var __method = this, args = $A(arguments), object = args.shift();
  102.                 return function() {
  103.                     return __method.apply(object, args.concat($A(arguments)));
  104.                 }
  105.             },
  106.             wrap: function(wrapper) {
  107.                 var __method = this;
  108.                 return function() {
  109.                     return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
  110.                 }
  111.             }
  112.         });

  114.         Object.extend(Array.prototype, {
  115.             first: function() {
  116.                 return this[0];
  117.             }
  118.         });
  119.         
普通浏览复制代码保存代码打印代码
  1.         var Prototype = {
  2.             emptyFunction: function() { }
  3.         };
  5.         var Class = {
  6.             create: function() {
  7.                 var parent = null, properties = $A(arguments);
  8.                 if (Object.isFunction(properties[0]))
  9.                     parent = properties.shift();
  11.                 function klass() {
  12.                     this.initialize.apply(this, arguments);
  13.                 }
  15.                 Object.extend(klass, Class.Methods);
  16.                 klass.superclass = parent;
  17.                 klass.subclasses = [];
  19.                 if (parent) {
  20.                     var subclass = function() { };
  21.                     subclass.prototype = parent.prototype;
  22.                     klass.prototype = new subclass;
  23.                     parent.subclasses.push(klass);
  24.                 }
  26.                 for (var i = 0; i < properties.length; i++)
  27.                     klass.addMethods(properties[i]);
  29.                 if (!klass.prototype.initialize)
  30.                     klass.prototype.initialize = Prototype.emptyFunction;
  32.                 klass.prototype.constructor = klass;
  34.                 return klass;
  35.             }
  36.         };
  38.         Class.Methods = {
  39.             addMethods: function(source) {
  40.                 var ancestor = this.superclass && this.superclass.prototype;
  41.                 var properties = Object.keys(source);
  43.                 if (!Object.keys({ toString: true }).length)
  44.                     properties.push("toString", "valueOf");
  46.                 for (var i = 0, length = properties.length; i < length; i++) {
  47.                     var property = properties[i], value = source[property];
  48.                     if (ancestor && Object.isFunction(value) && value.argumentNames().first() == "$super") {
  49.                         var method = value;
  50.                         value = (function(m) {
  51.                             return function() { return ancestor[m].apply(this, arguments) };
  52.                         })(property).wrap(method);
  54.                         value.valueOf = method.valueOf.bind(method);
  55.                         value.toString = method.toString.bind(method);
  56.                     }
  57.                     this.prototype[property] = value;
  58.                 }
  60.                 return this;
  61.             }
  62.         };
  64.         Object.extend = function(destination, source) {
  65.             for (var property in source)
  66.                 destination[property] = source[property];
  67.             return destination;
  68.         };
  70.         function $A(iterable) {
  71.             if (!iterable) return [];
  72.             if (iterable.toArray) return iterable.toArray();
  73.             var length = iterable.length || 0, results = new Array(length);
  74.             while (length--) results[length] = iterable[length];
  75.             return results;
  76.         }
  78.         Object.extend(Object, {
  79.             keys: function(object) {
  80.                 var keys = [];
  81.                 for (var property in object)
  82.                     keys.push(property);
  83.                 return keys;
  84.             },
  85.             isFunction: function(object) {
  86.                 return typeof object == "function";
  87.             },
  88.             isUndefined: function(object) {
  89.                 return typeof object == "undefined";
  90.             }
  91.         });
  93.         Object.extend(Function.prototype, {
  94.             argumentNames: function() {
  95.                 var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1].replace(/\s+/g, '').split(',');
  96.                 return names.length == 1 && !names[0] ? [] : names;
  97.             },
  98.             bind: function() {
  99.                 if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
  100.                 var __method = this, args = $A(arguments), object = args.shift();
  101.                 return function() {
  102.                     return __method.apply(object, args.concat($A(arguments)));
  103.                 }
  104.             },
  105.             wrap: function(wrapper) {
  106.                 var __method = this;
  107.                 return function() {
  108.                     return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
  109.                 }
  110.             }
  111.         });
  113.         Object.extend(Array.prototype, {
  114.             first: function() {
  115.                 return this[0];
  116.             }
  117.         });
  118.         

首先，我们需要先解释下Prototypejs中一些方法的定义。
?  argumentNames: 获取函数的参数数组

  1.                 function init($super, name, employeeID) {
  2.                 }
  3.                 console.log(init.argumentNames().join(",")); // "$super,name,employeeID"
复制代码

?  bind: 绑定函数的上下文this到一个新的对象（一般是函数的第一个参数）

  1.                 var name = "window";
  2.                 var p = {
  3.                     name: "Lisi",
  4.                     getName: function() {
  5.                         return this.name;
  6.                     }
  7.                 };

  9.                 console.log(p.getName());   // "Lisi"
  10.                 console.log(p.getName.bind(window)());  // "window"
复制代码

?  wrap: 把当前调用函数作为包裹器wrapper函数的第一个参数

  1.                 var name = "window";
  2.                 var p = {
  3.                     name: "Lisi",
  4.                     getName: function() {
  5.                         return this.name;
  6.                     }
  7.                 };

  9.                 function wrapper(originalFn) {
  10.                     return "Hello: " + originalFn();
  11.                 }

  13.                 console.log(p.getName());   // "Lisi"
  14.                 console.log(p.getName.bind(window)());  // "window"
  15.                 console.log(p.getName.wrap(wrapper)()); // "Hello: window"
  16.                 console.log(p.getName.wrap(wrapper).bind(p)()); // "Hello: Lisi"
复制代码
有一点绕口，对吧。这里要注意的是wrap和bind调用返回的都是函数，把握住这个原则，就很容易看清本质了。

对这些函数有了一定的认识之后，我们再来解析Prototypejs继承的核心内容。
这里有两个重要的定义，一个是Class.extend，另一个是Class.Methods.addMethods。
  2.         var Class = {
  3.             create: function() {
  4.                 // 如果第一个参数是函数，则作为父类
  5.                 var parent = null, properties = $A(arguments);
  6.                 if (Object.isFunction(properties[0]))
  7.                     parent = properties.shift();

  9.                 // 子类构造函数的定义
  10.                 function klass() {
  11.                     this.initialize.apply(this, arguments);
  12.                 }
  13.                
  14.                 // 为子类添加原型方法Class.Methods.addMethods
  15.                 Object.extend(klass, Class.Methods);
  16.                 // 不仅为当前类保存父类的引用，同时记录了所有子类的引用
  17.                 klass.superclass = parent;
  18.                 klass.subclasses = [];

  20.                 if (parent) {
  21.                     // 核心代码 - 如果父类存在，则实现原型的继承
  22.                     // 这里为创建类时不调用父类的构造函数提供了一种新的途径
  23.                     // - 使用一个中间过渡类，这和我们以前使用全局initializing变量达到相同的目的，
  24.                     // - 但是代码更优雅一点。
  25.                     var subclass = function() { };
  26.                     subclass.prototype = parent.prototype;
  27.                     klass.prototype = new subclass;
  28.                     parent.subclasses.push(klass);
  29.                 }

  31.                 // 核心代码 - 如果子类拥有父类相同的方法，则特殊处理，将会在后面详解
  32.                 for (var i = 0; i < properties.length; i++)
  33.                     klass.addMethods(properties[i]);

  35.                 if (!klass.prototype.initialize)
  36.                     klass.prototype.initialize = Prototype.emptyFunction;
  37.                
  38.                 // 修正constructor指向错误
  39.                 klass.prototype.constructor = klass;

  41.                 return klass;
  42.             }
  43.         };
普通浏览复制代码保存代码打印代码
  1.         var Class = {
  2.             create: function() {
  3.                 // 如果第一个参数是函数，则作为父类
  4.                 var parent = null, properties = $A(arguments);
  5.                 if (Object.isFunction(properties[0]))
  6.                     parent = properties.shift();
  8.                 // 子类构造函数的定义
  9.                 function klass() {
  10.                     this.initialize.apply(this, arguments);
  11.                 }
  12.                 
  13.                 // 为子类添加原型方法Class.Methods.addMethods
  14.                 Object.extend(klass, Class.Methods);
  15.                 // 不仅为当前类保存父类的引用，同时记录了所有子类的引用
  16.                 klass.superclass = parent;
  17.                 klass.subclasses = [];
  19.                 if (parent) {
  20.                     // 核心代码 - 如果父类存在，则实现原型的继承
  21.                     // 这里为创建类时不调用父类的构造函数提供了一种新的途径
  22.                     // - 使用一个中间过渡类，这和我们以前使用全局initializing变量达到相同的目的，
  23.                     // - 但是代码更优雅一点。
  24.                     var subclass = function() { };
  25.                     subclass.prototype = parent.prototype;
  26.                     klass.prototype = new subclass;
  27.                     parent.subclasses.push(klass);
  28.                 }
  30.                 // 核心代码 - 如果子类拥有父类相同的方法，则特殊处理，将会在后面详解
  31.                 for (var i = 0; i < properties.length; i++)
  32.                     klass.addMethods(properties[i]);
  34.                 if (!klass.prototype.initialize)
  35.                     klass.prototype.initialize = Prototype.emptyFunction;
  36.                 
  37.                 // 修正constructor指向错误
  38.                 klass.prototype.constructor = klass;
  40.                 return klass;
  41.             }
  42.         };
再来看addMethods做了哪些事情：
  2.         Class.Methods = {
  3.             addMethods: function(source) {
  4.                 // 如果父类存在，ancestor指向父类的原型对象
  5.                 var ancestor = this.superclass && this.superclass.prototype;
  6.                 var properties = Object.keys(source);
  7.                 // Firefox和Chrome返回1，IE8返回0，所以这个地方特殊处理
  8.                 if (!Object.keys({ toString: true }).length)
  9.                     properties.push("toString", "valueOf");

  11.                 // 循环子类原型定义的所有属性，对于那些和父类重名的函数要重新定义
  12.                 for (var i = 0, length = properties.length; i < length; i++) {
  13.                     // property为属性名，value为属性体（可能是函数，也可能是对象）
  14.                     var property = properties[i], value = source[property];
  15.                     // 如果父类存在，并且当前当前属性是函数，并且此函数的第一个参数为 $super
  16.                     if (ancestor && Object.isFunction(value) && value.argumentNames().first() == "$super") {
  17.                         var method = value;
  18.                         // 下面三行代码是精华之所在，大概的意思：
  19.                         // - 首先创建一个自执行的匿名函数返回另一个函数，此函数用于执行父类的同名函数
  20.                         // - （因为这是在循环中，我们曾多次指出循环中的函数引用局部变量的问题）
  21.                         // - 其次把这个自执行的匿名函数的作为method的第一个参数（也就是对应于形参$super）
  22.                         // 不过，窃以为这个地方作者有点走火入魔，完全没必要这么复杂，后面我会详细分析这段代码。
  23.                         value = (function(m) {
  24.                             return function() { return ancestor[m].apply(this, arguments) };
  25.                         })(property).wrap(method);

  27.                         value.valueOf = method.valueOf.bind(method);
  28.                         // 因为我们改变了函数体，所以重新定义函数的toString方法
  29.                         // 这样用户调用函数的toString方法时，返回的是原始的函数定义体
  30.                         value.toString = method.toString.bind(method);
  31.                     }
  32.                     this.prototype[property] = value;
  33.                 }

  35.                 return this;
  36.             }
  37.         };
普通浏览复制代码保存代码打印代码
  1.         Class.Methods = {
  2.             addMethods: function(source) {
  3.                 // 如果父类存在，ancestor指向父类的原型对象
  4.                 var ancestor = this.superclass && this.superclass.prototype;
  5.                 var properties = Object.keys(source);
  6.                 // Firefox和Chrome返回1，IE8返回0，所以这个地方特殊处理
  7.                 if (!Object.keys({ toString: true }).length)
  8.                     properties.push("toString", "valueOf");
  10.                 // 循环子类原型定义的所有属性，对于那些和父类重名的函数要重新定义
  11.                 for (var i = 0, length = properties.length; i < length; i++) {
  12.                     // property为属性名，value为属性体（可能是函数，也可能是对象）
  13.                     var property = properties[i], value = source[property];
  14.                     // 如果父类存在，并且当前当前属性是函数，并且此函数的第一个参数为 $super
  15.                     if (ancestor && Object.isFunction(value) && value.argumentNames().first() == "$super") {
  16.                         var method = value;
  17.                         // 下面三行代码是精华之所在，大概的意思：
  18.                         // - 首先创建一个自执行的匿名函数返回另一个函数，此函数用于执行父类的同名函数
  19.                         // - （因为这是在循环中，我们曾多次指出循环中的函数引用局部变量的问题）
  20.                         // - 其次把这个自执行的匿名函数的作为method的第一个参数（也就是对应于形参$super）
  21.                         // 不过，窃以为这个地方作者有点走火入魔，完全没必要这么复杂，后面我会详细分析这段代码。
  22.                         value = (function(m) {
  23.                             return function() { return ancestor[m].apply(this, arguments) };
  24.                         })(property).wrap(method);
  26.                         value.valueOf = method.valueOf.bind(method);
  27.                         // 因为我们改变了函数体，所以重新定义函数的toString方法
  28.                         // 这样用户调用函数的toString方法时，返回的是原始的函数定义体
  29.                         value.toString = method.toString.bind(method);
  30.                     }
  31.                     this.prototype[property] = value;
  32.                 }
  34.                 return this;
  35.             }
  36.         };
上面的代码中我曾有“走火入魔”的说法，并不是对作者的亵渎， 只是觉得作者对JavaScript中的一个重要准则（通过自执行的匿名函数创建作用域） 运用的有点过头。
  1.         value = (function(m) {
  2.             return function() { return ancestor[m].apply(this, arguments) };
  3.         })(property).wrap(method);
复制代码
其实这段代码和下面的效果一样：
  1.         value = ancestor[property].wrap(method);
复制代码
我们把wrap函数展开就能看的更清楚了：
  1.         value = (function(fn, wrapper) {
  2.             var __method = fn;
  3.             return function() {
  4.                 return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
  5.             }
  6.         })(ancestor[property], method);
复制代码
可以看到，我们其实为父类的函数ancestor[property]通过自执行的匿名函数创建了作用域。 而原作者是为property创建的作用域。两则的最终效果是一致的。

我们对Prototypejs继承的重实现
分析了这么多，其实也不是很难，就那么多概念，大不了换种表现形式。
下面我们就用前几章我们自己实现的jClass来实现Prototypejs形式的继承。

  1.         // 注意：这是我们自己实现的类似Prototypejs继承方式的代码，可以直接拷贝下来使用
  2.         
  3.         // 这个方法是借用Prototypejs中的定义
  4.         function argumentNames(fn) {
  5.             var names = fn.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1].replace(/\s+/g, '').split(',');
  6.             return names.length == 1 && !names[0] ? [] : names;
  7.         }


  10.         function jClass(baseClass, prop) {
  11.             // 只接受一个参数的情况 - jClass(prop)
  12.             if (typeof (baseClass) === "object") {
  13.                 prop = baseClass;
  14.                 baseClass = null;
  15.             }

  17.             // 本次调用所创建的类（构造函数）
  18.             function F() {
  19.                 // 如果父类存在，则实例对象的baseprototype指向父类的原型
  20.                 // 这就提供了在实例对象中调用父类方法的途径
  21.                 if (baseClass) {
  22.                     this.baseprototype = baseClass.prototype;
  23.                 }
  24.                 this.initialize.apply(this, arguments);
  25.             }

  27.             // 如果此类需要从其它类扩展
  28.             if (baseClass) {
  29.                 var middleClass = function() {};
  30.                 middleClass.prototype = baseClass.prototype;
  31.                 F.prototype = new middleClass();
  32.                 F.prototype.constructor = F;
  33.             }

  35.             // 覆盖父类的同名函数
  36.             for (var name in prop) {
  37.                 if (prop.hasOwnProperty(name)) {
  38.                     // 如果此类继承自父类baseClass并且父类原型中存在同名函数name
  39.                     if (baseClass &&
  40.                         typeof (prop[name]) === "function" &&
  41.                         argumentNames(prop[name])[0] === "$super") {
  42.                         // 重定义子类的原型方法prop[name]
  43.                         // - 这里面有很多JavaScript方面的技巧，如果阅读有困难的话，可以参阅我前面关于JavaScript Tips and Tricks的系列文章
  44.                         // - 比如$super封装了父类方法的调用，但是调用时的上下文指针要指向当前子类的实例对象
  45.                         // - 将$super作为方法调用的第一个参数
  46.                         F.prototype[name] = (function(name, fn) {
  47.                             return function() {
  48.                                 var that = this;
  49.                                 $super = function() {
  50.                                     return baseClass.prototype[name].apply(that, arguments);
  51.                                 };
  52.                                 return fn.apply(this, Array.prototype.concat.apply($super, arguments));
  53.                             };
  54.                         })(name, prop[name]);
  55.                         
  56.                     } else {
  57.                         F.prototype[name] = prop[name];
  58.                     }
  59.                 }
  60.             }

  62.             return F;
  63.         };
复制代码
调用方式和Prototypejs的调用方式保持一致：
  1.         var Person = jClass({
  2.             initialize: function(name) {
  3.                 this.name = name;
  4.             },
  5.             getName: function() {
  6.                 return this.name;
  7.             }
  8.         });

  10.         var Employee = jClass(Person, {
  11.             initialize: function($super, name, employeeID) {
  12.                 $super(name);
  13.                 this.employeeID = employeeID;
  14.             },
  15.             getEmployeeID: function() {
  16.                 return this.employeeID;
  17.             },
  18.             getName: function($super) {
  19.                 return "Employee name: " + $super();
  20.             }
  21.         });


  24.         var zhang = new Employee("ZhangSan", "1234");
  25.         console.log(zhang.getName());   // "Employee name: ZhangSan"
复制代码

经过本章的学习，就更加坚定了我们的信心，像Prototypejs形式的继承我们也能够轻松搞定。
以后的几个章节，我们会逐步分析mootools,Extjs等JavaScript类库中继承的实现，敬请期待。
posted @ 2014-08-06 23:42  JAVA之迷  阅读(280)  评论(0)  编辑  收藏  举报