Objekt Initialisierer

Zusammenfassung

Objekte können mittels new Object(), Object.create(), oder über die literale Notation (Initialisierungs Notaion) initialisiert werden. Ein Objekt Initialisierer ist eine Liste bestehend aus Null oder mehr Paaren von Eigenschafts-Namen und den zugehörigen Werten eines Objektes, eingeschlossen in geschwungene Klammern ({}).

Syntax

var o = {};
var o = { a: "foo", b: 42, c: {} };

var a = "foo", b = 42, c = {};
var o = { a: a, b: b, c: c };

var o = {
  property: function ([parameters]) {},
  get property() {},
  set property(value) {},
};

Neue Schreibweisen in ECMAScript 6

Um herauszufinden ob diese Schreibweisen (im folgenden Notation genannt) unterstützt werden, werfen Sie einen Blick auf die Kompatibilitäts Tabelle. In nicht-unterstützenden Umgebungen werden diese Schreibweisen zu Syntax Fehlern führen.

// Kurzschreibweisen für Eigenschaftsnamen (ES6)
var a = "foo", b = 42, c = {};
var o = { a, b, c };

// Kurzschreibweise Methoden Namen (ES6)
var o = {
  property([parameters]) {},
  get property() {},
  set property(value) {},
  * generator() {}
};

// Berechnete Eigenschaftsnamen (ES6)
var prop = "foo";
var o = {
  [prop]: "hey",
  ["b" + "ar"]: "there",
};

Beschreibung

Ein Objekt Initialisierer ist ein Ausdruck welcher die Initialisierung eines Object beschreibt. Objekte bestehen aus Eigenschaften (properties), welche verwendet werden, um ein Objekt zu beschreiben. Die Werte der Objekt Eigenschaften können primitive Datentypen oder andere Objekte enthalten.

Objekte erzeugen

Ein leeres Objekt ohne Eigenschaften kann wie folgt erzeugt werden:

var object = {};

Jedoch: die Vorteile der literalen oder Initialisierer Notation versetzen Sie in die Lage, Objekte inklusive Eigenschaften, innerhalb geschwungener Klammern, schneller zu erzeugen. Sie schreiben einfach eine Liste von Schlüssel:Werte Paaren, getrennt durch ein Komma. Der folgende Quellcode erzeugt ein Objekt mit drei Eingenschaften mit den Schlüsseln "foo", "age" und "baz". Die Werte dieser Schlüssel sind: die Zeichenkette "bar", die Zahl 42 und die dritte Eigenschaft hat ein anderes Objekt als Wert.

var object = {
  foo: "bar",
  age: 42,
  baz: { myProp: 12 },
}

Auf Eigenschaften zugreifen

Sobal ein Objekt erzeugt worden ist, möchte man auf seine Eigenschaften lesend oder schreibend zugreifen. Auf die Eigenschaften eines Objektes kann mit der Punktnotation oder der Klammer-Notation zugegriffen werden. Siehe property accessors für weiter Informationen.

object.foo; // "bar"
object["age"]; // 42

object.foo = "baz";

Eigenschaften definieren

Wir haben bereits gelernt, wie man Eigenschaften mit Hilfe der Initialisierungs Syntax schreibt. Oft gibt es Variablen im Code, die Sie in einem Objekt verwenden möchten. Man sieht oft Quellcode wie den folgenden:

var a = "foo", 
    b = 42,
    c = {};

var o = { 
  a: a,
  b: b,
  c: c
};

Mit ECMAScript 6 ist eine kürzere Schreibweise verfügbar, um das gleiche zu erreichen:

var a = "foo", 
    b = 42, 
    c = {};

// Shorthand property names (ES6)
var o = { a, b, c };

Doppelte Eigenschaftsnamen

Bei Verwendung des gleichen Namens für Ihre Eigenschaften, wird die zweite Eigenschaft die erste überschreiben.

var a = {x: 1, x: 2};
console.log(a); // { x: 2}

Im strikten Modus von ECMAScript 5 wurden doppelte Eigenschaftsnamen als SyntaxError gewertet. Mit der Einführung von berechneten Eigenschaftsnamen in ECMAScript 6 wurde diese Einschränkung entfernt, was Duplikate zur Laufzeit möglich macht.

function haveES6DuplicatePropertySemantics(){
  "use strict";
  try {
    ({ prop: 1, prop: 2 });

    // No error thrown, duplicate property names allowed in strict mode
    return true;
  } catch (e) {
    // Error thrown, duplicates prohibited in strict mode
    return false;
  }
}

Methoden Definitionen

Eine Eigenschaft eines Objekts kann auch auf eine Funktion oder einen Getter oder Setter-Methode verweisen.

var o = {
  property: function ([parameters]) {},
  get property() {},
  set property(value) {},
};

In ECMAScript 6, a shorthand notation is available, so that the keyword "function" is no longer necessary.

// Kurzschreibweise für Methoden Namen (ES6)
var o = {
  property([parameters]) {},
  get property() {},
  set property(value) {},
  * generator() {}
};

Für weiter Information und Beispiel zu Methoden, siehe method definitions.

Berechnete Bezeichnernamen

Beginnend mit ECMAScript 6, unterstützt die Objekt Initialisierer Syntax auch berechnete Bezeichnernamen für Objekt Eigenschaften. Das gestatt dem Programmierer einen Ausdruck in eckigen Klammern anzugeben, aus welchem der Bezeichnernamen für die Objekt Eigenschaft berechnet wird. Die Schreibweise dafür ist analog zu der Klammer-Notation für den Zugriff auf Objekt Eigenschaften welche Sie bereits benutzt haben. Dieselbe Syntax kann nun für Eigenschaften Bezeichner verwendet werden:

// Computed property names (ES6)
var i = 0;
var 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

var param = 'size';
var config = {
  [param]: 12,
  ["mobile" + param.charAt(0).toUpperCase() + param.slice(1)]: 4
};

console.log(config); // { size: 12, mobileSize: 4 }

Prototyp Mutationen

Eine Eigenschaft Definition der Form __proto__: Wert oder "__proto__": Wert erzeugt keine Eigenschaft mit dem Namen __proto__. Wenn der angegebene Wert ein Objekt oder null ist, wird stattdessen der [[Prototyp]] des erzeugten Objektes auf den angegebenen Wert geändert. (Das Objekt wird nicht verändert, falls der Wert kein Objekt oder null ist.)

var obj1 = {};
assert(Object.getPrototypeOf(obj1) === Object.prototype);

var obj2 = { __proto__: null };
assert(Object.getPrototypeOf(obj2) === null);

var protoObj = {};
var obj3 = { "__proto__": protoObj };
assert(Object.getPrototypeOf(obj3) === protoObj);

var obj4 = { __proto__: "not an object or null" };
assert(Object.getPrototypeOf(obj4) === Object.prototype);
assert(!obj4.hasOwnProperty("__proto__"));

Pro Objekt-Literal ist nur eine einzlene Prototyp mutation erlaubt: mehrfache Prototyp Mutationen führen zu einem Syntax Fehler.

Eigenschaftsdefinitionen welche nicht von der Doppelpunkt Notation Gebrauch machen, sind keine Prototyp Mutationen: es sind Eigenschaftsdefinitionen die sich verhalten wie jede andere Defintion von Eigenschaftsbezeichnern auch.

var __proto__ = "variable";

var obj1 = { __proto__ };
assert(Object.getPrototypeOf(obj1) === Object.prototype);
assert(obj1.hasOwnProperty("__proto__"));
assert(obj1.__proto__ === "variable");

var obj2 = { __proto__() { return "hello"; } };
assert(obj2.__proto__() === "hello");

var obj3 = { ["__prot" + "o__"]: 17 };
assert(obj3.__proto__ === 17);

Objekt literale Notation vs JSON

Die Objekt-Literal Notation ist nicht dasselbe wie die JavaScript Object Notation (JSON). Obwohl sie ähnlich aussehen, gibt es Unterschiede zwischen ihnen:

• JSON erlaubt nur Eigenschaftsdefinitionen mit "Eigenschaft": Wert Syntax. Der Eigenschaftsname muss in doppelten Anführungszeichen geschrieben werden, und die Definition kann nicht in Kurzschreibweise erfolgen.
• In JSON können die Werte nur Strings, Zahlen, Arrays, true, false, null oder  andere (JSON) Objekte sein.
• Ein Funktionswert (siehe "Methoden" oben) kann in JSON keinem Wert zugeordnet werden.
• Objekte wie {{jsxref ("Date")}} werden nach dem Aufruf von {{jsxref ("JSON.parse ()")}}, in einen String umgewandelt, .
• JSON.parse() weist berechnete Eigenschaftsnamen zurück und wirft eine Fehlermeldung.

Spezifizierung

Browser kompatibilität

Siehe auch

• Property accessors
• get / set
• Method definitions
• Lexical grammar