Campi e metodi dei corsi

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?

Campi privati

Campi del corso

Static fields