recursal/MDN huggingface dataset:
RangeError: invalid date
========================

Message
-------
```

RangeError: invalid date (Edge)
RangeError: invalid date (Firefox)
RangeError: invalid time value (Chrome)
RangeError: Provided date is not in valid range (Chrome)
```

Type d'erreur
-------------

`RangeError`Quel est le problème ?
----------------------

Une chaîne de caractères indiquant une date invalide a été fournie comme argument au constructeur `Date` ou à la méthode `Date.parse()`.

Exemples
--------

### Exemples invalides

Les chaînes de caractères qui ne peuvent pas être converties en date ou les dates qui contiennent des éléments illégaux pour le format ISO renvoient généralement `NaN`. Cependant, selon l'implémentation, les chaînes de caractères qui ne respectent pas le format ISO pour les dates peuvent déclencher une exception `RangeError: invalid date`. Les instructions suivantes déclencheront cette erreur dans Firefox :


```js
new Date("toto-truc 2014");
new Date("2014-25-23").toISOString();
new Date("toto-truc 2014").toString();
```


En revanche, cette instruction renverra `NaN` dans Firefox :


```js
Date.parse("toto-truc 2014"); // NaN
```


Pour plus de détails, consulter la documentation sur `Date.parse()`.

### Exemples valides


```js
new Date("05 October 2011 14:48 UTC");
new Date(1317826080); // timestamp Unix pour le 5 octobre 2011 14:48:00 UTC
```

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

* `Date`
* `Date.prototype.parse()`
* `Date.prototype.toISOString()`
Error: Permission denied to access property "x"
===============================================

Message
-------
```

Error: Permission denied to access property "x"
```

Type d'erreur
-------------

`Error`.

Quel est le problème ?
----------------------

Il y a eu une tentative d'accès non-autorisée à un objet sur lequel vous n'avez pas de permissions. Généralement, cela se produit lorsqu'un élément `<iframe>` est chargée depuis un domaine différent et que la condition de même origine n'est pas respectée.

Exemples
--------


```html
<!doctype html>
<html>
  <head>
    <iframe
 id="myframe"
 src="http://www1.w3c-test.org/common/blank.html"></iframe>
    <script>
 onload = function () {
 console.log(frames[0].document);
 // Error: Permission denied to access property "document"
 };
 </script>
  </head>
  <body></body>
</html>
```

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

* `<iframe>`
* Condition d'origine (*same-origin policy*)
URIError: malformed URI sequence
================================

Message
-------
```

URIError: The URI to be encoded contains invalid character (Edge)
URIError: malformed URI sequence (Firefox)
URIError: URI malformed (Chrome)
```

Type d'erreur
-------------

`URIError`Quel est le problème ?
----------------------

Il y a eu une erreur lors de l'encodage ou du décodage de l'URI. Un argument fourni à `decodeURI`, `encodeURI`, `encodeURIComponent` ou à `decodeURIComponent` n'était pas valide et la fonction concernée n'a pas pu encoder ou décoder la valeur correctement.

Exemples
--------

### Encodage

L'encodage permet de remplacer certains caractères par une, deux, trois voire quatre séquences d'échappement qui représente l'encodage UTF-8 du caractère. Une exception `URIError` sera levée si on tente d'encoder un caractère *surrogate* qui ne fait pas partie d'une paire de codets :


```js
encodeURI("\uD800");
// "URIError: malformed URI sequence"

encodeURI("\uDFFF");
// "URIError: malformed URI sequence"
```


En revanche, si on dispose de la paire de codets :


```js
encodeURI("\uD800\uDFFF");
// "%F0%90%8F%BF"
```

### Décodage

Le décodage permet de remplacer chaque séquence d'échappement dans le composant encodé par le caractère qu'elle représente. S'il n'existe aucun caractère correspondant, une exception sera déclenchée :


```js
decodeURIComponent("%E0%A4%A");
// "URIError: malformed URI sequence"
```


Avec la valeur d'entrée correcte, on a généralement quelque chose qui ressemble à :


```js
decodeURIComponent("JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript\_шеллы"
```

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

* `URIError`
* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
* `decodeURIComponent`
SyntaxError: identifier starts immediately after numeric literal
================================================================

Message
-------
```

SyntaxError: Unexpected identifier after numeric literal (Edge)
SyntaxError: identifier starts immediately after numeric literal (Firefox)
SyntaxError: Unexpected number (Chrome)
```

Type d'erreur
-------------

`SyntaxError`Quel est le problème ?
----------------------

Les noms qu'on donne aux variables (aussi appelés « identifiants ») doivent respecter certaines règles…

En JavaScript, un identifiant doit commencer par une lettre, un tiret bas (\_) ou un dollar ($), il ne peut pas commencer par un chiffre. Seuls les caractères après le premier peuvent être des chiffres.

Exemples
--------

### Des variables dont le nom commence par un chiffre

En JavaScript, les noms des variables ne peuvent pas commencer par un chiffre. Aussi, le script suivant provoquera des erreurs :


```js
var 1vie = 'toto';
// SyntaxError: identifier starts immediately after numeric literal

var toto = 1vie;
// SyntaxError: identifier starts immediately after numeric literal

alert(1.toto);
// SyntaxError: identifier starts immediately after numeric literal
```


Pour éviter ce problème, il faudra renommer les variables afin d'éviter d'utiliser un chiffre au début :


```js
var vie1 = "toto";
var toto = vie1;
```

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

* La grammaire lexicale de JavaScript
* Les variables dans le Guide JavaScript
SyntaxError: redeclaration of formal parameter "x"
==================================================

Message
-------
```

SyntaxError: Let/Const redeclaration (Edge)
SyntaxError: redeclaration of formal parameter "x" (Firefox)
SyntaxError: Identifier "x" has already been declared (Chrome)
```

Type d'erreur
-------------

`SyntaxError`Quel est le problème ?
----------------------

Le même nom de variable est présent comme paramètre de la fonction et dans une affectation `let` au sein du corps de cette fonction et il n'est pas possible de redéclarer la même variable dans la même fonction ou dans le même bloc avec `let`.

Exemples
--------

Dans le fragment de code qui suit, la variable `arg` redéclare l'argument passé à la fonction.


```js
function f(arg) {
  let arg = "toto";
}

// SyntaxError: redeclaration of formal parameter "arg"
```


Si on souhaite changer la valeur de `arg` dans le corps de la fonction, c'est possible mais il ne faut pas la redéclarer. Autrement dit, on peut retirer le mot-clé `let`. Si on souhaite plutôt créer une nouvelle variable, mieux vaudra utiliser un autre nom afin d'éviter les conflits avec les noms des paramètres existants.


```js
function f(arg) {
  arg = "toto";
}

function f(arg) {
  let truc = "toto";
}
```

Notes de compatibilité
----------------------

* Avant Firefox 49, cela provoquait une exception `TypeError` (bug Firefox 1275240).
Voir aussi
----------

* `let`
* `const`
* `var`
* Déclarer des variables dans le guide JavaScript
ReferenceError: assignment to undeclared variable "x"
=====================================================

Message
-------
```

ReferenceError: assignment to undeclared variable "x" (Firefox)
ReferenceError: "x" is not defined (Chrome)
ReferenceError: Variable undefined in strict mode (Edge)
```

Type d'erreur
-------------

Une erreur `ReferenceError`, uniquement en mode strict.

Quel est le problème ?
----------------------

Une valeur a été affectée à une variable non-déclarée. Autrement dit, il y a eu une affectation qui n'utilise pas le mot-clé `var`. Il existe certaines différences entre les variables déclarées et les variables non déclarées ce qui peut entraîner des résultats étranges. C'est pour cette raison que le moteur affiche une erreur en mode strict.

Trois choses à noter lorsqu'on évoque les variables déclarées/non déclarées :

* Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales.
* Les variables déclarées sont créées avant que le code soit exécuté. Les variables non déclarées n'existent pas tant que le code qui leur est affecté est exécuté.
* Les variables déclarées sont des propriétés non-configurables de leur contexte d'exécution (la fonction ou l'espace global). Les variables non-déclarées sont configurables (elles peuvent être supprimées).

Pour plus de détails et d'exemple, se référer à la page sur `var`.

Les erreurs à propos des affectations sur les variables non déclarées se produisent uniquement en mode strict. En mode non-strict, elles sont ignorées silencieusement.

Exemples
--------

### Exemples invalides

Ici, la variable `truc` n'est pas déclarée :


```js
function toto() {
  "use strict";
  truc = true;
}
toto(); // ReferenceError: assignment to undeclared variable truc
```

### Exemples valides

Afin de déclarer `truc`, on peut ajouter le mot-clé `var` devant.


```js
function toto() {
  "use strict";
  var truc = true;
}
toto();
```

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

* Le mode strict
SyntaxError: unparenthesized unary expression can't appear on the left-hand side of '\*\*'
==========================================================================================

L'exception JavaScript *"unparenthesized unary expression can't appear on the left-hand side of '\*\*'"* se produit lorsqu'un opérateur unaire (parmi `typeof`, `void`, `delete`, `await`, `!`, `~`, `+`, `-`) est utilisé sur l'opérande gauche de l'opérateur d'exponentiation sans parenthèse.

Message
-------
```

SyntaxError: Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence (moteur JavaScript basé sur V8)
SyntaxError: unparenthesized unary expression can't appear on the left-hand side of '**' (Firefox)
SyntaxError: Unexpected token '**'. Ambiguous unary expression in the left hand side of the exponentiation expression; parentheses must be used to disambiguate the expression. (Safari)
```

Type d'erreur
-------------

`SyntaxError`Quel est le problème ?
----------------------

Cela provient vraisemblablement d'une écriture comme celle-ci :


```js
-a \*\* b
```


Ici, l'expression est ambigüe et on ne sait pas si elle devrait être évaluée comme `(-a) ** b` ou comme `-(a ** b)`. En mathématiques, l'écriture -x2 signifie `-(x ** 2)`, et c'est ainsi que de nombreux langages de programmation, comme Python, Haskell, et PHP, gèrent cette évaluation. Mais si la précédence de l'opérateur unaire moins l'emporte sur `**`, cela casse la symétrie avec `a ** -b`, qui s'évalue sans ambigüité comme `a ** (-b)`. Aussi, le langage interdit cette syntaxe et impose d'utiliser des parenthèses d'un côté ou de l'autre pour résoudre l'ambigüité.


```js
(-a) \*\* b;
-(a \*\* b);
```


D'autres opérateurs unaires ne peuvent pas être utilisés sur l'opérande gauche non plus.


```js
await a \*\* b;
!a \*\* b;
+a \*\* b;
~a \*\* b;
```

Exemples
--------

Lorsqu'on écrit des expressions mathématiques complexes utilisant l'exponentiation, on peut aboutir à quelque chose comme :


```js
function taylorSin(x) {
  return (n) => -1 \*\* n \* x \*\* (2 \* n + 1) / factorial(2 \* n + 1);
  // SyntaxError: unparenthesized unary expression can't appear on the left-hand side of '\*\*'
}
```


Toutefois, le fragment `-1 ** n` est illégal en JavaScript. À la place, on utilisera des parenthèses sur l'opérande gauche :


```js
function taylorSin(x) {
  return (n) => ((-1) \*\* n \* x \*\* (2 \* n + 1)) / factorial(2 \* n + 1);
}
```


Cela a également l'avantage de rendre le code plus compréhensible et explicite.

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

* Discussion originale à propos de la précédence de l'opérateur d'exponentiation (en anglais)
* L'opérateur d'exponentiation
* La précédence des opérateurs
TypeError: cyclic object value
==============================

Message
-------
```

TypeError: cyclic object value (Firefox)
TypeError: Converting circular structure to JSON (Chrome and Opera)
TypeError: Circular reference in value argument not supported (Edge)
```

Type d'erreur
-------------

`TypeError`Quel est le problème ?
----------------------

Lorsqu'on appelle la méthode `JSON.stringify()`, les structures de références cycliques ne peuvent pas être converties en chaîne de caractères car le format JSON ne prend pas en charge les références (bien qu'un brouillon IETF existe).

Exemples
--------

Avec une structure circulaire comme la suivante :


```js
var a = {};
var b = {};
a.child = b;
b.child = a;
```


`JSON.stringify()` échouera :


```js
JSON.stringify(a);
// TypeError: cyclic object value
```


Il est nécessaire de contrôler l'existence de cycles avant la conversion en chaîne de caractères. On peut par exemple fournir une fonction de remplacement comme deuxième argument de la fonction `JSON.stringify()`.


```js
const getCircularReplacer = () => {
  const seen = new WeakSet();
  return (key, value) => {
    if (typeof value === "object" && value !== null) {
      if (seen.has(value)) {
        return;
      }
      seen.add(value);
    }
    return value;
  };
};

JSON.stringify(circularReference, getCircularReplacer());
// {"otherData":123}
```


On peut également utiliser une bibliothèque ou une fonction utilitaire pour ce scénario. comme cycle.js.

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

* `JSON.stringify`
* cycle.js qui introduit deux fonctions : `JSON.decycle` `et JSON.retrocycle` qui permettent d'encoder et de décoder des structures cycliques en JSON.
SyntaxError: Unexpected '#' used outside of class body
======================================================

L'expression JavaScript "Unexpected '#' used outside of class body" (qu'on peut traduire par « '#' inattendu en dehors d'un corps de classe ») se produit lorsqu'un croisillon (« # ») est trouvé dans un contexte inattendu, notamment en dehors d'une déclaration de classe. Les croisillons sont valides au début d'un fichier comme commentaire d'interpréteur, ou à l'intérieur d'une classe pour indiquer un champ privé. Vous pouvez également rencontrer cette erreur si vous oubliez d'encadrer un identifiant DOM entre quotes (la chaîne de caractères n'étant alors pas délimitée).

Message
-------


```js
SyntaxError: Unexpected '#' used outside of class body.
```

Type d'erreur
-------------

`SyntaxError`

Quel est le problème ?
----------------------

Un caractère `#` a été trouvé dans un contexte inattendu. Cela peut être à du code déplacé qui ne fait plus partie d'une classe, à un commentaire d'interpréteur (*hashbang*) situé sur une autre ligne que la première ou à l'oubli de quotes/guillemets autour d'un identifiant du DOM.

Exemples
--------

### Délimiteurs de chaîne manquants

Pour chaque cas, on peut avoir une légère erreur qui produit cette exception. Par exemple :


```js
document.querySelector(#un-élément)
```


Pourra être corrigé avec :


```js
document.querySelector("#un-élément");
```

### En dehors d'une classe


```js
class ClasseAvecChampPrivé {
  #champPrivé;

  constructor() {}
}

this.#champPrivé = 42;
```


Cela pourra être corrigé en déplaçant le champ privé à l'intérieur de la classe :


```js
class ClasseAvecChampPrivé {
  #champPrivé;

  constructor() {
    this.#champPrivé = 42;
  }
}
```

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

* `SyntaxError`
RangeError: x can't be converted to BigInt because it isn't an integer
======================================================================

L'exception JavaScript *"x can't be converted to BigInt because it isn't an integer"* se produit lorsque la fonction `BigInt()` est utilisée sur un nombre qui n'est pas entier.

Message
-------
```

RangeError: The number 1.5 cannot be converted to a BigInt because it is not an integer (moteur basé sur V8 et Firefox)
RangeError: Not an integer (Safari)
```

Type d'erreur
-------------

`RangeError`.

Quel est le problème ?
----------------------

Lorsqu'on utilise la fonction `BigInt()` afin de convertir un nombre en un grand entier, le nombre doit être une valeur entière (telle que `Number.isInteger()` renvoie `true`).

Exemples
--------

### Exemples invalides


```js
const a = BigInt(1.5);
// RangeError: The number 1.5 cannot be converted to a BigInt because it is not an integer
const b = BigInt(NaN);
// RangeError: NaN cannot be converted to a BigInt because it is not an integer
```

### Exemples valides


```js
const a = BigInt(1);
```

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

* `BigInt()`
* `Number.isInteger()`
TypeError: "x" is not a non-null object
=======================================

Message
-------
```

TypeError: Invalid descriptor for property {x} (Edge)
TypeError: "x" is not a non-null object (Firefox)
TypeError: Property description must be an object: "x" (Chrome)
TypeError: Invalid value used in weak set (Chrome)
```

Type d'erreur
-------------

`TypeError`Quel est le problème ?
----------------------

Un objet devrait être trouvé et n'est pas fourni. La valeur `null` n'est pas un objet et ne fonctionnera pas, il est nécessaire de fournir un véritable objet pour que le code en question fonctionne.

Exemples
--------

### Absence d'un descripteur de propriété

Lorsqu'on utilise des méthodes telles que `Object.create()`, `Object.defineProperty()` ou `Object.defineProperties()`, le paramètre optionnel de description des propriétés doit être un descripteur sous la forme d'un objet. Si la valeur fournie n'est pas un objet (mais par exemple un nombre), l'appel à la méthode déclenchera une erreur :


```js
Object.defineProperty({}, "cle", 1);
// TypeError: 1 is not a non-null object

Object.defineProperty({}, "cle", null);
// TypeError: null is not a non-null object
```


Un descripteur de propriété valide aura la structure suivante :


```js
Object.defineProperty({}, "cle", { value: "toto", writable: false });
```

### Les clés de `WeakMap` et `WeakSet` sont des objets

Les objets `WeakMap` et `WeakSet` utilisent des objets comme clé. On ne peut pas utiliser d'autres types de valeurs pour les clés de ces objets.


```js
var ws = new WeakSet();
ws.add("toto");
// TypeError: "toto" is not a non-null object
```


À la place, on utilisera des objets :


```js
ws.add({ toto: "truc" });
ws.add(window);
```

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

* `Object.create()`
* `Object.defineProperty()`, `Object.defineProperties()`
* `WeakMap`, `WeakSet`
SyntaxError: missing ) after condition
======================================

Message
-------
```

SyntaxError: Expected ')' (Edge)
SyntaxError: missing ) after condition (Firefox)
```

Type d'erreur
-------------

`SyntaxError`Quel est le problème ?
----------------------

Il y a une erreur pour la condition écrite dans l'instruction `if`. Pour chaque langage de programmation, on utilise des instructions pour choisir quel bloc d'instructions exécuter selon les différentes entrées. L'instruction `if` permet d'exécuter une instruction si une condition donnée est vérifiée. En JavaScript, il faut que cette condition apparaisse entre parenthèses après le mot-clé `if` :


```js
if (condition) {
  // faire quelque chose si la condition est vraie
}
```

Exemples
--------

Il s'agit peut-être simplement d'une coquille et il suffit alors de vérifier les parenthèses (ou plutôt leur absence) :


```js
if (3 > Math.PI {
  console.log("Pardon ?");
}

// SyntaxError: missing ) after condition
```


Pour corriger ce fragment de code, on ajoutera une parenthèse pour fermer la condition :


```js
if (3 > Math.PI) {
  console.log("Pardon ?");
}
```


Si vous avez l'habitude d'utiliser un autre langage de programmation, peut-être avez-vous utilisé un mot-clé qui n'existe pas en JavaScript ?


```js
if (done is true) {
 console.log("we are done!");
}

// SyntaxError: missing ) after condition
```


Pour corriger cette erreur, on utilisera un opérateur de comparaison correct :


```js
if (done === true) {
  console.log("Et voilà !");
}
```

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

* `if...else`
* Les opérateurs de comparaisons
* Choisir quel code exécuter : les structures conditionnelles
TypeError: can't convert x to BigInt
====================================

L'exception JavaScript *"x can't be converted to BigInt"* se produit lorsqu'on essaie de convertir un symbole, `null`, ou `undefined` en une valeur `BigInt`, ou si une opération qui s'applique à un paramètre `BigInt` reçoit un nombre.

Message
-------
```

TypeError: Cannot convert null to a BigInt (moteur JavaScript basé sur V8)
TypeError: can't convert null to BigInt (Firefox)
TypeError: Invalid argument type in ToBigInt operation (Safari)
```

Type d'erreur
-------------

`TypeError`.

Quel est le problème ?
----------------------

Lorsqu'on utilise la fonction `BigInt()` afin de convertir une valeur en grand entier, la valeur doit d'abord être convertie en une valeur primitive. Une fois cette conversion effectuée, si la valeur n'est pas un grand entier, une chaîne de caractères, un nombre ou un booléen, une erreur est levée.

Certaines opérations, comme `BigInt.asIntN()`, prennent uniquement un grand entier en paramètre, leur passer un nombre à la place déclenchera la même erreur.

Exemples
--------

### Utiliser `BigInt()` sur des valeurs invalides


```js
const a = BigInt(null);
// TypeError: can't convert null to BigInt
const b = BigInt(undefined);
// TypeError: can't convert undefined to BigInt
const c = BigInt(Symbol("1"));
// TypeError: can't convert Symbol("1") to BigInt
```



```js
const a = BigInt(1);
const b = BigInt(true);
const c = BigInt("1");
const d = BigInt(Symbol("1").description);
```


**Note :** Le simple fait de convertir la valeur en un nombre ou en une chaîne de caractères à l'aide de `String()` ou `Number()` avant de la passer à `BigInt()` ne sera généralement pas suffisant pour éviter toutes les erreurs. En effet, si la chaîne n'est pas une chaîne de caractères valide pour décrire un nombre entier, c'est une exception `SyntaxError` qui sera levée ; si le nombre n'est pas un entier (c'est notamment le cas de `NaN`), c'est une exception `RangeError` qui sera levée. Si le domaine de la valeur d'entrée est inconnu, on veillera à la valider correctement avant d'utiliser `BigInt()`.

### Passer un nombre à une opération qui utilise un grand entier


```js
const a = BigInt.asIntN(4, 8);
// TypeError: can't convert 8 to BigInt
const b = new BigInt64Array(3).fill(3);
// TypeError: can't convert 3 to BigInt
```



```js
const a = BigInt.asIntN(4, 8n);
const b = new BigInt64Array(3).fill(3n);
```

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

* `BigInt()`
SyntaxError: missing = in const declaration
===========================================

Message
-------
```

SyntaxError: Const must be initalized (Edge)
SyntaxError: missing = in const declaration (Firefox)
SyntaxError: Missing initializer in const declaration (Chrome)
```

Type d'erreur
-------------

`SyntaxError`Quel est le problème ?
----------------------

Une constante est une valeur qui ne peut pas être modifiée par le programme pendant l'exécution. Elle ne peut pas être changée avec une réaffectation ou une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé `const`. Il est également nécessaire de fournir une valeur d'initialisation dans l'instruction où on déclare la constante (ce qui est logique vu qu'on ne peut pas la modifier ensuite).

Exemples
--------

### Valeur d'initialisation manquante

À la différence de `var` ou de `let`, il est nécessaire d'indiquer une valeur lors de la déclaration. Si aucune valeur n'est indiquée, une exception sera levée :


```js
const COLUMNS;
// SyntaxError: missing = in const declaration
```

### Résoudre le problème

On a le choix entre plusieurs options pour résoudre ce problème. Il faut comprendre le rôle de la constante en question.

#### Ajouter une valeur constante

On peut indiquer la valeur de la constante dans la même instruction :


```js
const COLONNES = 80;
```


#### `const`, `let` ou `var` ?

`const` ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à `let` ou une variable globale avec `var`. Ces deux instructions ne nécessitent pas de valeur initiale.


```js
let colonnes;
```

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

* `const`
* `let`
* `var`