Czym są Symbole i gdzie się ich używa?

Question

Accepted Answer

**Symbol** jest unikalną, niezmienną prymitywą. Każdy `Symbol()`, który tworzysz, jest **gwarantowany jako odrębny** — nawet dwa o tym samym opisie nie są równe. Ich głównym zadaniem jest bycie **kluczami odpornymy na kolizje**.

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

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

## Dlaczego to ważne

Właściwości ze Symbolami jako kluczami nie kolidują z kluczami string i są **ukryte** przed normalną enumeracją — idealne do dołączania metadanych bez zaśmiecania obiektu:

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

Biblioteka może zatem przechowywać wewnętrzne dane na Twoim obiekcie za pośrednictwem Symbolu bez ryzyka konfliktu z Twoimi właściwościami lub pojawiania się w Twoich pętlach.

## Dobrze znane symbole dostosowują zachowanie języka

Najważniejsze użycie — `Symbol.iterator` sprawia, że obiekt jest iterowalny:

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

Innymi: `Symbol.asyncIterator`, `Symbol.toPrimitive` (niestandardowa konwersja), `Symbol.hasInstance`.

## Globalny rejestr

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

## Dlaczego to ważne

Symbole umożliwiają nienullujące się klucze metadanych i pozwalają Ci podłączyć się do głównych protokołów języka (iteracja, konwersja) — to sposób, w jaki funkcje wbudowane i frameworki bezpiecznie rozszerzają obiekty.