ECMAScript中如何实现继承

在 ECMAScript（JavaScript）中，有多种方法可以实现对象之间的继承。以下是几种常见的方法：

1. 原型链继承

通过将子类的原型对象指向父类的一个实例对象，从而实现子类继承父类原型上的属性和方法。

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

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

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

// 设置 Child 的原型为 Parent 的一个实例
Child.prototype = new Parent();

// 修复构造函数指向
Child.prototype.constructor = Child;

const child = new Child();
child.sayHello(); // 输出: Hello from Child

2. 构造函数继承

在子类构造函数内部调用父类构造函数，并将子类实例作为上下文。

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

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

function Child(name) {
    // 调用父类构造函数
    Parent.call(this, name);
}

const child = new Child('Child');
console.log(child.name); // 输出: Child
child.sayHello(); // 报错: child.sayHello is not a function

3. 组合继承

结合原型链继承和构造函数继承的优点，既继承了父类的属性，又继承了父类原型上的方法。

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

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

function Child(name) {
    // 调用父类构造函数
    Parent.call(this, name);
}

// 设置 Child 的原型为 Parent 的一个实例
Child.prototype = new Parent();

// 修复构造函数指向
Child.prototype.constructor = Child;

const child = new Child('Child');
child.sayHello(); // 输出: Hello from Child

4. 原型式继承

通过创建一个新对象，并将传入的对象作为新对象的原型。

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

const parent = {
    name: 'Parent',
    sayHello: function() {
        console.log('Hello from ' + this.name);
    }
};

const child = object(parent);
child.name = 'Child';
child.sayHello(); // 输出: Hello from Child

5. 寄生式继承

在原型式继承的基础上，增强对象。

function createObj(o) {
    const clone = object(o);
    clone.sayHello = function() {
        console.log('Hello from ' + this.name);
    };
    return clone;
}

const parent = {
    name: 'Parent'
};

const child = createObj(parent);
child.name = 'Child';
child.sayHello(); // 输出: Hello from Child

6. 寄生组合式继承

结合寄生式继承和组合继承的优点，避免调用两次父类构造函数。

function inheritPrototype(subType, superType) {
    const prototype = object(superType.prototype); // 创建对象
    prototype.constructor = subType; // 增强对象
    subType.prototype = prototype; // 指定对象
}

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

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

function Child(name) {
    Parent.call(this, name); // 第二次调用 Parent 构造函数
}

inheritPrototype(Child, Parent);

const child = new Child('Child');
child.sayHello(); // 输出: Hello from Child

这些方法各有优缺点，选择哪种方法取决于具体的需求和场景。寄生组合式继承通常被认为是实现继承的最佳实践，因为它结合了多种方法的优点，避免了不必要的性能开销。