Qual è il vantaggio dell'utilizzo di questo modello di codifica JavaScript per definire le funzioni del costruttore?

Question

tendo a scrivere costruttori degli oggetti nel modo seguente:

function Person(name) { 
    this.name = name; 
} 
Person.prototype.greet = function() { 
    alert("Hello! My name is " + this.name + "."); 
}; 

ho notato un paio di librerie JavaScript e framework aggiungendo un po 'di codice in più in giro che in questo modo:

var Person = (function() { 
    function Person(name) { 
     this.name = name; 
    } 
    Person.prototype.greet = function() { 
     alert("Hello! My name is " + this.name + "."); 
    }; 
    return Person; 
})(); 

So quello che il la funzione anonima self-executing fa e viene usata per. Quello che non riesco a vedere al momento è quale vantaggio o vantaggio ciò offre quando si definisce un costruttore e il suo prototipo.

EDIT # 1:

so che il modello del modulo e dei suoi vantaggi, e utilizzarlo abbastanza spesso nel mio codice. Il mio errore nella comunicazione non era chiaro sul fatto che il mio primo esempio di codice non dovrebbe essere nella portata globale. Comprendo sempre tutti i miei file JavaScript esterni in una funzione anonima autoeseguibile per applicare l'ambito locale sul codice.

Per esempio:

;(function (window, undefined) { 
    var p = function (name) { 
     this.name; 
    }; 
    p.prototype.greet = function() { 
     alert("Hello! My name is " + this.name + "."); 
    }; 
    window.Person = window.Person || p; 
})(window); 

Il fatto è che ho visto la tecnica mostrata nel mio secondo esempio di codice utilizzato all'interno una funzione così anonima.

Per esempio:

;(function (window, undefined) { 
    var p = (function() { 
     var q = function (name) { 
      this.name = name; 
     }; 
     q.prototype.greet = function() { 
      alert("Hello! My name is " + this.name + "."); 
     }; 
     return q; 
    })(); 
    window.Person = window.Person || p; 
})(window); 

Questo è dove io sono in perdita per il significato della tecnica.

Answer 1

Il secondo metodo, il modello di modulo, è più portabile. Si noti che è possibile nominare Person tutto ciò che si desidera.

Al primo metodo, è necessario tenere traccia di ogni occorrenza di Person e fare attenzione a non eliminare inavvertitamente parte del metodo quando si copia il costruttore + prototipo in un altro progetto.

Il secondo metodo ha un ulteriore vantaggio: è possibile utilizzare variabili locali/temporanee/throw-away che possono essere utilizzate per definire dinamicamente costanti/metodi/proprietà nello spazio dei nomi.

Answer 2

È effettivamente un namespace vero?

Answer 3

Preferisco la prima soluzione, meno codice più chiaro per me.

Vedo la seconda soluzione migliore solo se si copia incolla spesso il codice per altri biblioteca, ma non credo che questo sia un buon motivo

Answer 4

Questa è la risposta che il mio collega di lavoro, che ha un la conoscenza misteriosa non solo di JavaScript ma di come funzionano tutti i vari motori JavaScript nei browser, mi ha detto che questo modello di codice è un modo superfluo e eccessivamente difensivo per definire gli oggetti usati per trattare i guasti in alcuni parser JavaScript (ha citato in particolare le versioni di Opera) che consentono il creep dell'oscilloscopio. È certamente suoni come una risposta ragionevole ...