使用 `Object.create` 进行继承的好处

Inheritance establishes an is-a relation, for example, a Dog is an Animal. How is this expressed in terms of constructor function and prototype object?

很明显，狗必须具有与动物相同的方法，即 Dog prototype 对象必须以某种方式合并来自 Animal 的方法原型 对象.有多种方法可以做到这一点.你会经常看到这样的:

Obviously a dog must have the same methods as an animal, that is the Dog prototype object must somehow incorporate the methods from the Animal prototype object. There are multiple ways to do this. You will often see this:

Dog.prototype = new Animal();

这是因为 Animal instance 继承自 Animal prototype 对象.但是这也意味着每只狗都继承自一个特定的Animal实例.这似乎有点奇怪.实例特定代码不应该只在 constructor 函数中运行吗?突然，instance 特定代码和 prototype 方法似乎混在一起了.

This works because an Animal instance inherits from the Animal prototype object. But it also implies that every dog inherits from one specific Animal instance. That seems to be a bit strange. Shouldn't instance specific code only be run in the constructor function? Suddenly instance specific code and prototype methods seem to be mixed.

此时我们实际上并不想运行 Animal instance 特定的代码，我们只想要 Animal 中的所有方法 原型对象.这就是 Object.create 让我们做的:

We don't actually want to run Animal instance specific code at that moment, we only want all the methods from the Animal prototype object. That is what Object.create lets us do:

Dog.prototype = Object.create(Animal.prototype);

这里我们不是创建一个新的Animal实例，我们只得到原型方法.instance 特定的代码在构造函数内部准确地执行:

Here we are not creating a new Animal instance, we only get the prototype methods. The instance specific code is executed exactly where it should be, inside the constructor:

function Dog() { 
   Animal.call(this, 'Dog'); 
}

最大的优点是 Object.create 将始终 工作.new Animal() 仅在构造函数不期望任何参数时才有效.想象一下，如果构造函数看起来像这样:

The biggest advantage is that Object.create will always work. Using new Animal() only works if the constructor does not expect any arguments. Imagine if the constructor looked like this:

function Animal(name) { 
    this.name = name.toLowerCase();
}

你总是必须将一个字符串传递给Animal，否则你会得到一个错误.当你执行 Dog.prototype = new Animal(??); 时你会传递什么?实际上，你传递哪个字符串并不重要，只要传递 something，希望这能告诉你这是一个糟糕的设计.

You always have to pass a string to Animal, otherwise you will get an error. What will you pass when you do Dog.prototype = new Animal(??);? It doesn't actually matter which string you pass, as long as pass something, which hopefully shows you that this is bad design.

有人说Dog.prototype = Animal.prototype; 也可以.所以现在我完全糊涂了

Some say that Dog.prototype = Animal.prototype; can also work. So now I'm totally confused

所有将 Animal.prototype 属性添加"到 Dog.prototype 的东西都将起作用".但是解决方案的质量不同.在这种情况下，您将遇到添加到 Dog.prototype 的任何方法也将添加到 Animal.prototype 的问题.

Everything that "adds" the properties from Animal.prototype to Dog.prototype will "work". But the solutions are of different quality. In this case here you will have the problem that any method you add to Dog.prototype will also be added to Animal.prototype.

例子:

Dog.prototype.bark = function() {
    alert('bark');
};

由于Dog.prototype === Animal.prototype，现在所有的Animal实例都有一个方法bark，这肯定不是你的想.

Since Dog.prototype === Animal.prototype, all Animal instances have a method bark now, which is certainly not what you want.

Object.create(甚至是 new Animal)通过创建一个继承自 Animal.prototype 并且该新对象变为 Dog.prototype.

class Dog extends Animal {

  bark() {
    alert('bark');
  }

}