Прототипическое наследование, зачем нам нужно Object.create? [Дубликат]

Давайте будем понимать это только с кодом;

A.prototype = B.prototype;

function B() {console.log("I am B");this.b1= 30;}
    B.prototype.b2 = 40;

    function A() {console.log("I am A");this.a1= 10;}
    A.prototype.a2 = 20;

    A.prototype = B.prototype;

    A.prototype.constructor = A; 

    var a = new A;
    var b = new B;

    console.log(a);//A {a1: 10, b2: 40}
    console.log(b);//B {b1: 30, b2: 40}

    console.log(A.prototype.constructor);//A
    console.log(B.prototype.constructor);//A
    console.log(A.prototype);//A {b2: 40}
    console.log(B.prototype);//A {b2: 40}
    console.log(a.constructor === A); //true
    console.log(b.constructor === A); //true

console.log(a.a2);//undefined

[/g0]

A .prototype = Object.create (B.prototype);

function B() {console.log("I am B");this.b1= 30;}
B.prototype.b2 = 40;

function A() {console.log("I am A");this.a1= 10;}
A.prototype.a2 = 20;

A.prototype = Object.create(B.prototype);

A.prototype.constructor = A; 

var a = new A;
var b = new B;

console.log(a);//A {a1: 10, constructor: function, b2: 40}
console.log(b);//B {b1: 30, b2: 40} 

console.log(A.prototype.constructor);//A
console.log(B.prototype.constructor);//B
console.log(A.prototype);//A {constructor: function, b2: 40}
console.log(B.prototype);//B {b2: 40}
console.log(a.constructor === A); //true
console.log(b.constructor === B); //true
console.log(a.a2);//undefined

[/g1]

Я немного проиллюстрирую разницу:

Вот что в основном происходит, когда вы пишете new Animal():

    //creating a new object
    var res = {};

    //setting the internal [[prototype]] property to the prototype of Animal
    if (typeof Animal.prototype === "object" && Animal.prototype !== null) {
        res.__proto__ = Animal.prototype;
    }

    //calling Animal with the new created object as this
    var ret = Animal.apply(res, arguments);

    //returning the result of the Animal call if it is an object
    if (typeof ret === "object" && ret !== null) {
        return ret;
    }

    //otherise return the new created object
    return res;

И вот что в принципе происходит с Object.create:

    //creating a new object
    var res = {};

    //setting the internal [[prototype]] property to the prototype of Animal
    if (typeof Animal.prototype !== "object") {
        throw "....";
    }
    res.__proto__ = Animal.prototype;

    //return the new created object
    return res;

Таким образом, он делает то же самое, но не вызывает функцию Animal, а также всегда возвращает новый созданный объект. В вашем случае вы получаете два разных объекта. С помощью первого метода вы получите:

Dog.prototype = {
    name: undefined,
    __proto__: Animal.prototype
};

и со вторым методом:

Dog.prototype = {
    __proto__: Animal.prototype
};

Вам действительно не нужно иметь свойство name в вашем прототип, потому что вы уже назначили его вашему экземпляру Dog с помощью Animal.call(this, 'Dog');.

Ваша основная цель - предоставить вашему экземпляру Dog доступ ко всем свойствам прототипа Animal, который достигается с помощью обоих методов. Первый способ, однако, делает некоторые дополнительные вещи, которые на самом деле не нужны в вашем случае, или даже могут вызывать нежелательные результаты, о которых упоминал Pumbaa80.

Во-первых, запуск конструктора Animal может иметь нежелательные побочные эффекты. Рассмотрим это:

var Animal = function(name) {
    this.name = name;
    Animal.instances.push(this);
};
Animal.instances = [];

Эта версия будет отслеживать все созданные экземпляры. Вы не хотите, чтобы ваш Dog.prototype был записан там.

Во-вторых, Dog.prototype = Animal.prototype - плохая идея, поскольку это означало бы, что bark станет методом Animal.