¿Qué son los Symbols y dónde se usan?

Question

Accepted Answer

Un **Symbol** es un primitivo único e inmutable. Cada `Symbol()` que creas está **garantizado como distinto** — incluso dos con la misma descripción no son iguales. Su principal función es ser **claves de objeto a prueba de colisiones**.

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

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

## Por qué son útiles las claves únicas

Las propiedades con clave de Symbol no colisionan con las claves de tipo string y están **ocultas** de la enumeración normal — perfectas para adjuntar metadatos sin contaminar el objeto:

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

Así, una librería puede almacenar datos internos en tu objeto mediante un Symbol sin arriesgar una colisión con tus propiedades ni aparecer en tus bucles.

## Los well-known symbols personalizan el comportamiento del lenguaje

El uso más importante — `Symbol.iterator` hace que un objeto sea iterable:

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

Otros: `Symbol.asyncIterator`, `Symbol.toPrimitive` (coerción personalizada), `Symbol.hasInstance`.

## Registro global

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

## Por qué es importante

Los Symbols permiten claves de metadatos que no colisionan y te dejan engancharte a protocolos centrales del lenguaje (iteración, coerción) — son la forma en que los built-ins y los frameworks extienden objetos de manera segura.