Klassenfelder und -methoden

Felder

Klassenfelder werden direkt im Text einer Klasse deklariert, nicht explizit als Eigenschaft des this-Werts hinzugefügt. Das Ergebnis ist jedoch das gleiche: Eigenschaft definiert, die für Instanzen dieser Klasse definiert ist.

class MyClass {
    myField;
}

const myClassInstance = new MyClass();

myClassInstance;
> MyClass { myField: undefined }

Sie können ein Feld mit einem Wert initialisieren. Dies ist oft ein Standardwert, kann die Logik innerhalb der Klasse Folgendes überschreiben:

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 }

Klassenfelder sind funktional identisch mit Eigenschaften, die an die Klasse angehängt sind. mit this. Das bedeutet, dass sie von außerhalb des wie jede andere Property.

class MyClass {
    myField = true;
}

const myClassInstance = new MyClass();

myClassInstance.myField;
> true

myClassInstance.myField = false;

myClassInstance.myField;
> false;

Felder bilden die Grundlage für einige der erweiterten Funktionen von Klassen.

Private Felder und Methoden

Private Felder und Methoden sind außerhalb einer Klasse nicht zugänglich. Ein privates Property ist einer Instanz einer Klasse zugeordnet, was bedeutet, dass jede Instanz enthält eigene private Felder und Methoden, wie für die Klasse definiert.

Wenn Sie eine Property als privat kennzeichnen möchten, fügen Sie am Anfang der ID # hinzu, wenn geben Sie Folgendes an:

class MyClass {
    #myPrivateField = true;
    #myPrivateMethod() {}
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass { #myPrivateField: true }
    #myPrivateField: true
    <prototype>: Object { … }
        constructor: class MyClass {}
        <prototype>: Object { … }

Ein privates Feld muss im Text der enthaltenden Klasse deklariert werden. Sie können Ändern Sie seinen Wert später als Eigenschaft von this, aber Sie können das Feld nicht erstellen. mit this.

Auf private Felder im Script kann nicht zugegriffen werden. Dadurch wird verhindert, Eigenschaften, die außerhalb der bereitgestellten Getter- und Setter-Methoden geändert werden mit den darin enthaltenen Werten zu interagieren. Außerdem verhindert es den direkten Zugriff auf -Methoden, die nur für die Verwendung innerhalb der Klasse selbst vorgesehen sind.

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 }

Beachten Sie jedoch, dass die sind Entwicklerkonsolen sehr großzügig, wenn auch inkonsistent, über das Zulassen des Zugriffs auf private Felder für das Debugging Zwecke:

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

Private Felder sind eng auf den Text der Klasse beschränkt, in der sie enthalten sind. Das bedeutet, dass selbst untergeordnete Klassen nicht auf private Felder zugreifen können, die mit einer übergeordnete Klasse:

class MyClass {
    #myPrivateField = true;
}
class ChildClass extends MyClass {
    childMethod() {
        console.log( this.#myPrivateField );
    }
}
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateField

Statische Felder und Methoden

Statische Felder und Methoden sind Mitglieder einer Klasse selbst, nicht Mitglieder der instances dieser Klasse. Aus diesem Grund stellen statische Felder eine für Daten, die nicht für jede Instanz einer Klasse eindeutig sind, Instanzen müssen möglicherweise auf gemeinsame Konfigurationsinformationen verweisen. Statische Methoden sind häufig Dienstfunktionen für die Arbeit mit Instanzen eines an, z. B. zum Vergleichen oder Sortieren von Instanzen mit einem darin enthaltenen Feld.

Um statische Felder und Methoden im Text einer Klasse zu definieren, verwenden Sie die static Suchbegriff:

class MyClass {
    static myStaticField;
    static myStaticMethod() {}
}
const myClassInstance = new MyClass();

Sie können auch eine Punktnotation verwenden, um eine statische Methode zu erstellen:

class MyClass {
    constructor() {}
}
MyClass.myStaticMethod = function() {}

Sie können nicht über eine Instanz ihrer Klasse auf statische Attribute zugreifen, im Klassenkonstruktor verfügbar:

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."

Sie sind technisch nicht erforderlich, aber die Verwendung statischer Methoden ist eine Best Practice für Erstellen von Dienstprogrammen für die Arbeit mit Instanzen einer Klasse. Beispiele dafür sind eine statische Methode zum Sortieren von Instanzen einer Klasse oder eine statische Factory-Methode, die alle erforderlichen Einstellungen zum Erstellen der Instanz eines class und gibt dann die Klasseninstanz zurück:

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" }

Wissen testen

Auf welche der folgenden Feldtypen kann nur zugegriffen werden? innerhalb des Kurses?

Private Felder

Klassenfelder

Static fields