Ce sunt Simbolurile și unde sunt folosite?

Question

Accepted Answer

Un **Symbol** este o primitivă unică și imutabilă. Fiecare `Symbol()` pe care o creezi este **garantat distinct** — chiar și două cu aceeași descriere nu sunt egale. Scopul lor principal este să fie **chei de obiect rezistente la coliziuni**.

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

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

## De ce cheile unice sunt utile

Proprietățile cu cheie Symbol nu se ciocnesc cu cheile string și sunt **ascunse** de la enumerarea normală — perfecte pentru a atașa metadate fără a polua obiectul:

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

Deci o bibliotecă poate stoca date interne pe obiectul tău printr-un Symbol fără riscul unei ciocniri cu proprietățile tale sau să apară în buclele tale.

## Simbolurile cunoscute personalizează comportamentul limbajului

Utilizarea cea mai importantă — `Symbol.iterator` face un obiect iterabil:

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

Altele: `Symbol.asyncIterator`, `Symbol.toPrimitive` (coerție personalizată), `Symbol.hasInstance`.

## Registrul global

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

## De ce este important

Simbolurile permit chei de metadate fără coliziuni și te lasă să te conectezi la protocoalele limbajului de bază (iterație, coerție) — asta e cum built-ins și framework-urile extind obiecte în siguranță.