Simbolo

I simboli sono relativamente nuovi introdotto in ES6. Una primitiva di simboli rappresenta un valore unico che non si scontra mai con altri valori, inclusi quelli di altre primitive di simboli. Due primitive di stringa composte da caratteri identici vengono valutate come uguale a:

String() === String()
> true

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

Tuttavia, non è possibile creare due simboli utilizzando la funzione Symbol() rigorosamente uguale:

Symbol() === Symbol()
> false

Questo tratto consente di utilizzare i simboli come chiavi di proprietà uniche in un oggetto, impedendo le collisioni con chiavi che qualsiasi altro codice potrebbe aggiungere all'oggetto.

const mySymbol = Symbol( "Desc" );

const myObject = {

}

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

Esistono tre tipi di simboli:

• Simboli creati con Symbol()
• Simboli condivisi impostati e recuperati da un registro di simboli globale utilizzando Symbol.for()
• "Simboli noti" definite come proprietà statiche sull'oggetto Symbol. Questi simboli contengono metodi interni che non possono essere sovrascritti accidentalmente.

Symbol() accetta una descrizione (o "nome del simbolo") come argomento facoltativo. Queste descrizioni sono etichette leggibili da una persona ai fini del debug e non influiscono sull'univocità del risultato. Qualsiasi chiamata a Symbol restituisce un primitive di simboli completamente univoci, anche se più chiamate hanno query descrizioni:

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

Come con altri tipi di dati primitivi, i simboli ereditano metodi e proprietà il loro prototipo. Ad esempio, puoi accedere a una descrizione come proprietà ereditata del simbolo creato:

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

mySymbol.description
> "My symbol."

Tuttavia, non puoi creare un simbolo utilizzando la parola chiave new:

let mySymbol = new Symbol();

> Uncaught TypeError: Symbol is not a constructor

I simboli non sono enumerabili, il che significa che le proprietà simboliche non sono disponibili quando utilizzi metodi standard per ripetere l'iterazione. getOwnPropertySymbols() dà accesso alle proprietà dei simboli di un oggetto.

Simboli condivisi

Il metodo Symbol.for() cerca di cercare i simboli esistenti in una registro di simboli globale a livello di runtime con una determinata stringa come chiave e restituisce il simbolo corrispondente, se ne viene trovato uno. Se non ne trova uno, crea un simbolo con la chiave specificata e la aggiunge al registro globale:

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

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

Queste chiavi non condividono alcuna sovrapposizione funzionale con le descrizioni assegnate primitive Symbol create dall'autore. Per accedere a un simbolo nel registro dei simboli, devi prima crearlo utilizzando for():

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

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

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

Per recuperare la chiave per qualsiasi simbolo dal registro dei simboli, utilizza Symbol.keyFor():

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

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

"Ben noto" Simboli

I simboli noti sono proprietà statiche dell'oggetto Symbol, ognuno dei quali è un simbolo stesso. I simboli noti forniscono chiavi di proprietà univoche per accedere e modificare i metodi integrati di JavaScript, impedendo al contempo le non vengano sovrascritti involontariamente.

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 ()

Poiché i simboli sono una caratteristica specifica di ES6, questi valori simbolici sono utilizzabili come "punti di estensione" agli sviluppatori che modificano il codice JavaScript senza introdurre problemi di compatibilità con le versioni precedenti.

I valori dei simboli più noti sono spesso stilizzati con @@ prefisso o aggregato in % per a differenziare le chiavi dai prototipi mutabili. Ad esempio, @@match (o %match%) è un riferimento all'immutabile Symbol.match, non String.prototype.match.

Verifica le tue conoscenze