Nuovo restituirà l'istanza del costruttore della funzione denominata-?

Question

var foo = function() { 
    return new moo(); 
} 

var moo = function() { 
    return this; 
} 

Se eseguo la dichiarazione

new foo() 

posso effettivamente ottenere un'istanza di moo? Questo sembra allo stesso tempo ovvio e non intuitivo. Funzionalmente, questo è ciò che dovrebbe accadere, ma allo stesso tempo non è previsto se non si conoscono gli interni.

EDIT: Ho capito che questo sembra non intuitivo b.c. in Java i costruttori non possono restituire nulla.

Questo è molto simile al modello di costruzione utilizzato da jquery.

Answer 1

Sì otterrete un'istanza di moo.

la non-intuitività è dovuta al fatto che è possibile restituire qualcosa di diverso dall'oggetto stesso in un costruttore javascvipt. Ciò è possibile perché tutte le funzioni sono in effetti oggetti in js. In linguaggi come java e C# che non è possibile, il costruttore restituisce sempre l'oggetto a cui appartiene il costruttore. Non è inoltre possibile chiamare controtettori senza nuove parole chiave in tali lingue. Non restituire nulla dal costruttore è lo stesso sottile di return this; in js thing (supponendo che sia usato un costruttore) aggiunge anche un po 'di confusione.

Answer 2

lei ha ragione otterrete un'istanza di moo

La ragione di questo essere così ambiguo è perché ogni volta che viene utilizzato nuova parola chiave, the newly created object's constructor is not executed until 'this' keyword is used. il nuovo oggetto è associato alla parola chiave 'this'.

riferiscono questo da: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new

Quando viene eseguito il nuovo codice di foo (...), le seguenti cose accadono:

1. Viene creato un nuovo oggetto, che eredita da foo.prototype .
2. La funzione di costruzione foo viene chiamata con gli argomenti specificati e viene associata all'oggetto appena creato. new foo è equivalente a new foo(), cioè se non è specificato alcun elenco di argomenti, foo è chiamato senza argomenti.
3. L'oggetto restituito dalla funzione di costruzione diventa il risultato dell'intera nuova espressione. Se la funzione di costruzione non restituisce esplicitamente un oggetto, , l'oggetto creato nel passaggio 1 viene utilizzato invece . (Costruttori normalmente non restituiscono un valore, ma possono scegliere di farlo se vogliono ignorare il normale oggetto creazione processo.)

Nel tuo esempio, anche viene creato un nuovo oggetto, ma 'questa' parola chiave non viene usata e quindi il costruttore per foo non viene chiamato e quindi la funzione termina solo restituendo l'oggetto moo.

http://jsfiddle.net/v5aGu/

var foo = function() { 
    return new moo(); 
} 

var moo = function() { 
    return this; 
} 

var myFoo = new foo(2); 
if(myFoo instanceof moo){ 
    alert("moo"); 
} 
if(myFoo instanceof foo){ 
    alert("foo"); 
} 

Modifica: Per rispondere alla domanda sollevata da @Desu

id = 0; 

var foo = function(){ 

} 

if(new foo() instanceof foo){ 
alert("yes"); //alerts yes 
} 

JavaScript Costruttori 101:

1. Il comportamento predefinito di costruttore è di tornare 'questo 'se nient'altro viene restituito
2. Se un altro oggetto viene restituito da un costruttore nuovo oggetto creato legato a 'questo' viene scartato

http://jsfiddle.net/xQVuX/1/

id = 0; 

var foo = function(){ 
} 

if(new foo() instanceof foo){ 
alert("foo yes"); //alerts foo yes because foo returns this as a default behavior 
} 

var foo2 = function(){ 
    var i=new foo(); 
    return i; 
} 

if(new foo2() instanceof foo2){ 
alert("foo2 yes");// does not alert because foo2 returns another object and the newly created object is discarded 
} 

var foo3 = function(){ 
    this.i = 10; 
} 

if(new foo3() instanceof foo3){ 
    alert("foo3 yes"); // alerts foo3 yes because foo3 returns this as a default behavior 
}