Definizione di un prototipo di Javascript

Quali sono le differenze funzionali tra i seguenti due prototipi di Javascript e quali sono i vantaggi di sceglierne uno rispetto all’altro?

Opzione 1:

Person.prototype.sayName = function(name) { alert(name); } 

Opzione 2:

 Person.prototype = { sayName: function(name) { alert(name); } } 

Ho ragione nel ritenere che l’ Opzione 2 porti a cestinare alcune funzioni che sono implicitamente legate al prototipo?

Ho ragione nel ritenere che l’Opzione 2 porti a cestinare alcune funzioni che sono implicitamente legate al prototipo?

Si, esattamente. Sebbene l’unica proprietà implicitamente legata sia la proprietà del constructor , di cui raramente hai bisogno.

Quali sono le differenze funzionali?

L’opzione 1 sta semplicemente estendendo il prototipo esistente. Se ci sono già istanze Person ereditano dall’object prototipo, saranno in grado di usare anche il metodo sayName . Con l’opzione 2, il nuovo prototipo verrà utilizzato solo per oggetti istanziati dopo la sovrascrittura.

Ci sono dei vantaggi nello scegliere l’uno rispetto all’altro?

Questi dovrebbero essere auto-esplicativi ora. L’opzione 1 (estensione) è considerata più pulita, ed è un must se stai modificando prototipi stranieri / sconosciuti / nativi. Cerca di evitare l’opzione 2.

Se ti piace ancora la syntax letterale dell’object, dovresti considerare l’uso di Object.assign per estendere il prototipo esistente:

 Object.assign(Person.prototype, { sayName: function(name) { alert(name); } }); 

Potrebbe essere necessario il polyfill Object.assign per gli ambienti pre-ES6. In alternativa, $.extend o _.extend funzionano altrettanto bene. Sicuramente anche la tua libreria preferita ha una funzione di supporto per questo.

Il secondo sovrascrive person.prototype con l’object.

Metodo uno:

 Object.toString=function(){ return "Object to string"; } var Person = function(){ }; Person.toString=function(){ return "Person to string"; } Person.prototype.sayName=function(){} console.log(Person.prototype.constructor.toString());// "Person to string" 

Metodo due:

 Object.toString=function(){ return "Object to string"; } var Person = function(){ }; Person.toString=function(){ return "Person to string"; } Person.prototype = { sayName:function(){} } console.log(Person.prototype.constructor.toString());// "Object to string" 

Il primo è buono per una o due funzioni extra, ma definire un prototipo totalmente nuovo con molte funzioni sarebbe molto ripetitivo. D’altra parte, facendo il secondo distruggerebbe tutte le definizioni esistenti per il prototipo come lei ha menzionato.

In pratica, ho usato il primo per definire funzioni aggiuntive in Array e Math, ecc., Un po ‘come le categorie in Objective-C. Quest’ultimo uso come una “definizione di class”.

Qualsiasi istanza esistente del costruttore continuerà a puntare al vecchio object prototipo. Qualsiasi nuova istanza creata punterà al nuovo object prototipo.


I vantaggi dell’opzione 1 rispetto all’opzione 2 sono semplicemente che non è necessario ristabilire la proprietà del costruttore e si risparmia un livello di indentazione che è enorme per me.

Per salvare la ripetizione, assegno semplicemente la proprietà a una variabile locale:

 var method = Person.prototype; method.getAge = function() { return this.age; }; method.getName = function() { return this.name; }; 

Anche le scelte comuni sono fn (jQuery) e p che sono ancora più brevi del method .

in parole semplici la differenza è in Person.prototype.sayName tutto quello che devi fare è aggiungere una funzione al prototype . solo aggiungendo nuove funzionalità.

Nel secondo Person.prototype = {} qui stai facendo un nuovo intero object e lo assegni al prototype . Quindi tu crei un nuovo object o sovrascrivi il prototype con un nuovo object.

Il primo metodo è buono per aggiungere molte funzioni come vuoi su richiesta . È ansible aggiungerli uno alla volta, quindi ritengo utile quando il programma è semplice e gli oggetti dell’applicazione non condividono molte funzioni o oggetti tra loro.

Il secondo metodo è buono se gli oggetti dell’applicazione condividono alcuni oggetti (o un gruppo di funzioni come @isaach detto nelle Math functions ) tra loro.