Felder
Klassenfelder werden direkt im Textkörper einer Klasse deklariert und nicht explizit als Attribut des Werts this hinzugefügt. Das Ergebnis ist jedoch dasselbe: ein für Instanzen dieser Klasse definiertes Attribut.
class MyClass {
myField;
}
const myClassInstance = new MyClass();
myClassInstance;
> MyClass { myField: undefined }
Sie können ein Feld mit einem Wert initialisieren. Dies ist häufig ein Standardwert, der von der Logik innerhalb der Klasse überschrieben werden kann:
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 über this an die Klasse angehängt werden. Das bedeutet, dass sie wie jede andere Property von außerhalb der Klasse aufgerufen und geändert werden können.
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 Attribut ist einer Instanz einer Klasse zugeordnet. Dies bedeutet, dass jede Instanz ihre eigenen privaten Felder und Methoden enthält, die für die Klasse definiert sind.
Wenn Sie eine Eigenschaft als privat kennzeichnen möchten, fügen Sie am Anfang der ID ein # ein, wenn Sie sie deklarieren:
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 den Wert später als Eigenschaft von this ändern. Sie können das Feld jedoch nicht mit this erstellen.
Auf private Felder kann nicht anderswo in einem Skript zugegriffen werden. Dadurch wird verhindert, dass die Dateneigenschaften außerhalb der bereitgestellten Getter- und Setter-Methoden geändert werden, um mit den darin enthaltenen Werten zu interagieren. Außerdem wird der direkte Zugriff auf Methoden verhindert, 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 Entwicklerkonsolen von Browsern in der Regel sehr großzügig, wenn auch uneinheitlich, den Zugriff auf private Felder zur Fehlerbehebung ermöglichen:
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 auch untergeordnete Klassen nicht auf private Felder zugreifen können, die mit einer übergeordneten Klasse verknüpft sind:
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, keine Mitglieder der Instanzen dieser Klasse. Aus diesem Grund bieten statische Felder einen zentralen Punkt für Daten, die nicht für jede Instanz einer Klasse eindeutig sind, auf die diese Instanzen jedoch möglicherweise verweisen müssen, z. B. auf gemeinsame Konfigurationsinformationen. Statische Methoden sind häufig Dienstfunktionen zum Arbeiten mit Instanzen einer Klasse, z. B. zum Vergleichen oder Sortieren von Instanzen mit einem darin enthaltenen Feld.
Verwenden Sie das Schlüsselwort static, um statische Felder und Methoden im Text einer Klasse zu definieren:
class MyClass {
static myStaticField;
static myStaticMethod() {}
}
const myClassInstance = new MyClass();
Sie können auch die 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, sie sind jedoch 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 aus technischer Sicht nicht erforderlich, aber die Verwendung statischer Methoden hat sich zum Erstellen von Dienstprogrammen für die Arbeit mit Instanzen einer Klasse bewährt. Beispiele:
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 innerhalb der Klasse zugegriffen werden?
Static fields