recursal/MDN huggingface dataset:
Number.NEGATIVE\_INFINITY
=========================

La propriété **`Number.NEGATIVE_INFINITY`** représente l'infini négatif.

Exemple interactif
------------------

| Attributs de `Number.NEGATIVE_INFINITY` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

La valeur de `Number.NEGATIVE_INFINITY` est égale à l'opposé de la valeur fournie par la propriété `Infinity` de l'objet global.

Cette valeur se comporte différemment de l'infini mathématique :

* Toute valeur positive, y compris `POSITIVE_INFINITY`, multipliée par `NEGATIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`.
* Toute valeur négative, y compris `NEGATIVE_INFINITY`, multipliée par `NEGATIVE_INFINITY` sera égale à `POSITIVE_INFINITY`.
* Zéro multiplié par `NEGATIVE_INFINITY` sera égal à `NaN`.
* NaN multiplié par `NEGATIVE_INFINITY` sera égal à `NaN`.
* `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de `NEGATIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur positive à l'exception de `POSITIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal à `NaN`.
* Tout nombre positif divisé par `NEGATIVE_INFINITY` sera égal au zéro négatif.
* Tout nombre négatif divisé par `NEGATIVE_INFINITY` sera égal au zéro positif.

La propriété `Number.NEGATIVE_INFINITY` peut être utilisée pour indiquer une erreur sur un test renvoyant normalement un nombre fini. On notera cependant que la méthode `isFinite` est plus pertinente dans ce cas.

`Number.NEGATIVE_INFINITY` est une propriété statique de `Number` et on utilisera directement `Number.NEGATIVE_INFINITY` plutôt que comme une propriété d'un objet (instance) `Number`.

Exemples
--------

Dans l'exemple qui suit, on affecte une variable inférieure à la valeur numérique minimale à la variable `petitNombre`. Lorsque l'instruction conditionnelle `if` est exécutée, `petitNombre` possède la valeur "`-Infinity`", on modifie donc la valeur de `petitNombre` afin qu'il puisse être géré.


```js
var petitNombre = -Number.MAX\_VALUE \* 2;

if (petitNombre === Number.NEGATIVE\_INFINITY) {
  petitNombre = renvoyerUneValeurFinie();
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.negative\_infinity |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Number.POSITIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`
Number.MAX\_SAFE\_INTEGER
=========================

La constante **`Number.MAX_SAFE_INTEGER`** représente la valeur (sûre) maximale d'un nombre entier en JavaScript (2^53 -1).

**Note :** Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type `BigInt`.

Exemple interactif
------------------

| Attributs de `Number.MAX_SAFE_INTEGER` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

La constante `MAX_SAFE_INTEGER` a une valeur de `9007199254740991`. Cette valeur s'explique par le fait que JavaScript utilise les nombres au format de virgule flottante à double précision comme spécifié dans IEEE 754 et ne peut représenter avec certitude qu'un nombre entre `-(2^53-1)` et `2^53 -1`.

Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` vaudra `true` ce qui est mathématiquement incorrect. Pour plus d'informations, voir également `Number.isSafeInteger()`.

`MAX_SAFE_INTEGER` est une propriété statique de `Number`, elle doit toujours être utilisée comme `Number.MAX_SAFE_INTEGER` et non pas comme la propriété d'un objet `Number` qui aurait été instancié.

Exemples
--------


```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
Math.pow(2, 53) - 1; // 9007199254740991
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_safe\_integer |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Number.MIN_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`
Number.prototype.valueOf()
==========================

La méthode **`valueOf()`** renvoie la valeur primitive correspondant à celle représentée par l'objet `Number`.

Exemple interactif
------------------

Syntaxe
-------


```js
objetNumber.valueOf();
```

### Valeur de retour

Un nombre qui représente la valeur primitive de l'objet `Number`.

Description
-----------

Cette méthode est généralement utilisée de façon interne au moteur JavaScript et n'est pas utilisée de façon explicite dans du code JavaScript.

Exemples
--------

### Utiliser `valueOf`


```js
var numObj = new Number(10);
console.log(typeof numObj); // object

var num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // number
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.valueof |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Number.prototype.toSource()`
Number.isFinite()
=================

La méthode **`Number.isFinite()`** permet de déterminer si la valeur fournie est un nombre fini.

Exemple interactif
------------------

Syntaxe
-------


```js
Number.isFinite(valeurÀTester);
```

### Paramètres

`valeurÀTester`

La valeur dont on souhaite savoir si elle est finie.

### Valeur de retour

Un booléen indiquant si la valeur passée en argument est un nombre fini.

Description
-----------

Par rapport à la fonction de l'objet global `isFinite()` qui convertit l'argument donné en un nombre, la fonction `Number.isFinite` ne convertit pas l'argument et ne renvoie pas `true`.

Exemples
--------


```js
Number.isFinite(Infinity); // false
Number.isFinite(NaN); // false
Number.isFinite(-Infinity); // false

Number.isFinite(0); // true
Number.isFinite(2e64); // true

Number.isFinite("0"); // false, ce qui aurait
// renvoyé true avec isFinite("0")

Number.isFinite(null); // false, ce qui aurait
// renvoyé true avc isFinite(null)
```

Prothèse d'émulation (*polyfill*)
---------------------------------


```js
// Number.isFinite polyfill
// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite
if (typeof Number.isFinite !== "function") {
  Number.isFinite = function isFinite(value) {
    // 1. Si Type(number) n'est pas Number, on renvoie false.
    if (typeof value !== "number") {
      return false;
    }
    // 2. Si le nombre est NaN, +∞, ou −∞, on renvoie false.
    if (value !== value || value === Infinity || value === -Infinity) {
      return false;
    }
    // 3. Sinon on renvoie true.
    return true;
  };
}
```


Deuxième version plus concise qui utilise la méthode globale `isFinite`


```js
if (Number.isFinite === undefined)
  Number.isFinite = function (value) {
    return typeof value === "number" && isFinite(value);
  };
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isfinite |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* L'objet `Number` auquel appartient cette méthode
* La méthode `isFinite()` de l'objet global
Number.isInteger()
==================

La méthode **`Number.isInteger()`** permet de déterminer si l'argument est un nombre entier.

Exemple interactif
------------------

Syntaxe
-------


```js
Number.isInteger(valeurÀTester);
```

### Paramètres

`valeurÀTester`

La valeur dont on souhaite savoir si elle est entière ou non.

### Valeur de retour

Un booléen qui indique si la valeur fournie en argument est un entier.

Description
-----------

Si la valeur à tester est un entier, cette méthode renvoie `true`, `false` sinon. Si la valeur est `NaN` ou l'infini (`Infinity`), la méthode renverra `false`. La méthode renverra également `true` pour les nombres flottants qui peuvent être représentés comme des entiers.

Exemples
--------


```js
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(0); // true
Number.isInteger(1.0); // true
// Number.isInteger(9…9999); // true, même si le nombre dépasse 32 bits

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(-Infinity); // false
Number.isInteger(true); // false
Number.isInteger(NaN); // false
Number.isInteger("10"); // false

Number.isInteger(5.0); // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true
```

Prothèse d'émulation (*polyfill*)
---------------------------------


```js
Number.isInteger =
  Number.isInteger ||
  function (value) {
    return (
      typeof value === "number" &&
      isFinite(value) &&
      Math.floor(value) === value
    );
  };
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isinteger |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* L'objet global `Number` auquel appartient cette méthode.
Number.POSITIVE\_INFINITY
=========================

La propriéte **`Number.POSITIVE_INFINITY`** représente l'infini (positif).

Exemple interactif
------------------

| Attributs de `Number.POSITIVE_INFINITY` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

La valeur de `Number.POSITIVE_INFINITY` est identique à la valeur de la propriété de l'objet global `Infinity`.

Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique :

* Tout valeur positive, y compris `POSITIVE_INFINITY,` multipliée par `POSITIVE_INFINITY` sera égale à `POSITIVE_INFINITY`.
* Toute valeur négative, y compris `NEGATIVE_INFINITY`, multipliée par `POSITIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`.
* Zéro multiplié par `POSITIVE_INFINITY` sera égal à `NaN`.
* NaN multiplié par `POSITIVE_INFINITY` sera égal à NaN.
* `POSITIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de `NEGATIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`.
* `POSITIVE_INFINITY`, divisé par n'importe quelle valeur positive, à l'exception de `POSITIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`.
* `POSITIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal NaN.
* Tout nombre positif divisé par `POSITIVE_INFINITY` sera égal au zéro positif.
* Tout nombre négatif divisé par `POSITIVE_INFINITY` sera égal au zéro négatif.

Il est possible d'utiliser la propriété `Number.POSITIVE_INFINITY` pour faire un test d'erreur sur une valeur qu'on attendait finie. Cependant, la méthode `isFinite` sera plus appropriée dans ce cas.

`Number.POSITIVE_INFINITY` est une propriété statique de `Number` et il n'est donc pas nécessaire de créer un objet `Number` afin d'utiliser cette propriété.

Exemple
-------

### Utiliser `POSITIVE_INFINITY`

Dans l'exemple qui suit, on affecte une valeur plus grande que la valeur maximale à la variable `grosNombre`. Lors de l'exécution de l'instruction `if`, `grosNombre` aura la valeur `Infinity`, pour continuer, on met à jour `grosNombre` avec une valeur plus acceptable.


```js
var grosNombre = Number.MAX\_VALUE \* 2;
if (grosNombre == Number.POSITIVE\_INFINITY) {
  grosNombre = renvoyerUnNombreFini();
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.positive\_infinity |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite`
Number.isSafeInteger()
======================

La méthode **`Number.isSafeInteger()`** permet de déterminer si la valeur, passée en argument, est un entier représentable correctement en JavaScript (c'est-à-dire un nombre compris entre -(2^53-1) et 2^53-1).

Exemple interactif
------------------

**Note :** Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type `BigInt`.

Syntaxe
-------


```js
Number.isSafeInteger(valeurÀTester);
```

### Paramètres

`valeurÀTester`

La valeur dont on souhaite savoir si elle représente un entier représentable correctement en une valeur non signée sur 32 bits. (JavaScript utilise les nombres au format de virgule flottante à double précision comme spécifié dans IEEE 754 et ne peut représenter avec certitude un entier qu'entre `-(2^53-1)` et `2^53-1` (c'est-à-dire ± `9007199254740991`).

### Valeur de retour

Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript.

Description
-----------

Un entier correctement représentable en JavaScript :

* peut exactement être représenté avec un nombre à précision double selon IEEE-754
* la réprésentation IEEE-754 du nombre ne permet pas de l'arrondir à un autre entier pouvant être représenté avec le format décrit par IEEE-754.

Ainsi, par exemple, `2^53 - 1` peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, `2^53` ne peut pas être représenté correctement car `2^53 + 1` sera arrondi en `2^53` selon les règles IEEE-754 (arrondi à l'entier le plus proche).

L'intervalle des entiers qui peuvent être correctement représentés est `[-(2^53 - 1),2^53 - 1` ].

Exemples
--------


```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(Math.pow(2, 53)); // false
Number.isSafeInteger(Math.pow(2, 53) - 1); // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.issafeinteger |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* L'objet `Number` auquel appartient cette méthode
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`
* `BigInt`
Number.NaN
==========

La propriété **`Number.NaN`** représente une valeur qui n'est pas un nombre (en anglais « *Not-A-Number* » qui donne NaN). Elle est équivalente à `NaN`.

Exemple interactif
------------------

Il n'est pas nécessaire de créer un objet `Number` pour accéder à cette propriété statique. Il suffit d'utiliser directement `Number.NaN`.

| Attributs de `Number.NaN` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* L'objet global `NaN` ;
* L'objet `Number` auquel appartient cette propriété.
Number.MAX\_VALUE
=================

La propriété **`Number.MAX_VALUE`** représente la valeur maximale qui peut être représentée par un nombre en JavaScript.

Exemple interactif
------------------

| Attributs de `Number.MAX_VALUE` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

La propriété statique `MAX_VALUE` vaut environ `1.79E+308` (soit 2^1024). Les valeurs supérieures à `MAX_VALUE` sont représentées par `Infinity` (pour l'infini).

`MAX_VALUE` est une propriété statique de `Number`, il faut donc l'utiliser avec `Number.MAX_VALUE`, plutôt qu'en faisant appel à la propriété d'un objet `Number` qui aurait été instancié (si on appelle cette propriété sur l'objet `Number` créé, on obtiendra `undefined`).

Exemples
--------

Le code suivant teste si le produit de deux nombres est inférieur ou égal à `MAX_VALUE`, selon le résultat de ce test, soit on utilisera `func1`, soit on utilisera `func2`.


```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Number.MIN_VALUE`
* `Number`
Symbol.toStringTag
==================

Le symbole connu **`Symbol.toStringTag`** est une propriété qui est une chaîne de caractères qui est utilisée pour la description textuelle par défaut d'un objet. Ce symbole est utilisé par le moteur JavaScript via la méthode `Object.prototype.toString()`.

Exemple interactif
------------------

| Attributs de `Symbol.toStringTag` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

La plupart des types JavaScript ont des étiquettes par défaut :


```js
Object.prototype.toString.call("toto"); // "[object String]"
Object.prototype.toString.call([1, 2]); // "[object Array]"
Object.prototype.toString.call(3); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(null); // "[object Null]"
// etc.
```


D'autres ont le symbole natif `toStringTag` défini :


```js
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function\* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
// etc.
```


Lorsqu'on crée des classes personnalisées, JavaScript utilise l'étiquette "Object" par défaut :


```js
class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
```


Si on utilise le symbole `toStringTag` on peut définir une étiquette personnalisée :


```js
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.tostringtag |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Object.prototype.toString()`
Symbol.prototype.valueOf()
==========================

La méthode **`valueOf()`** renvoie la valeur primitive correspondant à l'objet `Symbol`.

Syntaxe
-------


```js
Symbol().valueOf();
```

### Valeur de retour

La valeur primitive de l'objet `Symbol` indiqué.

Description
-----------

La méthode `valueOf` de `Symbol` renvoie une valeur dont le type est le type primitif symbole à partir de l'objet `Symbol` donné.

JavaScript appelle la méthode `valueOf` afin de convertir l'objet en une valeur primitive. La plupart du temps, il n'est pas nécessaire d'appeler explicitement la méthode `valueOf`. JavaScript l'appelle automatiquement dans les cas où une valeur primitive est attendue.

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.valueof |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Object.prototype.valueOf()`
Symbol.replace
==============

Le symbole connu **`Symbol.replace`** définit la méthode utilisée pour remplacer les correspondances trouvées dans une chaîne de caractères. Cette fonction est appelée par la méthode `String.prototype.replace()`.

Pour plus d'informations, se référer aux pages sur `RegExp.prototype[@@replace]()` et `String.prototype.replace()`.

Exemple interactif
------------------

| Attributs de `Symbol.replace` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.replace |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Symbol.match`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@replace]()`
Symbol.split
============

Le symbole connu **`Symbol.split`** définit la méthode qui est utilisée pour découper une chaîne de caractères à l'emplacement où une correspondance a été trouvée grâce à une expression rationnelle. Cette fonction est appelée par la méthode `String.prototype.split()`.

Pour plus d'informations, se référer aux pages sur `RegExp.prototype[@@split]()` et `String.prototype.split()`.

Exemple interactif
------------------

| Attributs de `Symbol.split` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.split |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.search`
* `RegExp.prototype[@@split]()`
Symbol.hasInstance
==================

Le symbole « connu » **`Symbol.hasInstance`** est utilisé afin de déterminer si un objet constructeur reconnaît un objet comme une de ses instances. On peut donc adapter/personnaliser le comportement de l'opérateur `instanceof` grâce à ce symbole.

Exemple interactif
------------------

| Attributs de `Symbol.hasInstance` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Exemples
--------

On peut implémenter un comportement différent pour `instanceof` de cette façon :


```js
class MonArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MonArray); // true
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.hasinstance |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `instanceof`
Symbol.prototype[@@toPrimitive]
===============================

La méthode **`[@@toPrimitive]()`** permet de convertir un objet symbole en une valeur primitive.

Syntaxe
-------


```js
Symbol()[Symbol.toPrimitive](hint);
```

### Valeur de retour

La valeur primitive de l'objet `Symbol` indiqué.

Description
-----------

La méthode `[@@toPrimitive]()` de `Symbol` renvoie la valeur primitive d'un objet `Symbol` (le résultat sera donc un symbole au sens primitif). L'argument `hint` n'est pas utilisé.

Le moteur JavaScript appelle la méthode `[@@toPrimitive]()` afin de convertir un objet en une valeur primitive. Généralement, il n'est pas nécessaire d'appeler `[@@toPrimitive]()` car le moteur JavaScript l'appelle automatiquement lorsqu'il détecte un objet là où une valeur primitive est attendue.

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype-@@toprimitive |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Symbol.toPrimitive`