Symbol

Pour créer une nouvelle valeur primitive symbole, il suffit d'appeler Symbol(), éventuellement avec une chaîne de caractères descriptive :

let sym1 = Symbol();
let sym2 = Symbol("toto");
let sym3 = Symbol("toto");

Le fragment de code ci-dessus permet de créer trois nouveaux symboles. On notera que l'instruction Symbol('toto') ne convertit pas la chaîne 'toto' en un symbole. On crée bien un nouveau symbole pour chaque instruction ci-avant.

Symbol("toto") === Symbol("toto"); // false

La syntaxe suivante, utilisant l'opérateur new, entraînera une exception TypeError :

let sym = new Symbol(); // TypeError

Cela est fait pour empêcher d'écrire une enveloppe (wrapper) explicite de Symbol plutôt qu'une nouvelle valeur. Cela peut être surprenant, car généralement, on peut créer des objets enveloppant des types primitifs (par exemple avec new Boolean, new String et new Number).

Si on souhaite obtenir un object contenant un symbole, on pourra toujours utiliser la fonction Object() :

let sym = Symbol("toto");
typeof sym; // "symbol"
let symObj = Object(sym);
typeof symObj; // "object"

La syntaxe manipulée ci-avant, utilisant la fonction Symbol(), ne crée pas un symbole global, disponible partout dans votre code. Pour créer des symboles qui soient disponibles pour différents fichiers et appartiennent à l'environnement global, il faut utiliser les méthodes Symbol.for() et Symbol.keyFor() afin de définir et de récupérer les symboles listés dans le registre global.

La méthode Object.getOwnPropertySymbols() renvoie un tableau de symboles, permettant ainsi de connaître les propriétés identifiées par un symbole pour un objet donné. À l'initialisation, un objet ne contient aucune propriété propre identifiée par un symbole, ce tableau sera donc vide jusqu'à ce qu'une propriété, identifiée par un symbole, lui soit ajoutée.

Symbol()

Crée un nouvel objet Symbol. Il ne s'agit pas d'un constructeur au sens strict, car il ne prend pas en charge la syntaxe new Symbol().

Symbol.asyncIterator

Une méthode qui renvoie l'itérateur asynchrone par défaut d'un objet. Utilisée par for await…of.

Symbol.hasInstance

Une méthode qui détermine si le constructeur d'un objet reconnaît un objet comme une de ses instances. Utilisée par instanceof.

Symbol.isConcatSpreadable

Un booléen qui indique si un objet devrait être aplati avec ses éléments de tableau. Utilisée par Array.prototype.concat().

Symbol.iterator

Une méthode renvoyant l'itérateur par défaut d'un objet. Utilisée par for…of.

Symbol.match

Une méthode qui cherche des correspondances sur une chaîne de caractères et qui peut aussi être utilisée afin de déterminer si un objet peut être utilisé comme expression rationnelle. Utilisée par String.prototype.match().

Symbol.matchAll

Une méthode qui renvoie un itérateur fournissant les correspondances entre une expression rationnelle et une chaîne de caractères. Utilisée par String.prototype.matchAll().

Symbol.replace

Une méthode qui remplace les correspondances trouvées dans une chaîne de caractères. Utilisée par String.prototype.replace().

Symbol.search

Une méthode qui renvoie l'indice d'une chaîne de caractères indiquant où se situe une correspondance par rapport à une expression rationnelle. Utilisée par String.prototype.search().

Symbol.split

Une méthode qui divise une chaîne de caractères aux indices des correspondances par rapport à une expression rationnelle. Utilisée par String.prototype.split().

Symbol.species

Une fonction de construction utilisée pour créer des objets dérivés.

Symbol.toPrimitive

Une méthode convertissant un objet en valeur primitive.

Symbol.toStringTag

Une chaîne de caractères utilisée pour la description par défaut d'un objet. Utilisée par Object.prototype.toString().

Symbol.unscopables

Un objet dont les noms des propriétés propres et héritées ont exclues des liaisons d'environnement with de l'objet correspondant.

Symbol.for(cle)

Recherche les symboles existants avec la clé fournie en argument et les renvoie s'il y en a. Dans le cas contraire, un nouveau symbole est créé au sein du registre global avec cette clé.

Symbol.keyFor(sym)

Récupère la clé d'un symbole donné au sein du registre global.

Symbol.prototype.description

Une chaîne de caractères accessible en lecture seule et qui contient la description du symbole.

Symbol.prototype.toString()

Renvoie une chaîne de caractères contenant la description du symbole. Il s'agit d'une surcharge de la méthode Object.prototype.toString().

Symbol.prototype.valueOf()

Renvoie le symbole. Il s'agit d'une surcharge de la méthode Object.prototype.valueOf().

Symbol.prototype[@@toPrimitive]

Renvoie le symbole.

L'opérateur typeof permet d'identifier des symboles :

typeof Symbol() === "symbol";
typeof Symbol("toto") === "symbol";
typeof Symbol.iterator === "symbol";

Lorsqu'on utilise des mécanismes de conversion de types avec les symboles, on aura le comportement suivant :

• Lorsqu'on tente de convertir un symbole en un nombre, cela provoquera une exception TypeError (par exemple avec +sym ou sym | 0).
• L'égalité faible permet d'obtenir true avec Object(sym) == sym.
• Symbol("toto") + "truc" lève une exception TypeError (le symbole ne peut pas être converti en une chaîne de caractères), cela permet par exemple d'éviter de créer (sans s'en rendre compte) des noms de propriétés basés sur des symboles.
• La méthode utilisant la conversion avec String() fonctionnera comme un appel à Symbol.prototype.toString(). En revanche, new String(sym) renverra une erreur.

Les symboles ne peuvent pas être énumérés dans les boucles for…in. De plus, la méthode Object.getOwnPropertyNames() ne renverra pas les propriétés identifiées par des symboles. La méthode Object.getOwnPropertySymbols() permet d'avoir accès à ces propriétés.

let obj = {};

obj[Symbol("a")] = "a";
obj[Symbol.for("b")] = "b";
obj["c"] = "c";
obj.d = "d";

for (let i in obj) {
  console.log(i); // affiche "c" et "d"
}

Les propriétés identifiées par des symboles seront totalement ignorées par JSON.stringify() :

JSON.stringify({ [Symbol("toto")]: "toto" });
// '{}'

Pour plus de détails, voir la page JSON.stringify().

Lorsqu'on utilise un objet pour contenir la valeur du symbole et faire référence à une propriété, l'objet sera ramené au symbole d'origine :

let sym = Symbol("toto");
let obj = { [sym]: 1 };
obj[sym]; // 1
obj[Object(sym)]; // toujours 1

• Une prothèse d'émulation de Symbol dans la bibliothèque core-js
• La page du glossaire sur le type de données symbole
• typeof
• Types et structures de données en JavaScript
• L'article ES6 en détails sur les symboles, disponible sur tech.mozfr.org