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 :


```js
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.


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


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


```js
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()` :


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

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 :


```js
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.


```js
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()` :


```js
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 :


```js
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 with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* 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