JavaScript
Explica cómo Symbol crea valores únicos, sirve como clave de propiedad y participa en protocolos del lenguaje mediante símbolos bien conocidos.
Un es un valor primitivo único que suele utilizarse como clave de propiedad sin riesgo de colisión accidental.
symbolconst id = Symbol("id");
const user = {
[id]: "user-1",
};Symbol("id") === Symbol("id");
// falseLa descripción ayuda a depurar, pero no define identidad.
typeof Symbol("id"); // "symbol"No se crea con new.
new Symbol();
// TypeErrorLas property keys válidas son strings y symbols.
const internal = Symbol("internal");
const object = {
visible: true,
[internal]: {
cached: true,
},
};Object.getOwnPropertySymbols(object);
Reflect.ownKeys(object);Los symbols pueden descubrirse mediante reflexión. Evitan colisiones y enumeración ordinaria, pero no sustituyen campos privados # o closures.
Object.keys(object);
Object.entries(object);
JSON.stringify(object);Estas operaciones normalmente omiten propiedades symbol.
Reflect.ownKeys(object);Incluye strings y symbols propios.
Spread y Object.assign copian propiedades symbol propias enumerables.
const copy = { ...object };
copy[internal] === object[internal];La copia sigue siendo superficial.
const first = Symbol.for("app.user");
const second = Symbol.for("app.user");
first === second; // trueSymbol.for consulta un registro global dentro del agente.
Symbol.keyFor(first); // "app.user"No confundir con Symbol("app.user"), que siempre crea otro valor.
Una clave global puede colisionar si dos librerías eligen el mismo nombre. Usa nombres suficientemente específicos y solo cuando necesitas identidad compartida por nombre.
JavaScript define symbols conocidos para protocolos internos.
Symbol.iterator;
Symbol.asyncIterator;
Symbol.toPrimitive;
Symbol.toStringTag;
Symbol.hasInstance;
Symbol.match;Permiten personalizar cómo un objeto participa en operaciones del lenguaje.
const range = {
start: 1,
end: 3,
*[Symbol.iterator]() {
for (
let value = this.start;
value <= this.end;
value++
) {
yield value;
}
},
};
[...range]; // [1, 2, 3]El objeto se vuelve iterable.
const money = {
amount: 100,
[Symbol.toPrimitive](hint) {
if (hint === "string") {
return `$${this.amount}`;
}
return this.amount;
},
};El método debe devolver un primitivo. Personalizar coerción puede ser útil, pero también volver el código sorpresivo.
const collection = {
get [Symbol.toStringTag]() {
return "ProductCollection";
},
};
Object.prototype.toString.call(collection);
// "[object ProductCollection]"Es una etiqueta de representación, no una validación segura de tipo.
class EvenNumber {
static [Symbol.hasInstance](value) {
return Number.isInteger(value) && value % 2 === 0;
}
}
2 instanceof EvenNumber; // trueModificar instanceof puede sorprender a quien espera una relación prototípica. Úsalo con mucha cautela.
String(Symbol("id"));
// "Symbol(id)"La concatenación implícita puede lanzar.
"id: " + Symbol("id");
// TypeErrorConvierte explícitamente.
El estándar moderno admite symbols no registrados como claves débiles. Los registrados mediante Symbol.for no son recolectables de la misma forma por su registro global.
Para compatibilidad amplia y claridad, las colecciones débiles siguen utilizándose principalmente con objetos.
export const validationMetadata = Symbol(
"validationMetadata",
);
export function attachValidationMetadata(
schema,
metadata,
) {
Object.defineProperty(
schema,
validationMetadata,
{
value: metadata,
enumerable: false,
},
);
}La clave evita chocar con propiedades públicas ordinarias.
¿Por qué dos Symbol("id") no son iguales?
Porque cada llamada crea una identidad única. La descripción solo sirve como etiqueta de depuración.
JSON y serialización explica cómo representar datos para intercambio sin confundirlos con objetos JavaScript completos.