Objektinitialisierer
Baseline
Weitgehend verfügbar
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Ein Objektinitialisierer ist eine durch Kommas getrennte Liste aus null oder mehr Paaren von Eigenschaftsnamen und zugehörigen Werten eines Objekts, die in geschweifte Klammern ({}) eingeschlossen ist. Objekte können auch mit Object.create() oder durch Aufrufen einer Konstruktorfunktion mit dem Operator new initialisiert werden.
Probieren Sie es aus
const object1 = { a: "foo", b: 42, c: {} };
console.log(object1.a);
// Expected output: "foo"
const a = "foo";
const b = 42;
const c = {};
const object2 = { a: a, b: b, c: c };
console.log(object2.b);
// Expected output: 42
const object3 = { a, b, c };
console.log(object3.a);
// Expected output: "foo"
Syntax
o = {
a: "foo",
b: 42,
c: {},
1: "number literal property",
"foo:bar": "string literal property",
shorthandProperty,
method(parameters) {
// …
},
get property() {},
set property(value) {},
[expression]: "computed property",
__proto__: prototype,
...spreadProperty,
};
Beschreibung
Ein Objektinitialisierer ist ein Ausdruck, der die Initialisierung eines Object beschreibt. Objekte bestehen aus Eigenschaften, mit denen ein Objekt beschrieben wird. Die Werte von Objekteigenschaften können entweder primitive Datentypen oder andere Objekte sein.
Objektliteral-Syntax im Vergleich zu JSON
Die Objektliteral-Syntax ist nicht dasselbe wie die JavaScript Object Notation (JSON). Obwohl sie ähnlich aussehen, gibt es Unterschiede:
- JSON erlaubt die Definition von Eigenschaften nur mit der Syntax
"property": value. Der Eigenschaftsname muss in doppelten Anführungszeichen stehen, und die Definition darf keine Kurzschreibweise sein. Berechnete Eigenschaftsnamen sind ebenfalls nicht erlaubt. - Werte von JSON-Objekteigenschaften können nur Zeichenfolgen, Zahlen,
true,false,null, Arrays oder andere JSON-Objekte sein. Daher kann JSON weder Methoden noch Objekte wieMapoderRegExpdarstellen. - In JSON ist
"__proto__"ein gewöhnlicher Eigenschaftsschlüssel. In einem Objektliteral legt er den Prototyp des Objekts fest.
JSON ist eine strikte Teilmenge der Objektliteral-Syntax. Das bedeutet, dass jeder gültige JSON-Text als Objektliteral geparst werden kann und dabei in der Regel keine Syntaxfehler verursacht. Die einzige Ausnahme ist, dass die Objektliteral-Syntax doppelte __proto__-Schlüssel verbietet; für JSON.parse() gilt das nicht. JSON.parse() behandelt __proto__ wie eine gewöhnliche Eigenschaft und verwendet das letzte Vorkommen als Eigenschaftswert. Auch der dargestellte Objektwert (also die Semantik) unterscheidet sich nur, wenn der Quelltext den Schlüssel __proto__ enthält: Bei Objektliteralen legt er den Prototyp des Objekts fest, bei JSON ist er eine gewöhnliche Eigenschaft.
console.log(JSON.parse('{ "__proto__": 0, "__proto__": 1 }')); // {__proto__: 1}
console.log({ "__proto__": 0, "__proto__": 1 }); // SyntaxError: Duplicate __proto__ fields are not allowed in object literals
console.log(JSON.parse('{ "__proto__": {} }')); // { __proto__: {} }
console.log({ "__proto__": {} }); // {} (with {} as prototype)
Beispiele
>Objekte erstellen
Ein leeres Objekt ohne Eigenschaften kann so erstellt werden:
const object = {};
Der Vorteil der Literal- oder Initialisierer-Schreibweise besteht jedoch darin, dass Sie Objekte mit Eigenschaften direkt innerhalb der geschweiften Klammern erstellen können. Dazu geben Sie eine durch Kommas getrennte Liste von key: value-Paaren an.
Der folgende Code erstellt ein Objekt mit drei Eigenschaften und den Schlüsseln "foo", "age" und "baz". Die zugehörigen Werte sind die Zeichenfolge "bar", die Zahl 42 und ein weiteres Objekt.
const object = {
foo: "bar",
age: 42,
baz: { myProp: 12 },
};
Auf Eigenschaften zugreifen
Nachdem Sie ein Objekt erstellt haben, möchten Sie möglicherweise seine Eigenschaften lesen oder ändern. Auf Objekteigenschaften können Sie mit der Punktnotation oder der Klammernotation zugreifen. (Weitere Informationen finden Sie unter Eigenschaftszugriff.)
object.foo; // "bar"
object["age"]; // 42
object.baz; // {myProp: 12}
object.baz.myProp; // 12
Eigenschaften definieren
Sie haben bereits gesehen, wie Eigenschaften mit der Initialisierer-Syntax angegeben werden. Häufig gibt es in Ihrem Code Variablen, die Sie in ein Objekt aufnehmen möchten. Dann sieht der Code beispielsweise so aus:
const a = "foo";
const b = 42;
const c = {};
const o = {
a: a,
b: b,
c: c,
};
Dasselbe lässt sich kürzer schreiben:
const a = "foo";
const b = 42;
const c = {};
// Shorthand property names
const o = { a, b, c };
// In other words,
console.log(o.a === { a }.a); // true
Doppelte Eigenschaftsnamen
Wenn Sie denselben Namen für mehrere Eigenschaften verwenden, überschreibt die zweite Eigenschaft die erste.
const a = { x: 1, x: 2 };
console.log(a); // {x: 2}
Seit ES2015 sind doppelte Eigenschaftsnamen überall erlaubt, auch im Strict Mode. Auch in Klassen können Eigenschaftsnamen mehrfach vorkommen. Die einzige Ausnahme sind private Elemente, die innerhalb des Klassenrumpfs eindeutig sein müssen.
Methoden definieren
Eine Eigenschaft eines Objekts kann auch auf eine Funktion oder eine Getter- beziehungsweise Setter-Methode verweisen.
const o = {
property: function (parameters) {},
get property() {
return 1;
},
set property(value) {},
};
Es gibt eine Kurzschreibweise, bei der das Schlüsselwort function nicht mehr erforderlich ist.
// Shorthand method names
const o = {
property(parameters) {},
};
Auch Generator-Methoden lassen sich kurz definieren.
const o = {
*generator() {
// …
},
};
Das entspricht der folgenden ES5-ähnlichen Schreibweise (beachten Sie jedoch, dass ECMAScript 5 keine Generatoren kennt):
const o = {
generator: function* () {
// …
},
};
Weitere Informationen und Beispiele zu Methoden finden Sie unter Methodendefinitionen.
Berechnete Eigenschaftsnamen
Die Objektinitialisierer-Syntax unterstützt auch berechnete Eigenschaftsnamen. Damit können Sie einen Ausdruck in eckige Klammern [] setzen, der ausgewertet und als Eigenschaftsname verwendet wird. Das ähnelt der Klammernotation der Syntax für den Eigenschaftszugriff, die Sie möglicherweise bereits zum Lesen und Setzen von Eigenschaften verwendet haben.
Eine ähnliche Syntax können Sie nun auch in Objektliteralen verwenden:
// Computed property names
let i = 0;
const a = {
[`foo${++i}`]: i,
[`foo${++i}`]: i,
[`foo${++i}`]: i,
};
console.log(a.foo1); // 1
console.log(a.foo2); // 2
console.log(a.foo3); // 3
const items = ["A", "B", "C"];
const obj = {
[items]: "Hello",
};
console.log(obj); // A,B,C: "Hello"
console.log(obj["A,B,C"]); // "Hello"
const param = "size";
const config = {
[param]: 12,
[`mobile${param.charAt(0).toUpperCase()}${param.slice(1)}`]: 4,
};
console.log(config); // {size: 12, mobileSize: 4}
Spread-Eigenschaften
Objektliterale unterstützen die Spread-Syntax. Sie kopiert eigene aufzählbare Eigenschaften eines angegebenen Objekts in ein neues Objekt.
Damit lassen sich Objekte mit einer kürzeren Syntax als bei Object.assign() flach klonen (ohne prototype) oder zusammenführen.
const obj1 = { foo: "bar", x: 42 };
const obj2 = { foo: "baz", y: 13 };
const clonedObj = { ...obj1 };
// { foo: "bar", x: 42 }
const mergedObj = { ...obj1, ...obj2 };
// { foo: "baz", x: 42, y: 13 }
Warnung:
Beachten Sie, dass Object.assign() Setter auslöst, die Spread-Syntax hingegen nicht!
Prototyp-Setter
Eine Eigenschaftsdefinition der Form __proto__: value oder "__proto__": value erstellt keine Eigenschaft mit dem Namen __proto__. Wenn der angegebene Wert ein Objekt oder null ist, setzt sie stattdessen [[Prototype]] des erstellten Objekts auf diesen Wert. (Ist der Wert weder ein Objekt noch null, bleibt das Objekt unverändert.)
Beachten Sie, dass der Schlüssel __proto__ eine standardisierte Syntax ist – im Gegensatz zu den nicht standardisierten und wenig performanten Object.prototype.__proto__-Accessoren. Er legt [[Prototype]] während der Objekterstellung fest, ähnlich wie Object.create, anstatt die Prototypkette nachträglich zu verändern.
const obj1 = {};
console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true
const obj2 = { __proto__: null };
console.log(Object.getPrototypeOf(obj2)); // null
const protoObj = {};
const obj3 = { "__proto__": protoObj };
console.log(Object.getPrototypeOf(obj3) === protoObj); // true
const obj4 = { __proto__: "not an object or null" };
console.log(Object.getPrototypeOf(obj4) === Object.prototype); // true
console.log(Object.hasOwn(obj4, "__proto__")); // false
In einem Objektliteral ist nur ein einziger Prototyp-Setter zulässig. Mehrere Prototyp-Setter verursachen einen Syntaxfehler.
Eigenschaftsdefinitionen, die keine Doppelpunktnotation verwenden, sind keine Prototyp-Setter. Sie verhalten sich wie entsprechende Eigenschaftsdefinitionen mit einem beliebigen anderen Namen.
const __proto__ = "variable";
const obj1 = { __proto__ };
console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true
console.log(Object.hasOwn(obj1, "__proto__")); // true
console.log(obj1.__proto__); // "variable"
const obj2 = { __proto__() { return "hello"; } };
console.log(obj2.__proto__()); // "hello"
const obj3 = { ["__proto__"]: 17 };
console.log(obj3.__proto__); // 17
// Mixing prototype setter with normal own properties with "__proto__" key
const obj4 = { ["__proto__"]: 17, __proto__: {} }; // {__proto__: 17} (with {} as prototype)
const obj5 = {
["__proto__"]: 17,
__proto__: {},
__proto__: null, // SyntaxError: Duplicate __proto__ fields are not allowed in object literals
};
const obj6 = {
["__proto__"]: 17,
["__proto__"]: "hello",
__proto__: null,
}; // {__proto__: "hello"} (with null as prototype)
const obj7 = {
["__proto__"]: 17,
__proto__,
__proto__: null,
}; // {__proto__: "variable"} (with null as prototype)
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-object-initializer> |