Property accessors — Operator · JavaScript-Referenz

Signatur

object.property | object["property"]

Beschreibung

Property accessors sind die grundlegende Syntax in JavaScript, um auf Eigenschaften (und Methoden) eines Objekts zuzugreifen, sie zu lesen oder zu schreiben. Es gibt zwei gleichwertige Schreibweisen:

Punktnotation (object.propertyName): Die kompaktere und in der Praxis häufiger verwendete Form. Der Eigenschaftsname muss ein gültiger JavaScript-Bezeichner sein (keine Leerzeichen, darf nicht mit einer Ziffer beginnen usw.).
Klammernotation (object["propertyName"]): Erlaubt beliebige Zeichenketten als Eigenschaftsname – auch solche mit Sonderzeichen, Leerzeichen oder Zahlen als erstem Zeichen. Außerdem können hier Variablen oder Ausdrücke als Schlüssel verwendet werden (dynamischer Zugriff).

Beide Notationen können nicht nur zum Lesen, sondern auch zum Schreiben von Eigenschaften eingesetzt werden: obj.name = "Alice" bzw. obj["name"] = "Alice". Wird auf eine nicht vorhandene Eigenschaft zugegriffen, liefert JavaScript undefined zurück, anstatt einen Fehler zu werfen – es sei denn, das Objekt selbst ist null oder undefined, dann entsteht ein TypeError.

Property accessors lassen sich verketten: user.address.city oder gemischt data["users"][0].name. Für sicheren Zugriff auf tief verschachtelte Strukturen empfiehlt sich der Optional Chaining Operator (?.), der einen TypeError vermeidet, wenn eine Zwischeneigenschaft null oder undefined ist.

Parameter

Name	Typ	Default	Beschreibung
$object Pflicht	object \| Array \| Function \| any	—	Das Objekt, auf dessen Eigenschaft zugegriffen werden soll. Kann jeder Nicht-`null`/`undefined`-Wert sein – primitive Werte werden dabei temporär in ihr Wrapper-Objekt konvertiert (z. B. `String`, `Number`).
$property Pflicht	string \| symbol	—	Bei der Punktnotation: ein gültiger JavaScript-Bezeichner, der direkt angegeben wird. Bei der Klammernotation: ein beliebiger Ausdruck (Variable, Zeichenkette, Template-Literal, Symbol usw.), der zu einem String oder Symbol ausgewertet wird.

Rückgabewert

Typ

any

Beschreibung

Der Wert der Eigenschaft – oder undefined, falls die Eigenschaft am Objekt (und in seiner Prototyp-Kette) nicht existiert. Beim Schreiben (Zuweisung) ist der Rückgabewert der zugewiesene Wert selbst.

Beispiele

Punkt- vs. Klammernotation (Lesen & Schreiben)

const user = { name: "Alice", age: 30 };

// Lesen per Punktnotation
console.log(user.name);      // "Alice"

// Lesen per Klammernotation
console.log(user["age"]);    // 30

// Schreiben per Punktnotation
user.email = "alice@example.com";

// Schreiben per Klammernotation
user["isAdmin"] = false;

console.log(user);
// { name: "Alice", age: 30, email: "alice@example.com", isAdmin: false }

Alice 30 { name: 'Alice', age: 30, email: 'alice@example.com', isAdmin: false }

Dynamischer Zugriff mit Variablen

const config = {
  theme: "dark",
  language: "de",
  fontSize: 16
};

// Schlüssel zur Laufzeit bestimmen
const key = "language";
console.log(config[key]);   // "de"

// Über ein Array von Schlüsseln iterieren
const keys = ["theme", "fontSize"];
keys.forEach(k => console.log(`${k}: ${config[k]}`));
// theme: dark
// fontSize: 16

de theme: dark fontSize: 16

Sonderzeichen im Eigenschaftsnamen & Verkettung

const data = {
  "first-name": "Bob",          // Bindestrich → nur Klammernotation möglich
  "123start": "Zahl vorn",      // Ziffer am Anfang → nur Klammernotation
  address: { city: "Berlin" }
};

console.log(data["first-name"]);   // "Bob"
console.log(data["123start"]);     // "Zahl vorn"

// Verkettung
console.log(data.address.city);    // "Berlin"

// Sicherer Zugriff mit Optional Chaining
console.log(data.address?.zip);    // undefined (kein TypeError)

Bob Zahl vorn Berlin undefined

Zugriff auf Methoden & Prototyp-Eigenschaften

const text = "Hallo, Welt!";

// String-Methoden über Punktnotation aufrufen
console.log(text.toUpperCase());       // "HALLO, WELT!"
console.log(text["includes"]("Welt")); // true

// Array-Methoden
const nums = [3, 1, 4, 1, 5];
console.log(nums.length);              // 5
console.log(nums["join"]("-"));        // "3-1-4-1-5"

HALLO, WELT! true 5 3-1-4-1-5

// Wichtig · Fallstricke

Fallstricke & Hinweise:

TypeError bei null/undefined: Wird auf eine Eigenschaft eines null- oder undefined-Wertes zugegriffen (z. B. null.name), wirft JavaScript einen TypeError. Der Optional Chaining Operator (?.) umgeht dieses Problem.
Primitivwerte werden automatisch geboxed: JavaScript konvertiert Primitive wie string, number oder boolean beim Eigenschaftszugriff temporär in ihr Wrapper-Objekt. Geschriebene Eigenschaften gehen dabei verloren: ("hallo").foo = 1; ("hallo").foo // → undefined.
Prototyp-Kette: Wird eine Eigenschaft nicht direkt am Objekt gefunden, sucht JavaScript automatisch in der Prototyp-Kette weiter. Das kann zu unerwartetem Verhalten führen, wenn geerbte Eigenschaften überschrieben werden.
Symbol-Schlüssel: Nur die Klammernotation unterstützt Symbole als Eigenschaftsschlüssel: obj[Symbol.iterator]. Mit der Punktnotation ist das nicht möglich.
Computed Property Names in Objekt-Literalen ({ [expr]: value }) nutzen dieselbe Auswertungslogik wie die Klammernotation und sind seit ES2015 verfügbar.

Siehe auch

Optional Chaining (?.) Nullish Coalescing (??) Object.defineProperty() in-Operator delete-Operator Destructuring Assignment get (Getter) set (Setter)