recursal/MDN huggingface dataset:
Math.atan()
===========

La fonction **`Math.atan()`** renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par :



Math.atan
(
x
)

=
arctan
(
x
)
=le seul

y
∊

[

-

π
2

;

π
2

]

tel que

tan
(
y
)
=
x

\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \tan(y) = x

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

Syntaxe
-------


```js
Math.atan(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'arc tangente du nombre passé en argument (exprimé en radians).

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

La méthode `Math.atan()` renvoie une valeur numérique comprise entre 


-

π
2

-\frac{\pi}{2}

 et 


π
2

\frac{\pi}{2}

.

`atan()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.atan()`, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.atan()`


```js
Math.atan(1); // 0.7853981633974483
Math.atan(0); // 0
Math.atan(-0); // -0

Math.atan(Infinity); // 1.5707963267948966
Math.atan(-Infinity); // -1.5707963267948966

// L'angle formé entre la droite [(0,0);(x,y)] et l'axe des abscisses
// dans un système de coordonnées cartésienne
Math.atan(y / x);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan |

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

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

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

* `Math.acos()`
* `Math.asin()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.LOG2E
==========

La propriété **`Math.LOG2E`** représente la valeur du logarithme en base 2 de e, environ 1.442 :


Math.LOG2E

=

log
2

(
e
)
≈
1.442

\mathtt{\mi{Math.LOG2E}} = \log\_2(e) \approx 1.442

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

| Attributs de `Math.LOG2E` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

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

`LOG2E` est une propriété statique de l'objet `Math` et doit toujours être utilisé avec la syntaxe `Math.LOG2E` plutôt que comme la propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.LOG2E`

La fonction suivante renvoie la valeur du logarithme en base 2 de e :


```js
function getLog2e() {
  return Math.LOG2E;
}

getLog2e(); // 1.4426950408889634
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2e |

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.sqrt()
===========

La fonction **`Math.sqrt()`** renvoie la racine carrée d'un nombre. Cette fonction est définie par :



∀
x
≥
0
,

M
a
t
h
.
s
q
r
t
(
x
)

=

x

=
l'unique

y
≥
0

tel que

y
2

=
x

\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} ; y \geq 0 ; \text{such that} ; y^2 = x

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

Syntaxe
-------


```js
Math.sqrt(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est `NaN` qui sera renvoyé.

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

Si la valeur de `x` est négative, `sqrt` renverra `NaN`.

`sqrt()` est une méthode statique de `Math`, elle doit être utilisée avec la syntaxe `Math.sqrt()`, elle ne doit pas être appelée comme méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------


```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
Math.sqrt(-0); // -0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt |

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

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

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

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`
Math.LN2
========

La propriété **`Math.LN2`** représente le logarithme naturel de 2, environ 0.693:


Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693

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

| Attributs de `Math.LN2` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

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

`LN2` est une propriété statique de l'objet `Math`, il doit toujours être utilisé avec la syntaxe `Math.LN2`, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.LN2`

La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de `Math.LN2` :


```js
function getLog2(x) {
  return Math.log(x) / Math.LN2;
}

getLog2(256); // 8
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln2 |

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.imul()
===========

La fonction **`Math.imul()`** renvoie le résultat de la multiplication de deux nombres, calculée avec la représentation sur 32 bits de ces nombres, à la façon du langage C.

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

Syntaxe
-------


```js
Math.imul(a, b);
```

### Paramètres

`a`

Le premier nombre.

`b`

Le second nombre.

### Valeur de retour

Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C).

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

`Math.imul()` permet d'effectuer une multiplication rapide pour des entiers sur 32 bits avec une sémantique proche du langage C. Cela est utile pour des aspects de performance, notamment pour des projets comme Emscripten. `imul()` étant une méthode statique de `Math`, il faut utiliser `Math.imul()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec `Math.imul()` car cela implique une opération de conversion des flottants vers les entiers pour la multiplication puis une opération de conversion du résultat en flottant. Dans la pratique, `Math.imul()` est notamment pertinent pour asm.js.

Exemples
--------

### Utiliser `Math.imul()`


```js
Math.imul(2, 4); // 8
Math.imul(-1, 8); //-8
Math.imul(-2, -2); // 4
Math.imul(0xffffffff, 5); //-5
Math.imul(0xfffffffe, 5); //-10
```

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

Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :


```js
Math.imul =
  Math.imul ||
  function (a, b) {
    var ah = (a >>> 16) & 0xffff;
    var al = a & 0xffff;
    var bh = (b >>> 16) & 0xffff;
    var bl = b & 0xffff;
    // Le décalage par 0 rétablit le signe de la partie haute
    // le |0 final convertit la valeur non-signée en une valeur signée
    return (al \* bl + (((ah \* bl + al \* bh) << 16) >>> 0)) | 0;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.imul |

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

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

La propriété **`Math.PI`** représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159:


Math.PI

=
π
≈
3.14159

\mathtt{\mi{Math.PI}} = \pi \approx 3.14159

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

| Attributs de `Math.PI` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

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

`PI` est une propriété statique de l'objet `Math` et doit toujours être utilisée avec la syntaxe `Math.PI` plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.PI`

La fonction suivante utilise `Math.PI` afin de calculer le périmètre d'un cercle à partir du rayon passé en argument.


```js
function calculPérimètre(rayon) {
  return 2 \* Math.PI \* rayon;
}

calculPérimètre(1); // 6.283185307179586
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pi |

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

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

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

* `Math`
Math.asin()
===========

La fonction **`Math.asin()`** renvoie l'arc sinus d'un nombre (en radians). Elle est définie par :



∀
x
∊
[

-
1

;
1
]
,

Math.asin
(
x
)

=
arcsin
(
x
)
=
 le seul 

y
∊

[

-

π
2

;

π
2

]

tel que

sin
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \sin(y) = x

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

Syntaxe
-------


```js
Math.asin(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'arc sinus du nombre passé en argument (exprimé en radians). Si ce nombre n'est pas compris entre -1 et 1, la valeur renvoyée sera `NaN`.

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

La méthode `Math.asin()` renvoie une valeur numérique comprise entre 


-

π
2

-\frac{\pi}{2}

 et 


π
2

\frac{\pi}{2}

 pour `x` compris entre -1 et 1. Si `x` est hors de cet intervalle, la méthode renverra `NaN`.

`Math.asin()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.asin()`, elle ne doit pas être appelée à partir d'un autre objet créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.asin()`


```js
Math.asin(-2); // NaN
Math.asin(-1); // -1.570796326794897 (-pi/2)
Math.asin(0); // 0
Math.asin(0.5); // 0.5235987755982989
Math.asin(1); // 1.570796326794897 (pi/2)
Math.asin(2); // NaN
```


Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.asin()` renvoie `NaN`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asin |

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

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

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

* `Math.acos()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.cbrt()
===========

La fonction **`Math.cbrt()`** renvoie la racine cubique (le nom anglais étant *cubic root*) d'un nombre :



M
a
t
h
.
c
b
r
t
(
x
)

=

x
3

=
le seul

y

tel que

y
3

=
x

\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} ; y ; \text{such that} ; y^3 = x

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

Syntaxe
-------


```js
Math.cbrt(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

La racine cubique du nombre passé en argument.

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

`cbrt()` étant une méthode statique de `Math`, il faut utiliser `Math.cbrt()`, et non pas la méthode d'un autre objet créé (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.cbrt()`


```js
Math.cbrt(NaN); // NaN
Math.cbrt(-1); // -1
Math.cbrt(-0); // -0
Math.cbrt(-Infinity); // -Infinity
Math.cbrt(0); // 0
Math.cbrt(1); // 1
Math.cbrt(Infinity); // Infinity
Math.cbrt(null); // 0
Math.cbrt(2); // 1.2599210498948732
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cbrt |

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

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

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

* `Math.pow()`
* `Math.sqrt()`
Math.exp()
==========

La fonction **`Math.exp()`** renvoie l'exponentielle d'un nombre (donnée par `e^x`, où `x` est la valeur passée en argument et `e` la valeur du nombre d'Euler (parfois appelé constante de Napier).

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

Syntaxe
-------


```js
Math.exp(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'exponentielle du nombre passé en argument (`e^x`).

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

`exp()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.exp()`, elle ne doit pas être utilisée avec un objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.exp()`


```js
Math.exp(-1); // 0.36787944117144233
Math.exp(0); // 1
Math.exp(1); // 2.718281828459045
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.exp |

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

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

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

* `Math.E`
* `Math.expm1()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`
Math.acos()
===========

La fonction **`Math.acos()`** renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par :



∀
x
∊
[

-
1

;
1
]
,

Math.acos
(
x
)

=
arccos
(
x
)
=
 le seul 
y
∊
[
0
;
π
]

tel que

cos
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } ; y \in [0; \pi] , \text{such that} ; \cos(y) = x

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

Syntaxe
-------


```js
Math.acos(x);
```

### Paramètres

`x`

Un nombre (représentant un angle exprimé en radians).

### Valeur de retour

L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie `NaN` sinon.

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

La méthode `acos` renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de `x` est hors de cet intervalle, la méthode renverra `NaN`.

`acos` est une méhode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.acos()`, elle ne doit pas être appelée depuis un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.acos()`


```js
Math.acos(-2); // NaN
Math.acos(-1); // 3.141592653589793
Math.acos(0); // 1.5707963267948966
Math.acos(0.5); // 1.0471975511965979
Math.acos(1); // 0
Math.acos(2); // NaN
```


Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.acos` renvoie `NaN`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acos |

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

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

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

* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.log10()
============

La fonction **`Math.log10()`** renvoie le logarithme en base 10 d'un nombre, donné par la formule :



∀
x
>
0
,

Math.log10
(
x
)

=

log
10

(
x
)
=
l'unique 
y

tel que

10
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log\_10(x) = \text{the unique} ; y ; \text{such that} ; 10^y = x

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

Syntaxe
-------


```js
Math.log10(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est `NaN` qui sera renvoyé.

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

Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à `NaN`.

`log10()` étant une méthode statique de `Math`, il faut utiliser `Math.log10()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par `Math.log(x) / Math.log(10)`.

Exemple
-------

### Utiliser `Math.log10()`


```js
Math.log10(2); // 0.3010299956639812
Math.log10(1); // 0
Math.log10(0); // -Infinity
Math.log10(-2); // NaN
Math.log10(100000); // 5
```

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

Il est possible d'avoir un résultat approximatif avec la fonction suivante :


```js
Math.log10 =
  Math.log10 ||
  function (x) {
    return Math.log(x) \* Math.LOG10E;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log10 |

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`
Math.acosh()
============

La fonction **`Math.acosh()`** renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par :



∀
x
≥
1
,

Math.acosh
(
x
)

=
arcosh
(
x
)
=
 l'unique 

y
≥
0

tel que

cosh
(
y
)
=
x

\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } ; y \geq 0 ; \text{such that} ; \cosh(y) = x

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

Syntaxe
-------


```js
Math.acosh(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera `NaN`.

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

`acosh` étant une méthode statique de `Math`, il faut l'utiliser avec `Math.acosh()`, plutôt qu'en faisant appel à une méthode d'un autre objet créé (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.acosh()`


```js
Math.acosh(-1); // NaN
Math.acosh(0); // NaN
Math.acosh(0.5); // NaN
Math.acosh(1); // 0
Math.acosh(2); // 1.3169578969248166
```


Pour les valeurs strictement inférieures à 1 `Math.acosh` renvoie `NaN`.

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

Pour tout 


x
≥
1

x \geq 1

, 


arcosh
(
x
)
=
ln

(

x
+

x
2

-
1

)

\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)

, on peut donc émuler cette fonction avec le code suivant :


```js
function acosh(x) {
  return Math.log(x + Math.sqrt(x \* x - 1));
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acosh |

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

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

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

* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.round()
============

La fonction **`Math.round()`** retourne la valeur d'un nombre arrondi à l'entier le plus proche.

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

Syntaxe
-------


```js
Math.round(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

La valeur de l'entier le plus proche du nombre passé en argument.

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

Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus grande. Si elle est plus petite que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus petite. Si la partie décimale du nombre vaut exactement 0.5, l'argument est arrondi à l'entier le plus proche en direction de l'infini positif (attention, pour la plupart des langages de programmation, c'est le nombre avec la plus grande valeur absolue qui est renvoyé ; on a donc une différence de comportement pour les nombres négatifs dont la partie décimale vaut exactement 0.5).

`round()` étant une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.round()`, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------


```js
Math.round(20.49); // 20
Math.round(20.5); // 21
Math.round(42); // 42
Math.round(-20.5); // -20
Math.round(-20.51); // -21
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.round |

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

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

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

* `Number.toPrecision()`
* `Number.toFixed()`
* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.sign()`
* `Math.trunc()`
JSON.parse()
============

La méthode **`JSON.parse()`** analyse une chaîne de caractères JSON et construit la valeur JavaScript ou l'objet décrit par cette chaîne. On peut éventuellement utiliser cette fonction avec un paramètre de modification permettant de traiter l'objet avant qu'il soit renvoyé.

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

Syntaxe
-------


```js
JSON.parse(texte[, reviver])
```

### Paramètres

`texte`

La chaine de caractère à analyser comme du JSON. Voir l'objet `JSON` pour une description de la syntaxe JSON.

`reviver`

Si l'argument est une fonction, effectue une opération de transformation sur la valeur analysée avant de la renvoyer.

### Valeur de retour

Un objet (`Object`) correspondant au texte envoyé.

### Exceptions

Lève une exception `SyntaxError` si la chaine de caractère à analyser ne contient pas du JSON valide.

Exemples
--------

### Utiliser `JSON.parse()`


```js
try {
  JSON.parse("{}"); // {}
  JSON.parse("true"); // true
  JSON.parse('"toto"'); // "toto"
  JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
  JSON.parse("null"); // null
} catch (e) {
  console.error("Parsing error:", e);
}
```

### Utiliser le paramètre `reviver`

Si un *reviver* est spécifié, la valeur obtenue par l'analyse est transformée avant d'être renvoyée. Plus précisément, la valeur calculée, et toutes les propriétés (commençant avec les propriétés les plus imbriquées), sont passées individuellement au *reviver*, qui est appelé avec : l'objet contenant la propriété en cours de traitement, le nom de la propriété en chaine de caractères et la valeur de la propriété. Si la fonction *reviver* retourne `undefined` (ou ne retourne aucune valeur, par exemple si l'exécution s'arrête à la fin de la fonction), la propriété est supprimée de l'objet. Autrement la propriété est redéfinie avec la valeur retournée.

Si le *reviver* ne transforme que certaines valeurs et pas d'autres, assurez-vous que les valeurs inchangées soient renvoyées telles quelles. En effet, si elles ne sont pas renvoyées, elles seront supprimés sur l'objet obtenu !


```js
JSON.parse('{"p": 5}', (key, value) => {
  if (typeof value === "number") {
    return value \* 2; // renvoie value \* 2 pour les nombres
  }
  return value; // pour le reste, la valeur est inchangée
});

// { p: 10 }

JSON.parse('{"1": 1, "2": 2,"3": {"4": 4, "5": {"6": 6}}}', (key, value) => {
  console.log(key); // on affiche le nom de la propriété dans la console
  return value; // et on renvoie la valeur inchangée.
});

// 1
// 2
// 4
// 6
// 5
// 3
// ""
```

### `JSON.parse()` n'accepte pas les virgules en fin de tableau


```js
// les deux instructions qui suivent lèveront une SyntaxError
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{ "toto" : 1, }');
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

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

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

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

* `JSON.stringify()`