Aperçu

ES6 introduit un nouveau type de données primitif, Symbol, qui représente des valeurs uniques. Son cas d'utilisation le plus important est de définir des noms de propriétés uniques pour les objets.

En plus de Number, String, Boolean, Object, null et undefined, les types de données ES6 incluent également Symbol.

Utilisation de base

La fonction Symbol ne peut pas être utilisée avec la commande new, car Symbol est un type de données primitif, et non un objet. Elle peut accepter une chaîne comme paramètre pour fournir une description du Symbol nouvellement créé, qui est utilisée pour l'affichage dans la console ou lorsqu'elle est utilisée comme chaîne, afin de faciliter la distinction.

let sy = Symbol("KK"); console.log(sy); // Symbol(KK) typeof(sy); // "symbol" //Les valeurs renvoyées par Symbol() avec le même paramètre ne sont pas égales. let sy1 = Symbol("kk"); sy === sy1; // false

Scénarios d'utilisation

En tant que noms de propriétés

Utilisation

Comme chaque valeur Symbol est unique, utiliser Symbol comme nom de propriété d'un objet permet de garantir que les noms de propriétés n'entrent pas en conflit.

let sy = Symbol("key1"); //Syntaxe 1 let syObject = {}; syObject[sy] = "kk"; console.log(syObject); // {Symbol(key1): "kk"} //Syntaxe 2 let syObject = { [sy]: "kk" }; console.log(syObject); // {Symbol(key1): "kk"} //Syntaxe 3 let syObject = {}; Object.defineProperty(syObject, sy, {value: "kk"}); console.log(syObject); // {Symbol(key1): "kk"}

Lorsque Symbol est utilisé comme nom de propriété d’objet, l’opérateur point ne peut pas être utilisé ; il faut utiliser des crochets. Comme ce qui suit l’opérateur point est une chaîne, ce qui est accessible est la propriété sy de chaîne, et non la propriété sy de valeur Symbol.

let syObject = {}; syObject[sy] = "kk"; syObject[sy]; // "kk" syObject.sy; // undefined

Points à noter

Lorsqu'une valeur Symbol est utilisée comme nom de propriété, cette propriété est publique, non privée, et est accessible en dehors de la classe. Cependant, elle n'apparaîtra pas dans les boucles for...in ou for...of, et ne sera pas renvoyée par Object.keys() ou Object.getOwnPropertyNames(). Pour lire les propriétés Symbol d'un objet, vous pouvez les obtenir via Object.getOwnPropertySymbols() et Reflect.ownKeys().

let syObject = {}; syObject[sy] = "kk"; console.log(syObject); for (let i in syObject) { console.log(i); } //Aucune sortie Object.keys(syObject); // [] Object.getOwnPropertySymbols(syObject); // [Symbol(key1)] Reflect.ownKeys(syObject); // [Symbol(key1)]

Définition de constantes

Dans ES5, les chaînes de caractères sont utilisées pour représenter des constantes. Par exemple :

const COLOR_RED = "red";
const COLOR_YELLOW = "yellow";
const COLOR_BLUE = "blue";

Mais l'utilisation de chaînes de caractères ne permet pas de garantir que les constantes soient uniques, ce qui peut causer certains problèmes :

const COLOR_RED = "red"; const COLOR_YELLOW = "yellow"; const COLOR_BLUE = "blue"; const MY_BLUE = "blue"; function ColorException(message) { this.message = message; this.name = "ColorException"; } function getConstantName(color) { switch (color) { case COLOR_RED : return "COLOR_RED"; case COLOR_YELLOW : return "COLOR_YELLOW "; case COLOR_BLUE: return "COLOR_BLUE"; case MY_BLUE: return "MY_BLUE"; default: throw new ColorException("Impossible de trouver cette couleur"); } } try { var color = "green"; //green lance une exception var colorName = getConstantName(color); } catch (e) { var colorName = "unknown"; console.log(e.message, e.name); //Passez l'objet d'exception à la gestion des erreurs }

Mais utiliser Symbol pour définir des constantes peut garantir que les valeurs de ce groupe de constantes sont toutes différentes. Utilisez Symbol pour modifier l'exemple ci-dessus.

const COLOR_RED = Symbol("red"); const COLOR_YELLOW = Symbol("yellow"); const COLOR_BLUE = Symbol("blue"); function ColorException(message) { this.message = message; this.name = "ColorException"; } function getConstantName(color) { switch (color) { case COLOR_RED : return "COLOR_RED"; case COLOR_YELLOW : return "COLOR_YELLOW "; case COLOR_BLUE: return "COLOR_BLUE"; default: throw new ColorException("Impossible de trouver cette couleur"); } } try { var color = "green"; //green lance une exception var colorName = getConstantName(color); } catch (e) { var colorName = "unknown"; console.log(e.message, e.name); //Passez l'objet d'exception à la gestion des erreurs }

Les valeurs Symbol sont uniques, donc il n'y aura pas de constantes ayant la même valeur, ce qui garantit que l'instruction switch s'exécute comme le code le prévoit.

Symbol.for()

Symbol.for() est similaire au modèle singleton. D'abord, il recherche globalement parmi les Symbol enregistrés s'il existe une valeur Symbol ayant ce paramètre de chaîne comme nom. Si oui, il renvoie cette valeur Symbol ; sinon, il crée une nouvelle valeur Symbol avec le paramètre de chaîne comme nom, l'enregistre dans l'environnement global pour les recherches futures.

let yellow = Symbol("Yellow"); let yellow1 = Symbol.for("Yellow"); yellow === yellow1; // false let yellow2 = Symbol.for("Yellow"); yellow1 === yellow2; // true

Symbol.keyFor()

Symbol.keyFor() renvoie la clé d'une valeur Symbol enregistrée, qui est utilisée pour vérifier si une valeur Symbol ayant ce paramètre de chaîne comme nom a été enregistrée.

let yellow1 = Symbol.for("Yellow"); Symbol.keyFor(yellow1); // "Yellow"