static
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since March 2016.
Das static
Schlüsselwort definiert eine statische Methode oder ein statisches Feld für eine Klasse oder einen statischen Initialisierungsblock (siehe den Link für weitere Informationen zur Verwendung). Statische Eigenschaften können nicht direkt auf Instanzen der Klasse zugegriffen werden. Stattdessen greift man über die Klasse selbst darauf zu.
Statische Methoden sind oft Hilfsfunktionen, wie Funktionen zum Erstellen oder Klonen von Objekten, während statische Eigenschaften nützlich für Caches, feste Konfigurationen oder andere Daten sind, die nicht über Instanzen hinweg repliziert werden müssen.
Hinweis: Im Kontext von Klassen verwendet der Inhalt der MDN Web Docs die Begriffe Eigenschaften und Felder austauschbar.
Probieren Sie es aus
Syntax
class ClassWithStatic {
static staticField;
static staticFieldWithInitializer = value;
static staticMethod() {
// …
}
}
Es gibt einige zusätzliche Syntaxbeschränkungen:
- Der Name einer statischen Eigenschaft (Feld oder Methode) kann nicht
prototype
sein. - Der Name eines Klassenfeldes (statisch oder instanziiert) kann nicht
constructor
sein.
Beschreibung
Diese Seite führt in öffentliche statische Eigenschaften von Klassen ein, die statische Methoden, statische Zugriffs- und statische Felder umfassen.
- Für private statische Funktionen siehe private Eigenschaften.
- Für Instanzfunktionen siehe Methodendefinitionen, Getter, Setter und öffentliche Klassenfelder.
Öffentliche statische Funktionen werden mit dem static
Schlüsselwort deklariert. Sie werden zum Klassenkonstruktor hinzugefügt, wenn die Klassenauswertung mit der [[DefineOwnProperty]]
Semantik durchgeführt wird (was im Wesentlichen Object.defineProperty()
ist). Sie werden erneut vom Klassenkonstruktor aus aufgerufen.
Statische Methoden sind oft Hilfsfunktionen, wie Funktionen zum Erstellen oder Klonen von Instanzen. Öffentliche statische Felder sind nützlich, wenn Sie möchten, dass ein Feld nur einmal pro Klasse existiert und nicht in jeder Klasseninstanz, die Sie erstellen. Dies ist nützlich für Caches, feste Konfigurationen oder andere Daten, die nicht über Instanzen hinweg repliziert werden müssen.
Statische Feldnamen können berechnet werden. Der this
Wert im berechneten Ausdruck ist das this
, das die Klassendefinition umgibt, und ein Verweis auf den Namen der Klasse ist ein ReferenceError
, da die Klasse noch nicht initialisiert ist. await
und yield
arbeiten in diesem Ausdruck wie erwartet.
Statische Felder können einen Initialisierer haben. Statische Felder ohne Initialisierer werden auf undefined
initialisiert. Öffentliche statische Felder werden in Unterklassen nicht neu initialisiert, können aber über die Prototypenkette zugegriffen werden.
class ClassWithStaticField {
static staticField;
static staticFieldWithInitializer = "static field";
}
class SubclassWithStaticField extends ClassWithStaticField {
static subStaticField = "subclass field";
}
console.log(Object.hasOwn(ClassWithStaticField, "staticField")); // true
console.log(ClassWithStaticField.staticField); // undefined
console.log(ClassWithStaticField.staticFieldWithInitializer); // "static field"
console.log(SubclassWithStaticField.staticFieldWithInitializer); // "static field"
console.log(SubclassWithStaticField.subStaticField); // "subclass field"
Im Feld-Initialisierer bezieht sich this
auf die aktuelle Klasse (die Sie auch über ihren Namen aufrufen können), und super
bezieht sich auf den Basisklassenkonstruktor.
class ClassWithStaticField {
static baseStaticField = "base static field";
static anotherBaseStaticField = this.baseStaticField;
static baseStaticMethod() {
return "base static method output";
}
}
class SubClassWithStaticField extends ClassWithStaticField {
static subStaticField = super.baseStaticMethod();
}
console.log(ClassWithStaticField.anotherBaseStaticField); // "base static field"
console.log(SubClassWithStaticField.subStaticField); // "base static method output"
Der Ausdruck wird synchron ausgewertet. Sie können await
oder yield
nicht im Initialisiererausdruck verwenden. (Betrachten Sie den Initialisiererausdruck als implizit in eine Funktion gehüllt.)
Statische Feld-Initialisierer und statische Initialisierungsblöcke werden nacheinander ausgewertet. Feld-Initialisierer können sich auf Feldwerte oberhalb beziehen, nicht jedoch darunter. Alle statischen Methoden werden vorher hinzugefügt und können aufgerufen werden, obwohl es möglicherweise nicht wie erwartet funktioniert, wenn sie auf Felder unter dem zu initialisierenden zurückgreifen.
Hinweis: Dies ist wichtiger bei privaten statischen Feldern, da der Zugriff auf ein nicht initialisiertes privates Feld einen TypeError
wirft, selbst wenn das private Feld unterhalb deklariert wird. (Wenn das private Feld nicht deklariert ist, wäre es ein früher SyntaxError
.)
Beispiele
Verwendung statischer Mitglieder in Klassen
Das folgende Beispiel zeigt mehrere Dinge:
- Wie ein statisches Mitglied (Methode oder Eigenschaft) in einer Klasse definiert wird.
- Dass eine Klasse mit einem statischen Mitglied unterklassenfähig ist.
- Wie ein statisches Mitglied aufgerufen werden kann und nicht aufgerufen werden kann.
class Triple {
static customName = "Tripler";
static description = "I triple any number you provide";
static calculate(n = 1) {
return n * 3;
}
}
class SquaredTriple extends Triple {
static longDescription;
static description = "I square the triple of any number you provide";
static calculate(n) {
return super.calculate(n) * super.calculate(n);
}
}
console.log(Triple.description); // 'I triple any number you provide'
console.log(Triple.calculate()); // 3
console.log(Triple.calculate(6)); // 18
const tp = new Triple();
console.log(SquaredTriple.calculate(3)); // 81 (not affected by parent's instantiation)
console.log(SquaredTriple.description); // 'I square the triple of any number you provide'
console.log(SquaredTriple.longDescription); // undefined
console.log(SquaredTriple.customName); // 'Tripler'
// This throws because calculate() is a static member, not an instance member.
console.log(tp.calculate()); // 'tp.calculate is not a function'
Aufrufen statischer Mitglieder aus einer anderen statischen Methode
Um eine statische Methode oder Eigenschaft innerhalb einer anderen statischen Methode derselben Klasse aufzurufen, können Sie das this
Schlüsselwort verwenden.
class StaticMethodCall {
static staticProperty = "static property";
static staticMethod() {
return `Static method and ${this.staticProperty} has been called`;
}
static anotherStaticMethod() {
return `${this.staticMethod()} from another static method`;
}
}
StaticMethodCall.staticMethod();
// 'Static method and static property has been called'
StaticMethodCall.anotherStaticMethod();
// 'Static method and static property has been called from another static method'
Aufrufen statischer Mitglieder aus einem Klassenkonstruktor und anderen Methoden
Statische Mitglieder sind nicht direkt zugänglich über das this
Schlüsselwort aus nicht-statischen Methoden. Sie müssen sie mit dem Klassennamen aufrufen:
KLASSENNAME.STATISCHE_METHODEN_NAME()
/
KLASSENNAME.STATISCHE_EIGENSCHAFTS_NAME
oder indem Sie die Methode als Eigenschaft des constructors
aufrufen: this.constructor.STATISCHE_METHODEN_NAME()
/
this.constructor.STATISCHE_EIGENSCHAFTS_NAME
class StaticMethodCall {
constructor() {
console.log(StaticMethodCall.staticProperty); // 'static property'
console.log(this.constructor.staticProperty); // 'static property'
console.log(StaticMethodCall.staticMethod()); // 'static method has been called.'
console.log(this.constructor.staticMethod()); // 'static method has been called.'
}
static staticProperty = "static property";
static staticMethod() {
return "static method has been called.";
}
}
Spezifikationen
Specification |
---|
ECMAScript Language Specification # sec-class-definitions |
Browser-Kompatibilität
BCD tables only load in the browser