js继承实现方式

当涉及到 JavaScript 的继承时，有多种实现方式。以下是其中的六种常见方式：

1. 原型链继承：

function Parent() {
    this.name = 'Parent';
}

function Child() {
    this.age = 10;
}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

var child = new Child();
console.log(child.name);  // 输出: Parent
console.log(child.age);   // 输出: 10

2. 构造函数继承（借用构造函数）：

function Parent() {
    this.name = 'Parent';
}

function Child() {
    Parent.call(this);
    this.age = 10;
}

var child = new Child();
console.log(child.name);  // 输出: Parent
console.log(child.age);   // 输出: 10

3. 组合继承（原型链继承 + 构造函数继承）：

function Parent() {
    this.name = 'Parent';
}

Parent.prototype.sayHello = function() {
    console.log('Hello');
};

function Child() {
    Parent.call(this);
    this.age = 10;
}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

var child = new Child();
console.log(child.name);     // 输出: Parent
console.log(child.age);      // 输出: 10
child.sayHello();            // 输出: Hello

4. 原型式继承： 使用一个简单的对象作为中间对象，继承父对象的原型属性和方法。

function createObject(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

var parent = {
    name: 'Parent',
    sayHello: function() {
        console.log('Hello');
    }
};

var child = createObject(parent);
console.log(child.name);     // 输出: Parent
child.sayHello();            // 输出: Hello

5. 寄生式继承： 在原型式继承的基础上，对原有对象进行拓展。

function createObject(o) {
    var clone = Object.create(o);
    clone.sayHi = function() {
        console.log('Hi');
    };
    return clone;
}

var parent = {
    name: 'Parent',
    sayHello: function() {
        console.log('Hello');
    }
};

var child = createObject(parent);
console.log(child.name);     // 输出: Parent
child.sayHello();            // 输出: Hello
child.sayHi();               // 输出: Hi

6. ES6 类继承：

class Parent {
    constructor() {
        this.name = 'Parent';
    }

    sayHello() {
        console.log('Hello');
    }
}

class Child extends Parent {
    constructor() {
        super();
        this.age = 10;
    }
}

let child = new Child();
console.log(child.name);     // 输出: Parent
console.log(child.age);      // 输出: 10
child.sayHello();            // 输出: Hello

寄生组合式继承是一种优化过的继承方式，结合了原型链继承和借用构造函数继承的优点。它避免了父类构造函数被调用两次的问题，同时能实现正确的原型链继承。

下面是寄生组合式继承的代码实现：

function inheritPrototype(child, parent) {
    var prototype = Object.create(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}

function Parent(name) {
    this.name = name;
}

Parent.prototype.sayHello = function() {
    console.log('Hello, ' + this.name + '!');
};

function Child(name, age) {
    Parent.call(this, name);
    this.age = age;
}

inheritPrototype(Child, Parent);

Child.prototype.sayAge = function() {
    console.log(this.name + ' is ' + this.age + ' years old.');
};

var child = new Child('John', 10);
child.sayHello();  // 输出: Hello, John!
child.sayAge();    // 输出: John is 10 years old.

在上述代码中，inheritPrototype 函数实现了将子类的原型对象设置为父类的实例，并修正子类的构造函数引用。这样子类既能够继承父类的原型方法，又能够通过自身的构造函数进行属性的初始化。

寄生组合式继承是目前广泛应用的一种继承方式，它兼具了性能和灵活性，并且能够避免原型链继承和构造函数继承的缺点。