Hvad er Symbols, og hvor bruges de?

Question

Accepted Answer

Et **Symbol** er en unik, uforanderlig primitiv. Hvert `Symbol()`, du opretter, er **garanteret distinkt** — selv to med samme beskrivelse er ikke ens. Deres hovedformål er at være **kollisionssikre objektnøgler**.

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

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

## Hvorfor unikke nøgler er nyttige

Symbol-nøglede egenskaber kolliderer ikke med strengnøgler og er **skjult** fra normal enumeration — perfekt til at vedhæfte metadata uden at forurene objektet:

```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
```

Så et bibliotek kan gemme interne data på dit objekt via et Symbol uden risiko for at kollidere med dine egenskaber eller vises i dine sløjfer.

## Velkendte symboler tilpasser sprogadfærd

Den vigtigste brug — `Symbol.iterator` gør et objekt iterabelt:

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

Andre: `Symbol.asyncIterator`, `Symbol.toPrimitive` (brugerdefineret tvangskonvertering), `Symbol.hasInstance`.

## Globalt register

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

## Hvorfor det betyder noget

Symboler muliggør ikke-kollisionerende metadatanøgler og lader dig knytte dig til kernesprogprotokoller (iteration, tvangskonvertering) — det er sådan, built-ins og frameworks sikkert udvider objekter.