Campi
I campi della classe vengono dichiarati direttamente nel corpo di una classe, non aggiunti esplicitamente
come proprietà del valore this. Tuttavia, il risultato è lo stesso: una proprietà
definita sulle istanze di quella classe.
class MyClass {
myField;
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass { myField: undefined }
Puoi inizializzare un campo con un valore. Spesso si tratta di un valore predefinito che la logica all'interno della classe può sovrascrivere:
class MyClass {
myResult = false;
set setValue( myValue ) {
this.myResult = myValue;
}
}
const myClassInstance = new MyClass();
myClassInstance;
> Object { myResult: false }
myClassInstance.setValue = true;
myClassInstance;\
> Object { myResult: true }
I campi della classe sono identici dal punto di vista delle proprietà associate alla classe utilizzando this. Ciò significa che è possibile accedervi e modificarli dall'esterno della classe come qualsiasi altra proprietà.
class MyClass {
myField = true;
}
const myClassInstance = new MyClass();
myClassInstance.myField;
> true
myClassInstance.myField = false;
myClassInstance.myField;
> false;
I campi forniscono una base per alcune delle funzionalità più avanzate dei corsi.
Metodi e campi privati
I campi e i metodi privati sono inaccessibili al di fuori di una classe. Una proprietà privata è associata a un'istanza di una classe, il che significa che ogni istanza contiene il proprio insieme di metodi e campi privati, come definito nella classe.
Per rendere privata una proprietà, aggiungi # all'inizio dell'identificatore quando
lo dichiari:
class MyClass {
#myPrivateField = true;
#myPrivateMethod() {}
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass { #myPrivateField: true }
#myPrivateField: true
<prototype>: Object { … }
constructor: class MyClass {}
<prototype>: Object { … }
È necessario dichiarare un campo privato nel corpo della classe contenitore. Puoi
modificare il valore in un secondo momento come proprietà di this, ma non puoi creare il campo
utilizzando this.
Non è possibile accedere ai campi privati da qualsiasi altra posizione in uno script. Ciò impedisce che le proprietà dei dati vengano modificate al di fuori dei metodi getter e setter forniti per interagire con i valori che contengono e impedisce l'accesso diretto ai metodi destinati a essere utilizzati solo all'interno della classe stessa.
class MyClass {
#myResult = false;
set setValue( myValue ) {
this.#myResult = myValue;
}
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass { #myResult: false }
myClassInstance.#myResult = true;
> Uncaught SyntaxError: reference to undeclared private field or method #myResult
myClassInstance.setValue = true;
myClassInstance;\
> MyClass { #myResult: true }
Tuttavia, tieni presente che le console per gli sviluppatori dei browser sono generalmente molto permissive, anche se incoerenti, in merito all'autorizzazione dell'accesso ai campi privati per scopi di debug:
class MyClass {
#myPrivateField = true;
#myPrivateMethod() {
console.log( "This is inside a private method." );
}
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass {#myPrivateField: true}
myClassInstance.#myPrivateField;
> true
myClassInstance.#myPrivateMethod();
> "This is inside a private method."
class MyClass {
#myPrivateField = true;
#myPrivateMethod() {
console.log( "This is inside a private method." );
}
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass {#myPrivateField: true}
myClassInstance.#myPrivateField;
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateField
myClassInstance.#myPrivateMethod();
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateMethod
L'ambito dei campi privati è ristretto al corpo della classe che li contiene, il che significa che nemmeno le classi secondarie non possono accedere ai campi privati associati a una classe padre:
class MyClass {
#myPrivateField = true;
}
class ChildClass extends MyClass {
childMethod() {
console.log( this.#myPrivateField );
}
}
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateField
Metodi e campi statici
I campi e i metodi statici fanno parte di una classe stessa, non dei membri delle istanze di quella classe. Per questo motivo, i campi statici forniscono un punto centrale per i dati non univoci per ogni istanza di una classe, ma che potrebbero dover fare riferimento a queste istanze, ad esempio informazioni di configurazione condivise. I metodi statici sono spesso funzioni di utilità per lavorare con le istanze di una classe, come confrontare o ordinare le istanze in base a un campo che contengono.
Per definire metodi e campi statici nel corpo di una classe, utilizza la parola chiave static:
class MyClass {
static myStaticField;
static myStaticMethod() {}
}
const myClassInstance = new MyClass();
Puoi anche utilizzare la notazione dei punti per creare un metodo statico:
class MyClass {
constructor() {}
}
MyClass.myStaticMethod = function() {}
Non puoi accedere alle proprietà statiche da un'istanza della loro classe, ma sono disponibili nel costruttore della classe:
class MyClass {
static myStaticField = true;
static myStaticMethod() {
console.log( "A static method." );
}
}
const myClassInstance = new MyClass();
myClassInstance.myStaticField;
> undefined
myClassInstance.myStaticMethod();
> Uncaught TypeError: myClassInstance.myStaticMethod is not a function
MyClass.myStaticField;
> true
MyClass.myStaticMethod();
> "A static method."
Non sono tecnicamente obbligatori, ma l'uso di metodi statici è una best practice per creare utilità che funzionino con le istanze di una classe. Alcuni esempi potrebbero includere un metodo statico dedicato all'ordinamento delle istanze di una classe o un metodo statico di produzione che contiene qualsiasi configurazione necessaria per creare un'istanza di una classe e quindi restituisce l'istanza di classe:
class User {
constructor( name, email ) {
this.name = name;
this.email = email;
}
static fromObject( myObject ) {
return new User( myObject.name, myObject.email ?? "Omitted" );
}
}
const userObject = {
"name" : "My Name",
"email" : "my@email.address"
};
const secondUserObject = {
"name" : "My Name"
};
const firstUser = User.fromObject( userObject );
const secondUser = User.fromObject( secondUserObject );
firstUser;
> Object { name: "My Name", email: "my@email.address" }
secondUser;
> Object { name: "My Name", email: "Omitted" }
Verifica le tue conoscenze
A quali dei seguenti tipi di campi è possibile accedere solo dall'interno della classe?
Static fields