CKTIS / JavaScript
Function.prototype e assegnazione di metodi al prototipo
Distingui il prototipo della funzione stessa da quello delle sue istanze e condividi lo stesso metodo tra queste ultime.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
Function.prototype
Object.getPrototypeOf(Constructor)
Constructor.prototype.method = function (arg) { /* method body */ };
const instance = new Constructor();
instance.method(arg);
Object.getPrototypeOf(instance)Function.prototype è l’oggetto integrato da cui una funzione ordinaria come Counter eredita i metodi call, apply e bind. Usa Object.getPrototypeOf(Counter) per vedere il prototipo della funzione stessa. Invece, Counter.prototype è una proprietà propria del costruttore: fa riferimento all’oggetto che new Counter(...) usa come prototipo della nuova istanza.
Counter.prototype.double = function () { return this.value * 2; }; salva la funzione sul prototipo anziché copiarla in ogni istanza. Con early.double(), JavaScript cerca prima una proprietà propria double su early, poi risale la catena dei prototipi. Anche se trova la funzione sul prototipo, this vale early. Una funzione freccia non può sostituirla in questo caso: prende this dall’ambito circostante.
Se aggiungi un metodo all’oggetto prototipo esistente, sarà disponibile anche per le istanze già create, a meno che una proprietà propria non lo nasconda. Invece, Counter.prototype = {} sostituisce l’oggetto usato dalle chiamate successive a new Counter(...). Le istanze esistenti continuano a fare riferimento al prototipo precedente.
Aggiungi i metodi di istanza al prototipo del tuo costruttore, non a Function.prototype. Modificare quel prototipo integrato può influire anche su altre funzioni che ereditano da esso.
Esempi
{
function Counter(value) {
this.value = value;
}
const early = new Counter(3);
Counter.prototype.double = function () {
return this.value * 2;
};
const late = new Counter(5);
console.log(Object.getPrototypeOf(Counter) === Function.prototype);
console.log(Object.getPrototypeOf(early) === Counter.prototype);
console.log(early.double === late.double);
console.log(late.double());
Counter.prototype = {};
console.log(early.double());
console.log(typeof (new Counter(7)).double);
}Risultato
true true true 10 6 undefined
`early` viene creata prima che il metodo sia aggiunto, ma lo eredita comunque. Dopo la sostituzione del prototipo, `early.double()` restituisce ancora `6`, mentre `typeof` restituisce `"undefined"` per `double` sulla nuova istanza.
Lezioni correlate
- JavaScript · Lezione 38 · Intermedio · Versione: 3