Campi
I campi della classe vengono dichiarati direttamente nel corpo di una classe, non in modo esplicito
aggiunto come proprietà del valore this
. Tuttavia, il risultato è lo stesso:
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 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 del corso sono funzionalmente identici alle proprietà associate alla classe
utilizzando this
. Ciò significa che è possibile accedervi e modificarle dall'esterno
come qualsiasi altra proprietà.
class MyClass {
myField = true;
}
const myClassInstance = new MyClass();
myClassInstance.myField;
> true
myClassInstance.myField = false;
myClassInstance.myField;
> false;
I campi forniscono la base per alcune delle funzionalità più avanzate dei corsi.
Campi e metodi privati
I campi e i metodi privati non sono accessibili all'esterno di una classe. Un privato è associata a un'istanza di una classe, nel senso che ogni istanza contiene il proprio insieme di campi e metodi 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 { … }
Un campo privato deve essere dichiarato nel corpo della classe contenitore. Puoi
modificarne il valore in un secondo momento come una proprietà di this
, ma non puoi creare il campo
utilizzando this
.
Non è possibile accedere a campi privati altrove in uno script. Questo impedisce che i dati delle proprietà non vengano alterate al di fuori dei metodi getter e setter forniti di interagire con i valori che contengono. Inoltre, questo impedisce l'accesso diretto 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 i browser di solito le console per sviluppatori molto permissivo, ma incoerente, riguardo a consentire l'accesso ai campi privati per il debug scopi:
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
I campi privati sono limitati al corpo della classe che li contiene, il che significa che anche le classi figlio non possono accedere ai campi privati associati 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
Campi e metodi statici
I campi e i metodi statici sono membri della classe stessa, non membri del instance di quella classe. Per questo motivo, i campi statici forniscono una punto per i dati che non saranno univoci per ogni istanza di una classe, ma che tali potrebbe dover fare riferimento, ad esempio le informazioni di configurazione condivise. I metodi statici sono spesso funzioni di utilità per lavorare con le istanze di un , come il confronto o l'ordinamento delle istanze rispetto a un campo che contengono.
Per definire campi e metodi statici nel corpo di una classe, utilizza static
parola chiave:
class MyClass {
static myStaticField;
static myStaticMethod() {}
}
const myClassInstance = new MyClass();
Puoi anche utilizzare la notazione con 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 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'utilizzo di metodi statici è una best practice creando utilità per lavorare con le istanze di una classe. Esempi: includono un metodo statico dedicato all'ordinamento delle istanze di una classe o un che contiene la configurazione necessaria per creare un'istanza di un class e 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
Quali dei seguenti tipi di campi sono accessibili solo dalle all'interno del corso?
Static fields