recursal/MDN huggingface dataset:
Constructeur WeakRef()
======================

 Le constructeur **`WeakRef`** crée un objet `WeakRef`
 qui représente une référence faible vers un objet cible.

Syntaxe
-------


```js
new WeakRef(objetCible);
```

### Paramètres

objetCible

L'objet cible auquel l'objet `WeakRef` devrait faire référence (également appelé *référent*).

Exemples
--------

### Créer un nouvel objet WeakRef

Voir la page principale de `WeakRef` pour un exemple complet.


```js
class Counter {
  constructor(element) {
    // Construit une référence faible vers un élément du DOM
    this.ref = new WeakRef(element);
    this.start();
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weak-ref-constructor |

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

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

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

* `WeakRef`
Number.prototype.toExponential()
================================

La méthode **`toExponential()`** renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle.

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

Syntaxe
-------


```js
numObj.toExponential([nbChiffresDécimaux]);
```

### Paramètre

`nbChiffresDécimaux`

Paramètre optionnel. Un entier donnant le nombre de chiffres qu'on souhaite avoir dans la partie fractionnaire. Le comportement par défaut considèrera autant de chiffres que nécessaire pour représenter le nombre.

### Valeur de retour

Une chaîne représentant l'objet `Number` appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à `nbChiffresDécimaux` après la virgule.

### Exceptions

`RangeError`

Cette exception est causée si `nbChiffresDécimaux` est trop petit ou trop grand. Les valeurs comprises, au sens large, entre 0 et 20 ne causeront pas d'exception `RangeError`. Les implémentations peuvent également autorisér des valeurs en dehors de ces bornes.

`TypeError`

Si cette méthode est invoquée pour un objet qui n'est pas un objet `Number`.

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

La valeur renvoyée est une chaîne de caractères correspondant à la représentation du nombre en notation exponentielle. La partie entière est constituée d'un seul chiffre et la partie fractionnaire est composée de `nbChiffresDécimaux` chiffres. Si l'argument `nbChiffresDécimaux` est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique.

Si la méthode `toExponential()` est utilisée avec un littéral numérique et que celui-ci ne possède aucun exposant ou séparateur décimal ("."), il faut laisser un ou plusieurs espaces entre le littéral et le point indiquant l'appel de la méthode. Cela permet d'éviter que le point, permettant d'accéder à la méthode, soit confondu avec un séparateur décimal.

Si un nombre possède plus de chiffres décimaux que `nbChiffresDécimaux`, le nombre est arrondi au nombre le plus proche, représenté avec `nbChiffresDécimaux` pour la partie fractionnaire. Voir la discussion sur les arrondis dans la page de la méthode `toFixed()` pour plus de détails, la même méthode est utilisée pour `toExponential()`.

Exemples
--------

### Utiliser `toExponential`


```js
var numObj = 77.1234;

console.log(numObj.toExponential()); // affiche 7.71234e+1
console.log(numObj.toExponential(4)); // affiche 7.7123e+1
console.log(numObj.toExponential(2)); // affiche 7.71e+1
console.log((77.1234).toExponential()); // affiche 7.71234e+1
console.log((77).toExponential()); // affiche 7.7e+1
```

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

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

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`
Number.isNaN()
==============

La méthode **`Number.isNaN()`** permet de déterminer si la valeur passée en argument est `NaN`, avec un type `Number`. Cette version est plus robuste que la méthode de l'objet global `isNaN`.

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

Syntaxe
-------


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

### Paramètres

`valeurÀTester`

La valeur qu'on souhaite comparer à `NaN`.

### Valeur de retour

Un booléen qui indique si la valeur fournie en argument est `NaN`.

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

Les deux opérateurs d'égalité, `==` et `===`, renvoient `false` pour vérifier que `NaN` *est* NaN. La fonction `Number.isNaN` est nécessaire pour distinguer ce cas. Le résultat de cette comparaison sera différent avec les autres méthodes de comparaisons en JavaScript.

En effet, la fonction globale `isNaN` convertit l'argument en un nombre. `Number.isNaN` ne convertit pas l'argument. Cela signifie qu'on peut passer des valeurs qui, normalement, seraient converties en NaN, mais qui ne sont pas NaN. Cela signifie également que, uniquement lorsque la méthode sera utilisée avec des nombres qui valent `NaN`, elle renverra `true`.

Exemples
--------


```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true

// tout le reste renverra : false
Number.isNaN(undefined);
Number.isNaN({});

Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);

Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
Number.isNaN("NaN");
Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode isNaN de l'objet global
```

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

La fonction suivant fonctionne car `NaN` est la seule valeur JavaScript qui n'est pas égale à elle-même.


```js
Number.isNaN =
  Number.isNaN ||
  function (value) {
    return typeof value === "number" && isNaN(value);
  };
```

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

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

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 `Object.is` qui permet d'effectuer des comparaisons sur l'égalité de valeur
* La méthode `isNaN` de l'objet global
Number.MIN\_SAFE\_INTEGER
=========================

La constante **`Number.MIN_SAFE_INTEGER`** représente le plus petit entier représentable correctement en JavaScript (-(2^53 -1)).

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

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

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

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

La constante `MIN_SAFE_INTEGER` vaut `-9007199254740991`. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés en format à double précision selon la norme IEEE 754 et on ne peut représenter correctement que les nombres compris entre `-(2^53-1)` et `2^53 -1`. Voir `Number.isSafeInteger()` pour plus d'informations.

`MIN_SAFE_INTEGER` étant une méthode statique de `Number`, il faut utiliser `Number.MIN_SAFE_INTEGER()` et non pas la méthode d'un objet `Number` qui aurait été instancié.

Exemples
--------


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

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

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

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

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

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

* `Number.MAX_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`
Constructeur Number()
=====================

Le **constructeur `Number()`** permet de créer un objet `Number`.

Syntaxe
-------


```js
new Number(valeur);
```

### Paramètres

`valeur`

La valeur numérique de l'objet à créer.

Exemples
--------

### Créer des objets `Number`


```js
const a = new Number("123"); // a === 123 vaut false
const b = Number("123"); // b === 123 vaut true
a instanceof Number; // true
b instanceof Number; // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number-constructor |

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

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

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

* Prothèse d'émulation pour `Number` (incluant les fonctionnalités récentes sur la prise en charge des littéraux binaires et octaux, avec la bibliothèque `core-js`
* `NaN`
* L'objet global `Math`
* Les objets `BigInt` qui permettent de représenter des entiers avec une précision arbitraire
Number.parseFloat()
===================

La méthode **`Number.parseFloat()`** analyse et convertit une chaîne de caractères en un nombre flottant. Cette méthode possède un comportement identique à `parseFloat` et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales).

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

Syntaxe
-------


```js
Number.parseFloat(chaîne);
```

### Paramètres

`chaîne`

Une chaîne de caractères qu'on souhaite convertir en nombre flottant.

### Valeur de retour

Un nombre flottant obtenu à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, la valeur `NaN` sera renvoyée.

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

Cette méthode possède les mêmes fonctionnalités que la fonction globale `parseFloat()` :


```js
Number.parseFloat === parseFloat; // true
```


Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation de certaines fonctions globales. Pour plus de détails et d'exemples, voir `parseFloat()`.

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


```js
if (Number.parseFloat === undefined) {
  Number.parseFloat = parseFloat;
}
```

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

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

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 fonction.
* La méthode globale `parseFloat`.
Number.prototype.toString()
===========================

La méthode **`toString()`** renvoie une chaîne de caractère représentant l'objet Number.

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

Syntaxe
-------


```js
numObj.toString([base]);
```

### Paramètre

`base`

Paramètre optionnel. Un entier compris entre 2 et 36 qui indique la base du système numérique à utiliser pour représenter la valeur.

### Valeur de retour

Une chaîne de caractères représentant l'objet `Number`.

### Exception

`RangeError`

Si `toString()` reçoit une base qui n'est pas comprise entre 2 et 36, une exception `RangeError` est levée.

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

L'objet `Number` surcharge la méthode `toString()` de `Object` et n'hérite donc pas de `Object.prototype.toString()`. Pour les objets `Number`, la méthode `toString()` renvoie une représentation du nombre, dans une base donnée, en une chaîne de caractères.

La méthode `toString()` analyse son premier argument et tente de renvoyer une chaîne de caractères représentant le nombre en une base donnée. Pour les bases supérieures à 10, les lettres de l'alphabet sont utilisées pour représenter les numéraux supérieurs à 9. Par exemple, pour les nombres hexadécimaux (en base 16), les lettres `a` à `f` sont utilisées.

Si la base n'est pas spécifiée, on utilisera la base 10 par défaut.

Si l'objet `Number` est négatif, le signe sera conservé. Ceci, même si la base utilisée est la base 2 : la chaîne de caractères rendue sera la représentation binaire du nombre positif précédée par un signe -. La représentation **n'est pas** le complément à deux du nombre.

Si l'objet `Number` n'est pas un nombre entier, le point (.) sera utilisé pour séparer la partie entière et décimale.

Exemples
--------

### Utiliser `toString`


```js
var compte = 10;

console.log(compte.toString()); // affiche "10"
console.log((17).toString()); // affiche "17"
console.log((17.2).toString()); // affiche "17.2"

var x = 6;

console.log(x.toString(2)); // affiche "110"
console.log((254).toString(16)); // affiche "fe"

console.log((-10).toString(2)); // affiche "-1010"
console.log((-0xff).toString(2)); // affiche "-11111111"
```

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

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

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
Number.EPSILON
==============

La propriété **`Number.EPSILON`** représente la différence entre le chiffre 1 (un) et la plus petite valeur supérieure à 1 qui peut être représentée par un nombre en JavaScript.

Il n'est pas nécessaire de créer un objet `Number` pour accéder à cette propriété statique, elle est accessible avec `Number.EPSILON`.

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

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

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

La propriété `EPSILON` vaut environ `2.2204460492503130808472633361816E-16` (ce qui correspond à 2^-52).

Exemple
-------

### Tester une égalité mathématique avec un seuil de précision


```js
x = 0.2;
y = 0.3;
equal = Math.abs(x - y) < Number.EPSILON;
```

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


```js
if (Number.EPSILON === undefined) {
  Number.EPSILON = Math.pow(2, -52);
}
```

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

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

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 propriété.
Number.prototype.toPrecision()
==============================

La méthode **`toPrecision()`** renvoie une chaîne de caractères représentant un nombre avec la précision donnée.

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

Syntaxe
-------


```js
numObj.toPrecision([précision]);
```

### Paramètre

`précision`

Paramètre optionnel. Un entier spécifiant le nombre de chiffres significatifs.

### Valeur de retour

Cette méthode renvoie une chaîne de caractères représentant l'objet `Number` en notation à point fixe ou en notation exponentielle, arrondi avec un nombre de chiffres significatifs égal à `précision`. Le principe utilisé pour les arrondis est celui décrit dans la page de la méthode `Number.prototype.toFixed()`.

Si l'argument `précision` n'est pas utilisé, la méthode aura le même effet que `Number.prototype.toString()`. Si cet argument n'est pas un nombre entier, on prendra le nombre entier le plus proche.

### Exceptions

`RangeError`

Si `précison` n'est pas compris, au sens large, entre 1 et 100, on aura une exception `RangeError`. Les implémentations peuvent supporter des valeurs supérieures et/ou inférieures. Le standard ECMA-262 ne nécessite qu'une précision allant jusqu'à 21 chiffres significatifs.

Exemples
--------


```js
var objetNumber = 5.123456;
console.log(objetNumber.toPrecision()); //affiche "5.123456"
console.log(objetNumber.toPrecision(5)); //affiche "5.1235"
console.log(objetNumber.toPrecision(2)); //affiche "5.1"
console.log(objetNumber.toPrecision(1)); //affiche "5"

numObj = 0.000123;

console.log(numObj.toPrecision()); // affiche "0.000123"
console.log(numObj.toPrecision(5)); // affiche "0.00012300"
console.log(numObj.toPrecision(2)); // affiche "0.00012"
console.log(numObj.toPrecision(1)); // affiche "0.0001"

// dans certaines circonstances, on peut avoir une notation exponentielle
console.log((1234.5).toPrecision(2)); // "1.2e+3"
```

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

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

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toString()`
Number.MIN\_VALUE
=================

La propriété **`Number.MIN_VALUE`** représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript.

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

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

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

La propriété `MIN_VALUE` représente le nombre positif le plus proche de 0 et non pas le nombre négatif minimal qu'il est possible de représenter en JavaScript.

`MIN_VALUE` vaut environ 5e-324. Les valeurs inférieures à `MIN_VALUE` sont converties en 0.

`MIN_VALUE` est une propriété statique de `Number` et doit donc être utilisée avec la syntaxe `Number.MIN_VALUE`, et non pas via la propriété d'un objet `Number` qui aurait été instancié.

Exemples
--------

Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à `MIN_VALUE`, la fonction `func1` sera appelée, sinon la fonction `func2` sera utilisée.


```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

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

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

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

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

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

* `Number.MAX_VALUE`
Number.parseInt()
=================

La méthode **`Number.parseInt()`** analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée.

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

Syntaxe
-------


```js
Number.parseInt(chaîne [, base])
```

### Paramètres

`chaîne`

La valeur à convertir. Si `chaine` n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés.

`base` Facultatif

Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. **Il faut toujours spécifier ce paramètre.** Cela permet que le code ne soit pas ambigü et permet de garantir un comportement prévisible. En effet les différentes implémentations peuvent fournir des résultats différents lorsque la base n'est pas spécifiée.

### Valeur de retour

Un entier construit à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère ne permet pas de conversion numérique, c'est la valeur `NaN` qui sera renvoyée.

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

Voir la page `parseInt()` pour plus de détails et d'exemples. Cette méthode se comporte de façon identique à la fonction globale `parseInt()` et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales) et on aura :


```js
Number.parseInt === parseInt; // true
```

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

Si on souhaite bénéficier de cette fonction dans un environnement qui n'en dispose pas, on pourra donc l'émuler de la façon suivante :


```js
if (Number.parseInt === undefined) {
  Number.parseInt = parseInt;
}
```

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

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

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 fonction.
* La méthode `parseInt()` de l'objet global.
Number.prototype.toFixed()
==========================

La méthode **`toFixed()`** permet de formater un nombre en notation à point-fixe.

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

Syntaxe
-------


```js
numObj.toFixed([nbChiffres]);
```

### Paramètres

`nbChiffres` Facultatif

Le nombre de chiffres qu'on souhaite avoir après le séparateur décimal. Cette valeur peut être comprise, au sens large, entre 0 et 20. Les différentes implémentations peuvent éventuellement supporter des valeurs en dehors de cet intervalle. Si l'argument n'est pas utilisé, la valeur par défaut sera 0.

### Valeur de retour

Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe.

### Exceptions causées

`RangeError`

Cette exception est renvoyée si `nbChiffres` est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de `RangeError`. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes.

`TypeError`

Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique.

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

`toFixed()` renvoie une chaîne de caractères représentant `objetNumber` sans notation exponentielle et qui possède exactement `nbChiffres` pour la partie fractionnaire. Le nombre est arrondi si nécessaire et la partie fractionnaire est complétée par des zéros si nécessaire pour obtenir la longueur souhaitée. Si le `objetNumber` est supérieur ou égal à `1e+21`, la méthode utilise simplement `Number.prototype.toString()` et renvoie une chaîne en notation exponentielle.

**Attention :** En raison du standard IEEE 754 qui est utilisé par JavaScript pour représenter les nombres, tous les nombres décimaux ne sont pas représentés exactement en JavaScript, ce qui peut mener à des résultats inattendus (comme `0.1 + 0.2 === 0.3` qui renvoie `false`).

Exemples
--------


```js
var numObj = 12345.6789;

numObj.toFixed(); // Renvoie '12346' : arrondi, aucune partie fractionnaire
numObj.toFixed(1); // Renvoie '12345.7' : arrondi ici aussi
numObj.toFixed(6); // Renvoie '12345.678900' : des zéros sont ajoutés
(1.23e20).toFixed(2); // Renvoie '123000000000000000000.00'
(1.23e-10).toFixed(2); // Renvoie '0.00'
(2.34).toFixed(1); // Renvoie '2.3'
-(2.34).toFixed(1); // Renvoie -2.3 (en raison de la précédence des opérateurs,
// les littéraux de nombres négatifs ne renvoient pas de chaînes)
(2.35).toFixed(1); // Renvoie '2.4' (arrondi supérieur)
(2.55).toFixed(1); // Renvoie '2.5' (cf. l'avertissement ci-avant)
(-2.34).toFixed(1); // Renvoie '-2.3'
```

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

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

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

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

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

* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`