[转]JavaScript继承详解

发布于，归属于javascript。 沙发还空着，抢！ 共有63人围观    

JavaScript中类和继承

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

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

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

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

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

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

如何在JavaScript中实现简单的继承？

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

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

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

this

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

先看一个在全局作用范围内使用this的例子：

  1. console.log(this === window);  // true
  2.             console.log(window.alert === this.alert);  // true
  3.             console.log(this.parseInt("021", 10));  // 10

函数中的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"
  10.  
  11.         // 自定义一个对象，并将此对象的属性foo指向全局函数foo
  12.         var pack = {
  13.             fruit: "orange",
  14.             foo: foo
  15.         };
  16.         // 此时函数foo中this指向window.pack对象
  17.         pack.foo(); // "orange"

全局函数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.

constructor

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

  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

原文：http://www.cnblogs.com/sanshi/archive/2009/07/08/1519251.html

（如果您喜欢这篇教程，可以通过支付宝打赏我们1元哦，拜谢！）

跟作者说两句

:wink: :twisted: :roll: :oops: :mrgreen: :lol: :idea: :evil: :cry: :arrow: :?: :-| :-x :-o :-P :-? :) :( :!: 8-O 8)

同类