CKTIS / JavaScript
Function.prototype e sintassi del costruttore di classe
Distingui la catena dei prototipi di una funzione dalla proprietà `.prototype` usata per le istanze e scopri il ruolo di `new`, `constructor` e `super()` nell’ereditarietà.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
function C(value) {
this.value = value;
}
C.prototype.read = function () {
return this.value;
};
const instance = new C(1);
Function.prototype
Object.getPrototypeOf(C)
C.prototype
Object.getPrototypeOf(instance)
class Base {
constructor(value) {
this.value = value;
}
read() {
return this.value;
}
}
class Derived extends Base {
constructor(value) {
super(value);
this.ready = true;
}
}
const derived = new Derived(2);Function.prototype è l’oggetto funzione integrato da cui le funzioni ereditano metodi come call, apply e bind. È il prototipo diretto di una funzione ordinaria dichiarata con function e di una classe senza extends. La chiamata Function.prototype() restituisce undefined, ma new Function.prototype() genera un TypeError.
C.prototype è un’altra cosa: è una proprietà propria di una funzione costruttrice ordinaria o di una classe C. Se il suo valore è un oggetto, new C(...) normalmente lo usa come prototipo dell’istanza. Controlla il collegamento con Object.getPrototypeOf(instance). Un costruttore può invece restituire esplicitamente un altro oggetto. Aggiungere .prototype a una funzione freccia non la rende utilizzabile con new.
In una class, constructor(...) { ... } inizializza l’istanza, di solito con assegnazioni a this. I metodi pubblici di istanza come read() sono definiti su C.prototype; i metodi static su C. A differenza di una funzione ordinaria, la chiamata diretta a una classe con C(...) genera un TypeError. Sostituire .prototype in una funzione ordinaria non cambia il prototipo delle istanze esistenti. In una classe la proprietà non è scrivibile, ma l’oggetto prototipo rimane modificabile.
In class Derived extends Base, Derived eredita da Base, mentre Derived.prototype eredita da Base.prototype. In un costruttore derivato esplicito, chiama super(...) prima di usare this; l’uso anticipato di this genera un ReferenceError. Puoi omettere super() se restituisci direttamente un oggetto senza usare this. Se ometti del tutto il costruttore derivato, il costruttore predefinito inoltra gli argomenti.
Esempi
{
function Legacy(name) {
this.name = name;
}
Legacy.prototype.read = function () {
return this.name;
};
class Modern {
constructor(name) {
this.name = name;
}
read() {
return this.name;
}
}
const a = new Legacy('Ada');
const b = new Modern('Lin');
const prototypeOf = Object.getPrototypeOf;
const descriptor = Object.getOwnPropertyDescriptor;
console.log(`${prototypeOf(Legacy) === Function.prototype} ${prototypeOf(Modern) === Function.prototype}`);
console.log(`${prototypeOf(a) === Legacy.prototype} ${prototypeOf(b) === Modern.prototype}`);
console.log(`${a.read()} ${b.read()}`);
console.log(`${descriptor(Legacy, 'prototype').writable} ${descriptor(Modern, 'prototype').writable}`);
try {
Modern('Lin');
} catch (error) {
console.log(error.name);
}
}Risultato
true true true true Ada Lin true false TypeError
Esegui l’intero blocco in una console che supporta la sintassi `class`. Le prime due righe confrontano i prototipi dei costruttori e delle istanze; l’ultima mostra il nome dell’errore senza dipendere dal suo messaggio.
Lezioni correlate
- JavaScript · Lezione 32 · Avanzato · Versione: 4