Usando 'ritorno' per la creazione di oggetti con 'nuovo'

Question

ho trovato qualcosa di molto strano oggi: se si crea oggetti con una funzione di costruzione e la parola chiave new, ma return una funzione dal costruttore, si comporta in questo modo:

1. Il "oggetto" appena creato è invece una funzione.
2. Questa nuova funzione può essere invocata come normale, però ...
3. Se si mantiene un riferimento alla this nella funzione di costruzione, this riferimento a un oggetto che è stato correttamente creato dal costruttore. È quello che ti aspettavi di essere restituito da new.

Ecco un esempio:

function Constructor() { 
    var self = this; 

    this.name = 'instance'; 
    return function() { 
    return self; 
    } 
} 

Quindi, se avete istanziato in questo modo: var instance = new Constructor() Di seguito si tradurrebbe:

typeof instance //returns "function" 
typeof instance() //returns "object" 
instance()   //returns { name: 'instance' } 

Quindi credo Ho tre domande:

1. È legale e funziona? k cross-browser? È davvero fantastico e penso che possa essere usato in molti modi, ma questo comportamento è affidabile?
2. Cosa succede in background che causa questo comportamento?
3. (forse ha risposto con 2, ma ...) Il nuovo oggetto (quello referenziato con 'this') all'interno della nuova istanza, in modo che sia tutto autonomo e che venga corretto correttamente dal garbage collector?

Answer 1

1. Sì, mentre un costruttore di default restituisce il nuovo oggetto in costruzione (che fa riferimento this), è possibile ignorare che il valore di ritorno purché si restituire un oggetto. Poiché una funzione è un oggetto, puoi restituirla come nel tuo esempio. L'oggetto appena creato è non una funzione stessa, ma la funzione restituita fa riferimento all'oggetto appena creato nel suo ambito variabile.

2. Vedi # 1

3. Questo perché una funzione crea una chiusura, così continua fare riferimento alla variabile self, che avviene per fare riferimento all'oggetto effettivo in costruzione. Quindi non direi che è "dentro" qualsiasi cosa, ma piuttosto è semplicemente parte dell'ambito variabile della funzione.

La cosa da capire è che la funzione non è diversa da qualsiasi altra funzione. Proprio come se avessi invece restituito una matrice, avresti semplicemente una matrice regolare, che potrebbe fare riferimento al nuovo oggetto.

function Constructor() { 

    this.name = 'instance'; 
    return [ this ]; // Instead return an Array that references the new object 
} 

Answer 2

Bene, questa è una domanda davvero buona e, come avrete intuito, non è stata una risposta facile.

Per dirla in parole semplici:
1) Sì e Sì; questa è una delle straordinarie funzionalità che non si trovano nei linguaggi di programmazione "tradizionali".
2) Si prega di leggere su chiusure (link qui sotto)
3) Sì (leggi tutto)

Si dovrebbe leggere di più su Javascript Closures: http://jibbering.com/faq/notes/closures/
http://www.javascriptkit.com/javatutors/closures.shtml (qui avete ottenuto alcuni buoni esempi di lavoro)

e, più in particolare, il modello di ereditarietà Parassita:
http://blog.higher-order.net/2008/02/21/javascript-parasitic-inheritance-power-constructors-and-instanceof/

Spero che questo aiuta

Answer 3

questo è quello che si chiama un closure

ciò che fa è creare un ambiente di codice autonomo (comunemente noto come un oggetto)

typeof instance //returns "function" - since it's not "fired" or called. just returns the function declaration (correct me if i'm wrong) 
typeof instance() //returns "object" - it returns an object since you called it 
instance()   //returns an object also - you called it, but you didn't store it 

un esempio di un oggetto costruito utilizzando una chiusura:

function Constructor() { 
    var privateProperty = 'private'; 
    var privateMethod = function(){ 
     alert('called from public method'); 
    }; 

    //return only what's to be seen in public 
    return { 
     publicProperty: 'im public', 
     publicMethod: function(){ 
      alert('called from public method'); 
     } 
     getter: privateMethod //assign to call the private method 
    } 
} 

var myObj = Constructor(); 
var pubProp = myObj.publicProperty; // pubProp = 'im public' 
myObj.publicMethod()    //alert: 'called from public method'; 
myObj.getter()      //alert: 'called from public method'; 

//cannot access since "private": 
myObj.privateProperty 
myObj.privateMethod