Símbolo

Los símbolos son un concepto relativamente nuevo básica presentada en ES6. Un primitivo de símbolo representa un valor único que nunca colisione con ningún otro valor, incluidos los de otras primitivas de símbolos. Dos primitivas de cadenas compuestas por caracteres idénticos se evalúan como estrictas igual:

String() === String()
> true

String( "My string." ) === String( "My string." );
> true

Sin embargo, no se pueden usar dos símbolos creados con la función Symbol() estrictamente igual:

Symbol() === Symbol()
> false

Esta característica te permite usar símbolos como claves de propiedad únicas en un objeto, lo que evita y colisiones con claves que cualquier otro código podría agregar a ese objeto.

const mySymbol = Symbol( "Desc" );

const myObject = {

}

myObject
> Object { Symbol("Desc"): "propSymbol" }

Hay tres tipos de símbolos:

• Símbolos creados con Symbol()
• Símbolos compartidos que se configuran y recuperan de un registro de símbolos global con Symbol.for()
• "Símbolos conocidos" definidas como propiedades estáticas en el objeto Symbol. Estos símbolos contienen métodos internos que no se pueden reemplazar por accidente.

Symbol() acepta una descripción (o "nombre del símbolo") como argumento opcional. Estas descripciones son etiquetas legibles para fines de depuración y son no afectan la unicidad del resultado. Cualquier llamada a Symbol muestra un primitivo de símbolo completamente único, aunque múltiples llamadas tengan la misma descripciones:

Symbol( "My symbol." ) === Symbol( "My symbol." );
> false

Al igual que con otros tipos de datos primitivos, los símbolos heredan métodos y propiedades de su prototipo. Por ejemplo, puedes acceder a una descripción como una propiedad heredada del símbolo creado:

let mySymbol = Symbol( "My symbol." );

mySymbol.description
> "My symbol."

Sin embargo, no puedes crear un símbolo con la palabra clave new:

let mySymbol = new Symbol();

> Uncaught TypeError: Symbol is not a constructor

No se pueden enumerar los símbolos, lo que significa que las propiedades simbólicas no están disponibles. cuando se usan métodos estándar para iterar sobre ellos. El getOwnPropertySymbols() proporciona acceso a las propiedades de símbolos de un objeto.

Símbolos compartidos

El método Symbol.for() intenta buscar cualquier símbolo existente en un global de símbolos de todo el entorno de ejecución con una cadena dada como clave y muestra el símbolo correspondiente si se encuentra uno. Si no lo encuentra, se crea un símbolo. con la clave especificada y la agrega al registro global:

let sharedSymbol = Symbol.for( "My key." );

sharedSymbol === Symbol.for( "My key." )
> true

Estas claves no comparten ninguna superposición funcional con las descripciones asignadas a primitivas de Symbol creadas por el autor. Para acceder a un símbolo en el registro de símbolos, primero debes crearla con for():

Symbol( "String" ) === Symbol( "String" );
> false

Symbol( "String" ) === Symbol().for( "String" );
> false

Symbol().for( "String" ) === Symbol().for( "String" );
> true

Para recuperar la clave de cualquier símbolo del registro de símbolos, usa Symbol.keyFor():

let mySymbol = Symbol.for( "Key." );

Symbol.keyFor( mySymbol ) ;
> "Key."

"Conocido" símbolos

Los símbolos conocidos son propiedades estáticas del objeto Symbol, y cada una de ellas es un símbolo en sí mismo. Los símbolos conocidos proporcionan claves de propiedad únicas para acceder a los métodos integrados de JavaScript y modificarlos, mientras evitas y el comportamiento no deseado para evitar que se reemplace.

Symbol;
> function Symbol()
    asyncIterator: Symbol(Symbol.asyncIterator)
    for: function for()
    hasInstance: Symbol("Symbol.hasInstance")
    isConcatSpreadable: Symbol("Symbol.isConcatSpreadable")
    iterator: Symbol(Symbol.iterator)
    keyFor: function keyFor()
    length: 0
    match: Symbol("Symbol.match")
    matchAll: Symbol("Symbol.matchAll")
    name: "Symbol"
    prototype: Object { … }
    replace: Symbol("Symbol.replace")
    search: Symbol("Symbol.search")
    species: Symbol("Symbol.species")
    split: Symbol("Symbol.split")
    toPrimitive: Symbol("Symbol.toPrimitive")
    toStringTag: Symbol("Symbol.toStringTag")
    unscopables: Symbol("Symbol.unscopables")
    <prototype>: function ()

Como los símbolos son una función específica de ES6, estos valores simbólicos son destinados a usarse como "puntos de extensión" para desarrolladores que modifiquen sin introducir problemas de retrocompatibilidad.

Los valores de símbolos conocidos a menudo se estilizan con una @@ o unido a % para diferenciar sus claves de sus prototipos mutables. Por ejemplo, @@match. (o %match%) es una referencia al Symbol.match inmutable, no String.prototype.match

Verifica tus conocimientos