继承

Carrie
87 阅读7分钟

原型链

ECMAScript中描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。总结构造函数，原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。那么，假如我们让原型对象等于另一个类型的实例，结果会怎么样呢？显然，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中页包含一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。这就是所谓原型链的基本概念。

    function SuperType() {
        this.property = true;
    }
    SuperType.prototype.getSuperValue = function() {
        retutn this.property;
    }
    function SubType() {
        this.subproperty = false;
    }
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function(){
        return this.subproperty;
    }
    var instance = new SubType();
    console.log(instance.getSuperValue()); //true

以上代码定义了两个类型：SuperType和SubType。每个类型分别有一个属性和一个方法。它们的主要区别是SubType继承了SuperType，而继承是通过创建SuperType的实例，并将该实例赋给SubType.prototype实现的。实例的本质是重写原型对象，代之以一个新类型的实例。换句话说，原来存在于SuperType的实例中的所有属性和方法，现在也存在于SubType.prototype中了。在确立了继承关系后，我们给SubType.prototype添加了一个方法，这样就在继承了SuperType的属性和方法的基础上又添加了一个新方法。这个例子中的实例以及构造函数和原型之间的关系如图所示：

image.png

在上面的代码中，我们没有使用SubType默认提供的原型，而是给它换了一个新原型；这个新原型就是SuperType的实例。于是，新原型不仅具有作为一个SuperType的实例所拥有的全部属性和方法，而且内部还有一个指针，指向了SuperType的原型。最终结果就是这样的：instance指向SubType的原型，SubType的原型又指向SuperType的原型。getSuperValue（）方法仍然还是在SuperType.prototype中，但property则位于SubType.prototype中。这是因为property是一个实例属性，而getSuperValue()则是一个原型方法。既然SubType.prototype现在是SuperType的实例，那么property当然就位于该实例中了。

此外，要注意instance.constructor现在指向的是SuperType，这是因为SubType.prototype中的constructor被重写了的缘故。（实际上，不是SubType的原型的constructor属性被重写了，而是SubType的原型指向了另一个对象--SuperType的原型，而这个原型对象的constructor属性指向的是SuperType）。

拿上面的例子来说，调用instance.getSuperValue()会经历三个搜索步骤： 1、搜索实例； 2、 搜索subType.prorotype； 3、搜索SuperType.prorotype。 最后异步才找到该方法，在找不到属性和方法的情况下，搜索过程一环一环的前行到原型链末端才会停下来。

  1. 别忘记默认的原型

所有引用类型默认都继承了Object,而这个继承也是通过原型链实现的。所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype,这也是所有自定义类型都会继承toString(),valueOf等默认方法的根本原因。下图展示了该例子中完整的原型链。

image.png 一句话，SubType继承了SuperType,而SuperType继承了Object.当调用instance.toString()时，实际上调用的是保存在Object.prototype中的那个方法。

  1. 原型链的问题

原型链虽然很强大，可以用它来实现继承，但它也存在一些问题，最主要的问题来自包含引用类型值的原型。在通过原型来实现继承时，原型实际上会变成另一个类型的实例。于是，原先的实例属性也就顺理成章地变成了现在的原型属性了。下面的代码可以用来说明这个问题。

function SuperType() {
    this.colors = ["red","blue","greed"]
}
function SubType(){}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push("black");
console.log(instance1.colors); //"red,blue,green,black"
var instance2 = new SubType();
console.log(instance2.colors); //"red,blue,green,black"

这个例子中的SuperType构造函数定义了一个colors属性，该属性包含一个数组（引用类型值）。SuperType的每个实例都会有各自包含自己数组的colors属性。当SubType通过原型链继承了SuperType之后，SubType.prototype就变成了SuperType的一个实例，因此它也拥有了一个它自己的colors属性--就跟专门创建了一个SubType.prototype.colors属性一样。但结果是什么呢，结果是SubType的所有实例都会共享这一个colors属性。而我们对instance1.colors的修改通过instance2.colors反应出来，就已经充分证实了这一点。

原型链的第二个问题是：在创建子类型的实例时，不能向超类型的构造函数中传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。有鉴于此，再加上前面刚刚讨论过的由于原型中包含引用类型值所带来的问题，实践中很少单独使用原型链。

借用构造函数

借用构造函数（constructor stealing）的技术（有时候也叫做伪造对象活经典继承）。即在子类型构造函数的内部调用超类型构造函数。函数只是在特定环境下执行代码的对象。因此通过使用apply()和call()方法也可以在新创建的对象上执行构造函数。

function SuperType() {
    this.colors = ['red, 'blue', 'green'];
}
function SubType() {
    //继承了SuperType
    SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push("black");
console.log(instance1.colors); // "red,blue,green,black"
var instance2 = new SubType();
console.log(instance2.colors); //"red,blue,green"
  1. 传递参数

相对于原型链而言，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数中传递参数。如下：

function SuperType() {
    this.name = name;
}
function SubType() {
//继承了SuperType，同时还传递了参数
    SuperType.call(this, "Nicolas");
    this.age = 29;
}
var instance = new SubType();
console.log(instance.name); //Nicolas
console.log(instance.age); // 29
  1. 借用构造函数的问题

如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题--方法都在构造函数中定义，因为函数复用无从谈起了。而且，在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式。考虑到这些问题，借用构造函数的技术也是很少单独使用的。

组合继承

组合继承（combination inheritance），有时候也叫做伪经典继承，指的是将原型链和借用构造函数的技术组合到一起，从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。例子如下：

function SuperType(name) {
    this.name = name;
    this.colors = ['red','blue','green'];
}
SuperType.prototype.sayName = function(){
    console.log(this.name)
};
function SubType(name, age){
    //继承属性
    SuperType.call(this, name);
    this.age = age;
}
//继承方法
SubType.prototype = new SuperType();

SubType.prototype.sayAge = function() {
    console.log(this.age)
}
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
console.log(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //Nicholas
instance1.sayAge(); //29

var instance2 = new SubType("Greg", 27);
console.log(instance2.colors); // "red,blue,green"
instance2.sayName(); //Greg
instance2.sayAge(); //27

在这个例子中，SuperType构造函数定义了两个属性；name和colors。SuperType的原型定义了一个方法SayName()。SubType构造函数在调用SuperType构造函数时传入了name参数，紧接着有定义了它自己的属性age。然后，将SuperType的实例赋值给SubType的原型，然后又在该新原型上定义了方法sayAge()。这样一来，就可以让两个不同的SubType实例分别拥有自己的属性---包括colors属性，又可以使用相同的方法了。

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为JavaScript中最常用的继承模式。

avatar
文章
阅读
粉丝