Perché Object.create() e new Object() valutano su diversi prototipi?

Question

Perché queste 2 implementazioni si comportano diversamente? Cosa li distingue esattamente quando si tratta di valutare i loro prototipi?

Creazione di un oggetto con il prototipo specificato:

function Foo() {} 

    // creates an object with a specified prototype 
    var bar = Object.create(Foo); 

    console.log(Object.getPrototypeOf(bar)); // returns: function Foo(){} 
    console.log(Foo.isPrototypeOf(bar)); // returns: true 

Creazione di un oggetto con il metodo di costruzione:

function Foo() {} 

    // creates an object with the constructor method  
    var bar = new Foo(); 

    console.log(Object.getPrototypeOf(bar)); // returns: Foo {} 
    console.log(Foo.isPrototypeOf(bar)); // returns: false 

Inoltre, perché la seconda realizzazione di ritorno sia Foo {} e false ?

Answer 1

Object.create(Foo) significa "creare un oggetto con Foo come prototipo".

new Foo() significa "Creare un oggetto con Foo.prototype come prototipo e Foo come costruttore".

Pertanto Foo è il prototipo di Bar nel primo esempio e la costruzione di Bar nel secondo esempio.

Penso che la seconda parte della tua domanda è richiesto da fuorvianti output su console - Object.getPrototypeOf(bar) in realtà restituisce Foo.prototype, non Foo:

function Foo() {} 
var bar = new Foo(); 

Object.getPrototypeOf(bar) === Foo 
// -> false 

Object.getPrototypeOf(bar) === Foo.prototype 
// -> true 

Answer 2

Quando si utilizza il 'nuovo' parola chiave per un'istanza di un oggetto JavaScript aggiunge in realtà due linee di codice per il tuo oggetto.

Se avete intenzione di creare un oggetto con esemplificazione pseudoclassical si crea il tuo oggetto come questo:

var Foo = function() { 
this.property = 'baz'; 
}; 

Quando si chiama var bar = new Foo() Javascript corre Foo come il seguente:

var Foo = function() { 
// ADDED CODE: var this = Object.create(Foo.prototype); 
this.property = 'baz'; 
// ADDED CODE: return this; 

Utilizzando Object.create crea una relazione di delega dall'oggetto appena creato all'oggetto specificato, quindi nel primo caso la delega sta delegando le sue ricerche a Foo, ma nel secondo caso le ricerche sono delegate a Foo.prototype.

Potresti trovare post sul blog this interessante. Va in istanziazione pseudoclassica (usando la nuova parola chiave) al contrario dell'istanza Prototipale, che non usa la nuova parola chiave.