recursal/MDN huggingface dataset:
Infinity
========

La propriété globale **`Infinity`** est une valeur numérique représentant l'infini.

| Attributs de `Infinity` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

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

Syntaxe
-------


```js
Infinity;
```

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

`Infinity` est une propriété de *l'objet global* , c'est-à-dire qu'elle est accessible globalement.

La valeur initiale d'`Infinity` est `Number.POSITIVE_INFINITY`. La valeur `Infinity` (infinité positive) est une valeur plus grande que n'importe quel nombre. Cette valeur se comporte comme l'infini mathématique ; par exemple, tout ce qui est multiplié par `Infinity` vaut `Infinity`, et tout ce qui est divisé par `Infinity` vaut 0.

D'après la spécification ECMAScript 5, `Infinity` est en lecture seule.

Exemples
--------


```js
console.log(Infinity); // Infinity
console.log(Infinity + 1); // Infinity
console.log(Math.pow(10, 1000)); // Infinity
console.log(Math.log(0)); // -Infinity
console.log(1 / Infinity); // 0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-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.POSITIVE_INFINITY`
* `Number.isFinite`
Reflect
=======

**`Reflect`** est un objet natif qui fournit des méthodes pour les opérations qui peuvent être interceptées en JavaScript (via les proxies). Les méthodes de cet objet sont les mêmes que celles des gestionnaires de proxy. `Reflect` n'est pas une fonction (y compris pour construire un objet).

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

Contrairement à la plupart des objets globaux, `Reflect` n'est pas un constructeur. Il ne peut pas être utilisé avec l'opérateur `new` ou être invoqué comme une fonction. Les propriétés et méthodes de `Reflect` sont statiques (comme pour celles de l'objet `Math`).

Méthodes
--------

L'objet `Reflect` fournit des fonctions statiques qui ont les mêmes noms que les méthodes des gestionnaires de proxy et dont certaines correspondent, avec quelques différences, à celles d'`Object` :

`Reflect.apply()`

Appelle une fonction cible avec les arguments définis par le paramètres `args`. Voir aussi `Function.prototype.apply()`.

`Reflect.construct()`

L'opérateur `new` comme fonction. C'est équivalent à `new cible(...args)`. Cette méthode permet également d'indiquer un prototype différent.

`Reflect.defineProperty()`

Semblable à `Object.defineProperty()`. Renvoie un `Boolean`.

`Reflect.deleteProperty()`

L'opérateur `delete` comme fonction. C'est équivalent à `delete cible[nom]`.

`Reflect.get()`

Une fonction qui renvoie la valeur d'une propriété.

`Reflect.getOwnPropertyDescriptor()`

Semblable à `Object.getOwnPropertyDescriptor()`. Renvoie un descripteur de propriété si la propriété existe sur l'objet, `undefined` sinon.

`Reflect.getPrototypeOf()`

Identique à `Object.getPrototypeOf()`.

`Reflect.has()`

L'opérateur `in` comme fonction. Renvoie un booléen qui indique si une telle propriété existe pour l'objet (qu'elle soit directement rattachée ou héritée).

`Reflect.isExtensible()`

La même fonction que `Object.isExtensible()`.

`Reflect.ownKeys()`

Renvoie un tableau de chaînes de caractères qui correspondent aux noms des propriétés propres (celles qui ne sont pas héritées) de l'objet.

`Reflect.preventExtensions()`

Semblable à `Object.preventExtensions()`. Renvoie un `Boolean`.

`Reflect.set()`

Une fonction qui affecte des valeurs à des propriétés. Renvoie un `Boolean` qui vaut `true` si la mise à jour a bien été effectuée.

`Reflect.setPrototypeOf()`

Une fonction qui permet de définir le prototype d'un objet.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect-object |

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

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

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

* L'objet global `Proxy`.
* L'objet `handler` (en-US).
TypeError
=========

Un objet **`TypeError`** représente une erreur qui se produit généralement (mais pas toujours) lorsqu'une opération n'a pu avoir lieu parce qu'une valeur n'a pas le type attendu.

Une exception `TypeError` peut être levée lorsque :

* Un opérande ou un argument passé à une fonction est incompatible avec le type attendu par l'opérateur ou la fonction
* On tente de modifier une valeur qui ne peut pas être changée
* On tente d'utiliser une valeur de façon inappropriée.
Constructeur
------------

`TypeError()`

Crée un nouvel objet `TypeError`.

Propriétés des instances
------------------------

`TypeError.prototype.message`

Le message d'erreur.

`TypeError.prototype.name`

Le nom de l'erreur. Hérité depuis `Error`.

`TypeError.prototype.fileName`

Le chemin du fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`TypeError.prototype.lineNumber`

Le numéro de la ligne du fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`TypeError.prototype.columnNumber`

Le numéro de colonne de la ligne du fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`TypeError.prototype.stack`

La pile d'appels. Héritée depuis `Error`.

Exemples
--------

### Intercepter une exception `TypeError`


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### Créer une exception `TypeError`


```js
try {
  throw new TypeError("Coucou", "unFichier.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "unFichier.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-typeerror |

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

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

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

* `Error`
isFinite()
==========

La fonction globale **`isFinite()`** détermine si la valeur passée en argument est un nombre fini. Si nécessaire, le paramètre est d'abord converti en nombre.

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

Syntaxe
-------


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

### Paramètres

`valeurÀTester`

La valeur dont on souhaite savoir si elle est finie ou non.

### Valeur de retour

`false` si la valeur passée en argument vaut `Infinity` (en positif ou en négatif),`NaN` ou `undefined`, `true` sinon.

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

`isFinite()` est une fonction qui n'est rattachée à aucun objet et qui est disponible au plus haut niveau.

Cette fonction peut être utilisée pour déterminer si un nombre est fini ou non. La fonction `isFinite()` examine le nombre passé en argument : si celui-ci vaut `NaN`, `Infinity` (pour l'infini) ou `-Infinity` (pour l'infini négatif), cette fonction renvoie `false` sinon elle renvoie `true`.

Exemples
--------


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

isFinite(0); // true
isFinite(2e64); // true
isFinite(910); // true
isFinite(null); // true, ce qui aurait été false
// avec la méthode Number.isFinite(null)

isFinite("0"); // true ce qui aurait été false
// avec la méthode Number.isFinite("0")
```

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

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

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

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

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

* `Number.isFinite()`
* `Number.NaN`
* `Number.POSITIVE_INFINITY`
* `Number.NEGATIVE_INFINITY`
encodeURI()
===========

La fonction **`encodeURI()`** encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par une, deux, trois ou quatre séquences d'échappement représentant le caractère encodé en UTF-8 (les quatre séquences d'échappement ne seront utilisées que si le caractère est composé de deux caractères « *surrogate* »).

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

Syntaxe
-------


```js
encodeURI(URI);
```

### Paramètres

`URI`

Un Uniform Resource Identifier complet.

### Valeur de retour

Une nouvelle chaîne de caractères représentant un URI, encodé, à partir de la chaîne de caractères passée en argument.

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

`encodeURI()` échappe tous les caractères sauf ceux-ci :
```

A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #
```


`encodeURI()` est différente de `encodeURIComponent`. Par exemple :


```js
var set1 = ";,/?:@&=+$#"; // Caractères réservés
var set2 = "-\_.!~\*'()"; // Caractères non-réservés
var set3 = "ABC abc 123"; // Caractères alphanumériques et espace

console.log(encodeURI(set1)); // ;,/?:@&=+$#
console.log(encodeURI(set2)); // -\_.!~\*'()
console.log(encodeURI(set3)); // ABC%20abc%20123 (l'espace est encodé en %20)

console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23
console.log(encodeURIComponent(set2)); // -\_.!~\*'()
console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (l'espace est encodé en %20)
```


Une exception `URIError` sera levée si on tente d'encoder un caractère *surrogate* (demi-codet) qui ne fait pas partie d'une paire :


```js
// On a une paire de codets surrogate
console.log(encodeURI("\uD800\uDFFF"));

// Ici, seul le caractère "haut"
// ce qui déclenche une "URIError: malformed URI sequence"
console.log(encodeURI("\uD800"));

// Ici, seul le caractère "bas"
// ce qui déclenche une "URIError: malformed URI sequence"
console.log(encodeURI("\uDFFF"));
```


`encodeURI()` ne permet pas de former des requêtes HTTP GET ou POST (par exemple avec `XMLHTTPRequest`) car "&", "+" et "=" ne sont pas encodés et sont traités comme des caractères spéciaux (toutefois, la méthode. `encodeURIComponent` pourra être utilisée pour encoder ces caractères).

Si on souhaite suivre la RFC3986 qui concerne les URL et qui rend les crochets réservés (pour IPv6) (il ne faut donc plus encoder ces caractères lorsqu'ils font partie d'une URL (notamment pour la partie représentant l'hôte), on pourra utiliser le fragment de code suivant :


```js
function fixedEncodeURI(str) {
  return encodeURI(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-encodeuri-uri |

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

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

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

* `decodeURI()`
* `encodeURIComponent()`
* `decodeURIComponent()`
unescape()
==========

**Attention :** Bien que `unescape(…)` ne soit pas strictement obsolète (au sens où elle n'a pas été retirée des standards), elle est définie au sein de l'Annexe B du standard ECMA-262 qui commence par :

> 
> 
>  … L'ensemble des fonctionnalités et comportements définis dans cette annexe possède une ou plusieurs caractéristiques indésirables. En l'absence d'une utilisation historique, ces fonctionnalités seraient retirés de la spécification. …
>  … Les développeurs ne devraient pas utiliser ces fonctionnalités et comportements ou présupposer qu'elles existent lors de l'écriture de nouveau code ECMAScript. …
>  
> 
> 
> 

La fonction dépréciée **`unescape()`** calcule une nouvelle chaîne de caractères et remplace les séquences d'échappement hexadécimales par les caractères qu'elles représentent. Les séquences d'échappement peuvent provenir de la fonction `escape`. Cette méthode est obsolète, c'est pourquoi il est conseillé d'utiliser `decodeURI` ou `decodeURIComponent` à la place.

**Note :** `unescape()` ne doit pas être utilisée pour décoder les URI. À la place, utilisez `decodeURI`.

Syntaxe
-------


```js
unescape(str);
```

### Paramètres

`str`

La chaîne de caractères à décoder.

### Valeur de retour

Une nouvelle chaîne de caractères dont les caractères ont été décodés.

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

La fonction `unescape` est une propriété de l'*objet global*.

Exemples
--------


```js
unescape("abc123"); // "abc123"
unescape("%E4%F6%FC"); // "äöü"
unescape("%u0107"); // "ć"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-unescape-string |

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

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

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

* `decodeURI`
* `decodeURIComponent`
* `escape`
InternalError
=============

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

 L'objet **`InternalError`** indique qu'une erreur interne liée au moteur JavaScript s'est produite.
 De telles erreurs se produisent généralement au dépassement d'un seuil, par exemple :

* « trop de cas pour le `switch` » ;
* « trop de parenthèses dans l'expression rationnelle » ;
* « initialisateur de tableau trop grand » ;
* « trop de niveaux de récursion ».
Constructeur
------------

`InternalError()`

Crée un nouvel objet `InternalError`.

Propriétés des instances
------------------------

`InternalError.prototype.message`

Message d'erreur, hérité depuis `Error`.

`InternalError.prototype.name`

Nom d'erreur, hérité depuis `Error`.

`InternalError.prototype.fileName`

Le chemin du fichier qui a déclenché cette erreur, hérité depuis `Error`.

`InternalError.prototype.lineNumber`

Le numéro de la ligne du fichier qui a déclenché cette erreur, hérité depuis `Error`.

`InternalError.prototype.columnNumber`

Le numéro de colonne de la ligne du fichier qui a déclenché cette erreur, hérité depuis `Error`.

`InternalError.prototype.stack`

La pile d'appels, héritée depuis `Error`.

Exemples
--------

### Trop de niveau de récursion

Cette fonction récursive s'appelle 10 fois, comme indiquée par la condition d'arrêt.


```js
function boucle(x) {
  if (x >= 10) {
    // "x >= 10" représente la condition d'arrêt
    return;
  }
  // faire des trucs
  boucle(x + 1); // l'appel récursif
}
boucle(0);
```


En changeant cette condition avec une valeur extrêmement grande, cela ne fonctionnera plus :


```js
function boucle(x) {
  if (x >= 1000000000000) {
    return;
  }
  // faire des trucs
  boucle(x + 1);
}
boucle(0);

// InternalError: too much recursion
```


Pour plus d'informations, voir la page sur `InternalError: too much recursion`.

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

Cet objet ne fait partie d'aucune spécification.

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

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

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

* `Error`
* `InternalError: too much recursion`
GeneratorFunction
=================

En JavaScript, chaque fonction génératrice est en réalité un objet `GeneratorFunction`. Il n'existe pas d'objet global avec le nom `GeneratorFunction`, mais il est possible de créer un constructeur `GeneratorFunction()` avec le code suivant :


```js
const GeneratorFunction = Object.getPrototypeOf(function\* () {}).constructor;
```

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

Les fonctions génératrices créées avec un constructeur sont analysées à la création de la fonction. Il s'agit là d'une méthode moins efficace qu'une déclaration de fonction génératrice avec une expression `function*` qu'on appelle dans le code. En effet, de telles fonctions sont alors analysées avec le reste du code.

Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction à créer, dans l'ordre dans lequel ils sont passés.

**Note :** Les fonctions génératrices créées avec un constructeur ne créent pas de fermetures avec leur contexte de création. Elles sont toujours créées dans la portée globale.

Lors de leur exécution, elles ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles de la portée dans laquelle le constructeur a été appelé.

Il y a donc une différence de comportement par rapport à une expression `eval()` qui contiendrait une expression de fonction génératrice.

Invoquer un constructeur de fonction génératrice comme une fonction (sans utiliser `new`) aura le même effet que d'appeler le constructeur.

Exemples
--------

### Créer un générateur en utilisant le constructeur `GeneratorFunction()`


```js
const GeneratorFunction = Object.getPrototypeOf(function\* () {}).constructor;
const g = new GeneratorFunction("a", "yield a \* 2");
const iterator = g(10);
console.log(iterator.next().value); // 20
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generatorfunction-objects |

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

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

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

* L'instruction `function*`
* L'expression `function*`
* `Function`
* L'instruction `function`
* L'expression `function`
* Les fonctions et portées de fonctions
escape()
========

**Attention :** Bien que `escape(…)` ne soit pas strictement obsolète (au sens où elle n'a pas été retirée des standards), elle est définie au sein de l'Annexe B du standard ECMA-262 qui commence par :

> 
> 
>  … L'ensemble des fonctionnalités et comportements définis dans cette annexe possède une ou plusieurs caractéristiques indésirables. En l'absence d'une utilisation historique, ces fonctionnalités seraient retirés de la spécification. …
>  … Les développeurs ne devraient pas utiliser ces fonctionnalités et comportements ou présupposer qu'elles existent lors de l'écriture de nouveau code ECMAScript. …
>  
> 
> 
> 

La fonction **`escape()`** permet de renvoyer une nouvelle chaîne de caractères dont certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Cette méthode est obsolète et il est donc conseillé d'utiliser `encodeURI` ou `encodeURIComponent` à la place.

**Note :** Cette fonction pouvait être utilisée pour l'encodage de fragment de requêtes d'URL. Si on souhaite remplacer des caractères par leur séquence d'échappement correcte (avec `%20` par exemple), on pourra utiliser `decodeURIComponent`.

Syntaxe
-------


```js
escape(str);
```

### Paramètres

`str`

Une chaîne de caractères à encoder.

### Valeur de retour

Une nouvelle chaîne de caractères dont certains caractères ont été échappés.

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

La fonction `escape` est une propriété de l'*objet global*. Les caractères spéciaux, sauf `@*_+-./`, seront encodés.

La forme hexadécimale des caractères dont la valeur du codet est inférieure à 0xFF sera représentée sur deux chiffres : %xx. Pour les caractères avec un code supérieur, quatre chiffres seront utilisés avec le format suivant %**u**xxxx.

Exemples
--------


```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// caractères spéciaux
escape("@\*\_+-./"); // "@\*\_+-./"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

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

* `encodeURI`
* `encodeURIComponent`
* `unescape`
SyntaxError
===========

L'objet **`SyntaxError`** représente une erreur qui se produit lors de l'interprétation d'un code dont la syntaxe est invalide. Une telle exception est déclenchée lorsque le moteur JavaScript rencontre des entités lexicales invalides ou dans un ordre invalide par rapport à la grammaire du langage.

Constructeur
------------

`SyntaxError()`

Crée un nouvel objet `SyntaxError`.

Propriétés des instances
------------------------

`SyntaxError.prototype.message`

Le message d'erreur. Hérité depuis `Error`.

`SyntaxError.prototype.fileName`

Le chemin du fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`SyntaxError.prototype.lineNumber`

Le numéro de ligne dans le fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`SyntaxError.prototype.columnNumber`

Le numéro de colonne de la ligne du fichier qui a déclenché l'erreur. Hérité depuis `Error`.

`SyntaxError.prototype.stack`

La pile d'appels. Héritée depuis `Error`.

Exemples
--------

### Intercepter une exception `SyntaxError`


```js
try {
  eval("toto truc");
} catch (e) {
  console.log(e instanceof SyntaxError); // true
  console.log(e.message); // "missing ; before statement"
  console.log(e.name); // "SyntaxError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 1
  console.log(e.columnNumber); // 4
  console.log(e.stack); // "@Scratchpad/1:2:3\n"
}
```

### Créer une exception `SyntaxError`


```js
try {
  throw new SyntaxError("Coucou", "unFichier.js", 10);
} catch (e) {
  console.log(e instanceof SyntaxError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "SyntaxError"
  console.log(e.fileName); // "unFichier.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:11:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-syntaxerror |

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

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

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

* `Error`
EvalError
=========

L'objet **`EvalError`** indique une erreur relative à la fonction `eval()`. Cette exception n'est plus déclenchée par JavaScript, toutefois, l'objet `EvalError` est toujours présent à des fins de compatibilité.

Constructeur
------------

`EvalError()`

Crée un nouvel objet `EvalError`.

Propriétés des instances
------------------------

`EvalError.prototype.message`

Le message d'erreur.

`EvalError.prototype.name`

Le nom de l'erreur, hérité depuis `Error`.

`EvalError.prototype.fileName`

Le chemin vers le fichier qui a déclenché l'erreur, hérité depuis `Error`.

`EvalError.prototype.lineNumber`

Le numéro de la ligne dans le fichier qui a déclenché l'erreur, hérité depuis `Error`.

`EvalError.prototype.columnNumber`

Le numéro de la colonne de la ligne du fichier qui a déclenché l'erreur, hérité depuis `Error`.

`EvalError.prototype.stack`

La pile d'appels, héritée depuis `Error`.

Exemples
--------

`EvalError` n'est pas utilisée par la spécification ECMAScript actuelle et ne sera donc pas déclenchée par un moteur récent. Toutefois, cet objet reste disponible pour la rétrocompatibilité avec les anciennes versions de la spécification.

### Créer un objet `EvalError`


```js
try {
  throw new EvalError("Coucou", "unFichier.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "EvalError"
  console.log(e.fileName); // "unFichier.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-evalerror |

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

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

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

* `Error`
* `eval()`