javascript继承学习系列之三：对象伪装（Object Masquerading）

     基本思想很简单：在子类的构造器上调用超类构造器。更确切的说是在子类构造器执行上下文来中执行超类构造器（父类构造器中的 this指向子类实例），js提供了apply()和call()函数，它们可以实现这种调用。基本代码如下：

1. function BaseClass()
2. {
3.     this.colors=["red","blue"];
4. }
5. function ChildClass()
6. {
7.     //inherit
8.     BaseClass.call(this);
9. }
11. var instance1 = new ChildClass();
13. var instance2 = new ChildClass();
14. instance2.colors.push("green");
16. var instance3 = new ChildClass();
18. alert(instance1.colors);//red,blue
19. alert(instance2.colors);//red,blue,green
20. alert(instance3.colors);//red,blue

结果正是我们所预期的，即使对某个实例继承的属性进行了修改，对其他实例也没影响。代码很简单，核心的是子类构造器里的call()的执行，与它具有相同功效的是apply()，所以这里有必要对这两个神奇的函数进行简单说明。
    js中每个function都有这call()和apply()方法。call()函数的功能是在指定的对象上执行函数，它的第一个参数就是指定的对象。它还可以有多个参数，除第一个之外的参数都是调用指定函数所需要的参数，例如：

1. function fun(x,y)
2. {
3.    this.pointX = x;
4.    this.pointY = y;
5. }
7. var dot = {};
8. fun.call(dot,10,20);
9. alert(dot.pointX);//10
10. alert(dot.pointY);//20
    

其中代码fun.call(dot,10,20)使得dot具有了fun定义的属性。它的意思就是在dot对象上运行fun（），在运行时，fun中的this指向dot,同时向fun()传递了两个参数10和20，分别传给了fun的形参x和y。
    而apply()功用上与call()相同，但是调用形式上有些不同，将上个示例中将call()改成apply(),如下：

1. function(x,y)
2. {
3.     this.pointX = x;
4.     this.pointY = y;
5. }
7. var dot={};
8. fun.apply(dot,[10,20]);
9. alert(dot.pointX);//10
10. alert(dot.pointY);//20
    

区 别在于第一个实参（dot）之后的参数，fun()调用所需的实参以数组的形式传递给形参了。在这个示例中apply()的优点似乎不够明显，设想一下这 样的场景：用户调用一个函数，在执行这个函数时，同时要运行另外一个函数，但必须是同一个上下文中（this指向的是同一个对象），而用户传给第一个函数 的参数是不确定的，第一个函数传给第二个函数的参数也是将是不确定的，这种情况下用apply()就很合适了。如:

1. function fun2(x,y,z)
2. {
3.    x=x||0;
4.    y=y||0;
5.    z=z||0;
6.    var list = [];
7.    list.push(x);
8.    list.push(y);
9.    list.push(z);
10.    alert(list);
11. }
12. function fun1()
13. {
14.     fun2.apply(this,arguments);
15. }
16. fun1(10);//10,0,0
17. fun1(10,20);//10,20,0
18. fun1(10,20,30);//10,20,30
    

可见，如果函数参数传递时是固定的，用call()或apply()都可以，如果参数不是固定的，就要用apply()。
    构造器伪装存在一个问题，子类没有办法继承到父类原型上的属性和方法，它只能继承到在父类构造器里定义的属性和方法。而很多时候我们定义类时，为了避免每次new时重复定义方法，会将方法定义到它的原型上，而不是构造器里。考虑以下代码：

1. function BaseClass(n,g)
2. {
3.      this.name = n;
4.      this.gender = g;
5.      this.getName = function(){return this.name;};
6. }
7. BaseClass.prototype.getGender = function(){return this.gender;};
9. function ChildClass(n,g,a)
10. {
11.      BaseClass.call(this,n,g);
12.      this.age = a;
13. }
14. ChildClass.prototype.getAge=function(){return this.age;};
16. var instance = new ChildClass("sds","M",30);
18. alert(instance.getName());//sds
19. alert(instance.getAge());//30
20. alert(instance.getGender());//error,The getGender() don't inherit from BaseClass;
    

预 想的是getGender()返回"M"，要命的是报了个致命错误。这个示例给我的们展示了，仅靠构造器伪装方式，继承是不可靠的。这里还要说明一点，对 于getName()，由于它定义在父类构造器里，就意味这每次创建父类对象或子类对象时，它都会重新被创建，而这种重复工作，大多数时候是我们要极力避 免的。很多时候，我们将属性定义在构造器里，而将方法定义在原型对象上。这在OO里是讲得通的，因为每个对象拥有不同的数据（属性），但是拥有相同的行为 （方法）。好比我们人类自己，每个人（实例对象）都有自己区别于其他人的特征：姓名、年龄、性别等，但却拥有相同的行为：说话()、行走()等。