Symbol

Un objet Symbol est un objet natif dont le constructeur renvoie une valeur primitive de type symbol. On parle de valeur symbole ou de symbole : il s'agit d'une valeur dont l'unicité est garantie. Les symboles sont souvent utilisés pour ajouter des clés de propriétés uniques à un objet afin que celles-ci ne rentrent pas en conflit avec des clés ajoutées par un autre code. Les symboles sont masqués des mécanismes habituellement utilisés pour parcourir les propriétés d'un objet. Cela permet une sorte d'encapsulation faible, ou une forme faible de masquage de l'information.

Chaque appel à Symbol() garantit le renvoi d'un symbole unique. Chaque appel à Symbol.for("cle") renverra toujours le même symbole correspondant à la valeur "cle". Lorsque Symbol.for("cle") est appelé, si un symbole existe avec cette clé dans le registre global des symboles, il est renvoyé. Sinon, un nouveau symbole est créé et est ajouté au registre global des symboles avec cette clé puis est renvoyé.

Description

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"

Symboles partagés et registre global des symboles

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.

Trouver les propriétés identifiées par des symboles pour un objet

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.

Constructeur

Symbol() (en-US)

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

Propriétés statiques

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.

Méthodes statiques

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.

Propriétés des instances

Symbol.prototype.description

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

Méthodes des instances

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.

Exemples

Utiliser l'opérateur typeof avec des symboles

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

typeof Symbol() === 'symbol'
typeof Symbol('toto') === 'symbol'
typeof Symbol.iterator === 'symbol'

Les symboles et les conversions

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 et les boucles for…in

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 symboles et JSON.stringify()

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

Utiliser les symboles enveloppés dans un objet

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

Spécifications

Specification
ECMAScript Language Specification
# sec-symbol-objects

Compatibilité des navigateurs

BCD tables only load in the browser

Voir aussi