javascript 的继承是如何实现的

JavaScript 的继承通过原型链和构造函数实现、可以采用多种方式如原型链继承、构造函数继承、组合继承、原型式继承、寄生式继承及寄生组合式继承。 其中，最常用的继承方式是组合继承，因为它结合了原型链和构造函数的优点，避免了各自的缺点。通过构造函数继承属性，通过原型链继承共享的方法和属性，这样即避免了原型链中子类型实例共享父类引用属性的问题，又实现了方法复用。

本文将通过各种常见的继承方式的详细实现来深入探讨JavaScript的继承机制。

一、原型链继承

原型链继承是最基本的JavaScript继承方法，它利用原型让一个引用类型继承另一个引用类型的属性和方法。

function Parent(){
    this.parentProperty = true;
}
Parent.prototype.getParentProperty = function() {
    return this.parentProperty;
};
function Child(){
    this.childProperty = false;
}
// 继承Parent
Child.prototype = new Parent();
var instance = new Child();
alert(instance.getParentProperty());  // true

这种方法的主要缺点是包含引用类型值的原型属性会被所有实例共享，此外，创建子类型实例时，不能向超类型的构造函数中传递参数。

二、构造函数继承

构造函数继承使用父类的构造函数来增强子类实例，等同于复制父类的实例属性给子类，没有使用原型。

function Parent(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
function Child(name){
    // 继承自Parent
    Parent.call(this, name);
}
var instance1 = new Child("instance1");
var instance2 = new Child("instance2");
instance1.colors.push("black");
alert(instance1.colors); // "red,blue,green,black"
alert(instance2.colors); // "red,blue,green"

这种方法的优点是可以在子类型构造函数中向超类型构造函数传递参数。但这种方法的缺点是方法都在构造函数中定义，因此函数复用无从谈起。

三、组合继承

组合继承（伪经典继承）结合了原型链和构造函数的技术，从而发挥二者之长。用构造函数继承属性，用原型链的方式继承方法。

function Parent(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
Parent.prototype.sayName = function() {
    return this.name;
};
function Child(name, age){
    // 继承属性
    Parent.call(this, name);
    this.age = age;
}
// 继承方法
Child.prototype = new Parent();
Child.prototype.constructor = Child;
Child.prototype.sayAge = function() {
    return this.age;
};
var instance = new Child("Nicholas", 29);
alert(instance.sayName()); // "Nicholas"
alert(instance.sayAge());  // 29

这是JavaScript中最常用的继承模式。不过，它也有自己的不足：使用Child的实例时，其原型上会存在两份相同的属性/方法。

四、原型式继承

原型式继承基于已有的对象创建新对象，同时还不必因此创建自定义类型。

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
alert(person.friends); // "Shelby,Court,Van,Rob,Barbie"

Object.create()是ECMAScript 5中的一个新方法，直接指定原型。原型式继承的问题同原型链继承一样，包含引用类型值的属性始终都会共享相应的值，这点对于特定的应用场景是一种缺陷。

五、寄生式继承

寄生式继承是在原型式继承的基础上增强对象，返回构造函数。

function createAnother(original){
    var clone = Object.create(original); // 通过调用函数创建一个新对象
    clone.sayHi = function() {           // 以某种方式来增强这个对象
        alert("hi");
    };
    return clone;                        // 返回这个对象
}
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi(); // "hi"

这种方式同原型式继承几乎是一模一样的，只不过增强的是对象，而不是自定义类型的实例。

六、寄生组合式继承

寄生组合式继承是对组合继承的进一步优化，通过寄生方式来继承超类的原型，然后再将结果指定给子类的原型。

function inheritPrototype(subType, superType){
    var prototype = Object.create(superType.prototype); // 创建对象
    prototype.constructor = subType;                    // 增强对象
    subType.prototype = prototype;                      // 指定对象
}
function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
    alert(this.name);
};
function SubType(name, age){
    SuperType.call(this, name);
    this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
    alert(this.age);
};
var instance = new SubType("Nicholas", 29);
instance.sayName(); // "Nicholas"
instance.sayAge();  // "29"