为什么我们要用`Boy.prototype = new Human;`来模拟继承？

Question

我不明白为什么每个人都使用 Boy.prototype = new Human; 来模拟继承。你看，我们想要的是A的函数吧？我们可以在不实例化一个新的 A 的情况下做到这一点（事实上，实例化一个新的 A 确实会给我们带来不想要的结果，因为我们实际上正在运行实例化函数，这不是我们想要的）

所以这不是一个更好的解决方案吗？

for (var prop_name in Human.prototype) {
Object.defineProperty(
          Boy.prototype,
          prop_name,
          Object.getOwnPropertyDescriptor(Human.prototype,prop_name)
        );
}

假设我们很特别，不仅想要 Human.prototype 中的可枚举属性，我们仍然可以通过使用 Object.getOwnPropertyNames 并在原型链上调用它来实现它，而原型链又可以通过 <代码>Object.getPrototypeOf。

那么，当我们有更好的选择时，使用 Boy.prototype = new Human; 来模拟继承到底有什么好处呢？

Answer 1

更好的选择是创建一个中间体来保存原型。

function extend(clazz, superclass) {
    var intermediate = function() {};
    intermediate.prototype = superclass.prototype;
    clazz.prototype = new intermediate();
    // Following line is optional, but useful
    clazz.prototype.constructor = clazz;
}

这避免了不必要的复制，但仍然意味着您不需要实例化将在其构造函数中工作的对象。它还设置了原型链，以便您可以使用instanceof。它也不会导致某些继承反模式可能造成的超类原型污染。

为了完整起见，您的子类应该在其构造函数中调用超类构造函数，您可以使用 Superclass.call(this); 来执行此操作。

编辑：从 ES5 开始，您可以替换对 extend 的调用，它

Subclass.prototype = Object.create(Superclass.prototype);

可以执行相同的操作。

Answer 2

• 它正确设置了原型链，这意味着 instanceof 和 isPrototypeOf() 会起作用
• 它不太冗长

有一些简单但丑陋的解决方法可以防止构造函数在您刚刚使用时执行其通常的初始化它创建一个原型对象。例如，您可以检查参数：

function Boy(name) {
    if (arguments.length == 1) {
        this.name = name;
        // Do other initialization
    }
}

...或者将初始化移动到必须显式调用的单独方法中：

function Boy(name) {}

Boy.prototype.init = function(name) {
    this.name = name;
    // Do other initialization
}

这有一个明显的缺点，即要求您记住调用 init()每当你创建一个新的Boy时。

在 ECMAScript 5 环境中（例如，大多数浏览器的当前版本），更好的选择可能是 ECMAScript 5 的 Object.create()，它允许您创建一个直接从另一个对象继承的对象，并为您设置原型链。这可以被模拟（但只是近似：参见ES5中的Object.defineProperty？ ) 在非 ES5 环境中：

if (!Object.create) {
    Object.create = function(o) {
        function F() {}
        F.prototype = o;
        return new F();
    }; 
}