Was sind Symbols und wo werden sie verwendet?

Question

Accepted Answer

Ein **Symbol** ist ein eindeutiger, unveränderlicher Primitiv. Jedes `Symbol()`, das Sie erstellen, ist **garantiert unterschiedlich** — selbst zwei mit der gleichen Beschreibung sind nicht gleich. Ihr Hauptzweck ist es, **kollisionsfreie Objektschlüssel** zu sein.

```js
const id = Symbol("id");
const id2 = Symbol("id");
id === id2;        // false — always unique

const user = { [id]: 123, name: "Ann" };
user[id];          // 123
```

## Warum eindeutige Schlüssel nützlich sind

Symbol-Schlüssel-Eigenschaften kollidieren nicht mit String-Schlüsseln und sind **versteckt** vor normaler Enumeration — perfekt zum Anhängen von Metadaten, ohne das Objekt zu verschmutzen:

```js
Object.keys(user);          // ["name"]  — symbol key is skipped
for (const k in user) {}    // skips the symbol
JSON.stringify(user);       // {"name":"Ann"} — symbol not serialized
Object.getOwnPropertySymbols(user); // [Symbol(id)] — only way to list them
```

Also kann eine Bibliothek interne Daten über ein Symbol auf Ihrem Objekt speichern, ohne das Risiko einer Kollision mit Ihren Eigenschaften oder einem Erscheinen in Ihren Schleifen.

## Bekannte Symbols passen das Sprachverhalten an

Die wichtigste Verwendung — `Symbol.iterator` macht ein Objekt iterierbar:

```js
const range = {
  [Symbol.iterator]() {
    let i = 1;
    return { next: () => (i <= 3 ? { value: i++, done: false } : { done: true }) };
  },
};
[...range]; // [1, 2, 3]
```

Andere: `Symbol.asyncIterator`, `Symbol.toPrimitive` (benutzerdefinierte Erzwingung), `Symbol.hasInstance`.

## Globale Registrierung

```js
Symbol.for("key"); // shared symbol across the whole app (and across realms)
```

## Warum es wichtig ist

Symbols ermöglichen kollisionsfreie Metadatenschlüssel und lassen Sie sich in Kernsprachprotokolle einklinken (Iteration, Erzwingung) — so erweitern Built-ins und Frameworks sicher Objekte.