recursal/MDN huggingface dataset:
ReferenceError: can't access lexical declaration 'X' before initialization
==========================================================================

Message
-------
```

ReferenceError: Use before delaration (Edge)
ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
ReferenceError: 'x' is not defined (Chrome)
```

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

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

Il y a eu un accès à une variable déclarée avec `let` ou `const` avant que celle-ci ait été initialisée. Cela peut se produire dans n'importe quelle instruction de bloc avec une variable déclarée avec `let` ou `const` et qui est utilisée avant son initialisation.

Exemple
-------

### Exemples invalides

Dans l'exemple qui suit, la variable `toto` est redéclarée dans le bloc avec un second `let` et elle n'est donc pas initialisée.


```js
function test() {
  let toto = 33;
  if (true) {
    let toto = toto + 55;
    // ReferenceError: can't access lexical
    // declaration `toto` before initialization
  }
}
test();
```

### Exemples valides

Afin que `toto` puisse être modifiée au sein de l'instruction `if`, on enlèvera la redéclaration dans ce bloc :


```js
function test() {
  let toto = 33;
  if (true) {
    toto = toto + 55;
  }
}
test();
```

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

* La « zone morte temporelle » (ou TDZ pour « *Temporal Dead Zone* ») et les erreurs avec `let`
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated
================================================================================

Message
-------
```

SyntaxError: Calling delete on expression not allowed in strict mode (Edge)
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
```

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

`SyntaxError`, uniquement en mode strict.

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

Les variables JavaScript ne peuvent pas être supprimées grâce à l'opérateur `delete`. En mode strict, toute tentative de suppression d'une variable lèvera une exception.

L'opérateur `delete` sert uniquement à supprimer des propriétés sur un objet. Les propriétés d'un objet sont « qualifiées » si elles sont configurables.

Contrairement à ce qu'on pourrait penser, l'opérateur `delete` n'a rien à voir avec la libération de la mémoire. La gestion de la mémoire se fait indirectement en cassant les références utilisées. Pour plus d'informations, consulter les pages sur `delete` et la gestion de la mémoire en JavaScript.

Cette erreur ne se produit qu'en mode strict. En mode non-strict, l'opération renvoie simplement `false`.

Exemples
--------

Essayer de supprimer une variable normale avec `delete` ne fonctionne pas, voire lève une exception en mode strict :


```js
"use strict";

var x;

// ...

delete x;

// SyntaxError: applying the 'delete' operator to
// an unqualified name is deprecated
```


Pour libérer le contenu d'une variable, on peut la passer à `null` :


```js
"use strict";

var x;
// ...
x = null;

// x peut être ramassée par le ramasse-miettes
```

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

* `delete`
* La gestion de la mémoire en JavaScript
* TypeError: property "x" is non-configurable and can't be deleted
SyntaxError: missing } after property list
==========================================

Message
-------
```

SyntaxError: Expected '}' (Edge)
SyntaxError: missing } after property list (Firefox)
```

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

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

Il y a une coquille dans le littéral objet utilisé. Cela peut être dû à une accolade manquante ou à une virgule manquante. Il est aussi utile de vérifier que les accolades et les parenthèses sont bien ordonnées. Pour ce type d'erreur, une bonne indentation permet de repérer plus facilement la coquille parmi les lignes de code.

Exemples
--------

### Une virgule oubliée

Il arrive parfois que ce soit une virgule absente dans le littéral qui entraîne cette erreur :


```js
var obj = {
  a: 1,
  b: { maProp: 2 }
  c: 3
};
```


La version correcte correspondante est :


```js
var obj = {
  a: 1,
  b: { maProp: 2 },
  c: 3,
};
```

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

* Les littéraux objets
TypeError: "x" is read-only
===========================

Message
-------
```

TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
TypeError: "x" is read-only (Firefox)
TypeError: 0 is read-only (Firefox)
TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)
TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
```

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

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

La variable globale ou la propriété ne peut pas recevoir de valeur ou être modifiée car elle est en lecture seule (d'un point de vue technique, il s'agit d'une propriété de donnée en lecture seule).

Cette erreur ne se produit qu'avec le mode strict. En mode non-strict, l'affectation est ignorée silencieusement.

Exemples
--------

### Exemples invalides

Les propriétés en lecture seule ne sont pas fréquemment utilisées mais on peut en créer en utilisant les méthodes `Object.defineProperty()` ou `Object.freeze()`.


```js
"use strict";
var obj = Object.freeze({ name: "Elsa", score: 157 });
obj.score = 0; // TypeError

("use strict");
Object.defineProperty(this, "NB\_POUMONS", { value: 2, writable: false });
NB\_POUMONS = 3; // TypeError

("use strict");
var frozenArray = Object.freeze([0, 1, 2]);
frozenArray[0]++; // TypeError
```


Quelques propriétés natives JavaScript sont également en lecture seule. Par exemple, on obtient cette erreur lorsqu'on souhaite redéfinir une constante mathématique.


```js
"use strict";
Math.PI = 4; // TypeError
```


La variable globale `undefined` est également en lecture seule. On ne peut donc pas faire disparaître la fameuse erreur "*undefined is not a function*" avec ce code :


```js
"use strict";
undefined = function () {};
// TypeError: "undefined" is read-only
```

### Exemples valides


```js
"use strict";
var obj = Object.freeze({ name: "Score", points: 157 });
obj = { name: obj.name, points: 0 };
// En changeant d'objet, ça fonctionne

("use strict");
var NB\_POUMONS = 2; // `var` fonctionne
NB\_POUMONS = 3; // ok
```

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

* `Object.defineProperty()`
* `Object.freeze()`
TypeError: invalid 'in' operand "x"
===================================

Message
-------
```

TypeError: Invalid operand to 'in' (Edge)
TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox)
TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)
```

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

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

L'opérateur `in` peut uniquement être utilisé pour vérifier qu'une propriété appartient à un objet. Il ne peut pas être utilisé pour rechercher des caractères dans des chaînes de caractères, des nombres ou dans d'autres types de données en dehors des objets.

Exemples
--------

### Rechercher un texte dans une chaîne de caractères

À la différence de certains langages de programmation (Python par exemple), JavaScript ne permet pas de chercher des textes dans une chaîne de caractères grâce à l'opérateur `in`.


```js
"Coucou" in "Coucou monde";
// TypeError: cannot use 'in' operator to search for 'Coucou' in 'Coucou monde'
```


On utilisera plutôt la méthode `String.prototype.indexOf()` :


```js
"Coucou monde".indexOf("Coucou") !== -1;
// true
```

### `null` ou `undefined` ne fonctionnent pas

Avant d'utiliser `in`, il faut s'assurer que la valeur qu'on inspecte n'est pas `null` ou `undefined`.


```js
var toto = null;
"truc" in toto;
// TypeError: cannot use 'in' operator to search for 'truc' in 'toto" (Chrome)
// TypeError: right-hand side of 'in' should be an object, got null (Firefox)
```


L'opérateur `in` doit être utilisé avec un objet.


```js
var toto = { machin: "bidule" };
"truc" in toto; // false

"PI" in Math; // true
"pi" in Math; // false
```

### Rechercher dans un tableau

Attention lorsqu'on utilise l'opérateur `in` quand on recherche une valeur dans un objet `Array`. L'opérateur `in` vérifie la présence de l'index mais pas la valeur présente à cet index.


```js
var arbres = ["cèdre", "bouleau", "pin", "sapin", "érable"];
3 in arbres; // true
"pin" in arbres; // false
```

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

* L'opérateur `in`
SyntaxError: test for equality (==) mistyped as assignment (=)?
===============================================================

Message
-------
```

Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?
```

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

Uniquement pour Firefox. Un avertissement sous la forme d'une exception `SyntaxError`, généré uniquement si la préférence `javascript.options.strict` vaut `true`.

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

Le code utilise une affectation (`=`) là où on attendrait un test d'égalité (`==`). Afin d'aider au débogage, le moteur JavaScript déclenche des avertissements lorsqu'il détecte ce motif.

Exemples
--------

### Des affectations utilisées au sein d'expressions conditionnelles

Il est conseillé de ne pas utiliser d'affectations simples dans des expressions conditionnelles (comme le test effectué avec `if...else`) car on peut confondre les deux à la lecture du code. Ainsi, on n'utilisera pas la forme suivante :


```js
if (x = y) {
  // do the right thing
}
```


Si on doit effectivement affecter une variable dans une expression conditionnelle, on entourera l'affectation d'une paire de parenthèses supplémentaires afin de montrer qu'on veut bien effectuer une affectation, comme ceci :


```js
if ((x = y)) {
  // exécuter le code
}
```


Autrement (généralement), on veut plutôt utiliser un opérateur de comparaison (`==` ou `===` par exemple) :


```js
if (x == y) {
  // exécuter le code
}
```

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

* `if...else`
* Les opérateurs de comparaison
RangeError: repeat count must be less than infinity
===================================================

Message
-------
```

RangeError: argument out of range (Edge)
RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)
RangeError: Invalid count value (Chrome)
```

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

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

La méthode `String.prototype.repeat()`, qui permet de répéter une chaîne de caractères, a été utilisée avec un argument qui n'est pas compris entre 0 et `Infinity` (exclue) (ce qui correspond à l'intervalle [0, +∞))

La chaîne de caractères crée par cette méthode ne doit pas dépasser la taille maximale d'une chaîne. Cette taille varie selon le moteur JavaScript. Pour Firefox (SpiderMonkey), la taille maximale d'une chaîne de caractères vaut 2^28-1 (`0xFFFFFFF`).

Exemples
--------

### Exemples invalides


```js
"abc".repeat(Infinity); // RangeError
"a".repeat(2 \*\* 28); // RangeError
```

### Exemples valides


```js
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count will be converted to integer)
```

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

* `String.prototype.repeat()`
SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated
=============================================================================

Message
-------
```

SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge)
SyntaxError:
"0"-prefixed octal literals and octal escape sequences are deprecated;
for octal literals use the "0o" prefix instead
```

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

`SyntaxError`, uniquement en mode strict.

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

Les littéraux en base octale et les séquences d'échappement octales sont dépréciées et lèvent une exception `SyntaxError` en mode strict. À partir d'ECMAScript 2015, la syntaxe standard utilise un zéro suivi de la lettre « o » (en minuscule ou en majuscule) (`0o` or `0O)`.

Exemples
--------

### Littéraux en base octale préfixés par 0


```js
"use strict";

03;

// SyntaxError: "0"-prefixed octal literals and octal escape sequences
// are deprecated
```

### Séquences d'échappement en base octale


```js
"use strict";

"\251";

// SyntaxError: "0"-prefixed octal literals and octal escape sequences
// are deprecated
```

### Littéraux valides

Pour former un littéral en base octal, on pourra utiliser un zéro suivi de la lettre « o » :


```js
0o3;
```


Pour former une séquence d'échappement en base octale, on écrira une séquence d'échappement en base hexadécimale :


```js
"\xA9";
```

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

* La grammaire lexicale JavaScript
* Warning: 08/09 is not a legal ECMA-262 octal constant
TypeError: can't define property "x": "obj" is not extensible
=============================================================

Message
-------
```

TypeError: Cannot create property for a non-extensible object (Edge)
TypeError: can't define property "x": "obj" is not extensible (Firefox)
TypeError: Cannot define property: "x", object is not extensible. (Chrome)
```

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

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

La plupart du temps, un objet est extensible, ce qui signifie qu'on peut lui ajouter de nouvelles propriétés. Cependant, dans ce cas, on a utilisé la méthode `Object.preventExtensions()` afin de marquer l'objet comme non-extensible. Celui-ci ne pourra donc pas recevoir de nouvelles propriétés en plus de celles dont il dispose déjà.

Exemples
--------

En mode strict, si on essaie d'ajouter une nouvelle propriété sur un objet non-extensible, on obtient une exception `TypeError`. En mode non-strict, l'ajout de la nouvelle propriété est ignoré silencieusement.


```js
"use strict";

var obj = {};
Object.preventExtensions(obj);

obj.x = "toto";
// TypeError: can't define property "x": "obj" is not extensible
```


Pour le mode strict ete le mode non-strict, un appel à `Object.defineProperty()` déclenchera une exception lorsqu'on utilisera cette méthode pour ajouter une nouvelle propriété à un objet non-extenssible.


```js
var obj = {};
Object.preventExtensions(obj);

Object.defineProperty(obj, "x", { value: "toto" });
// TypeError: can't define property "x": "obj" is not extensible
```


Pour corriger cet erreur, il faut retirer l'appel à `Object.preventExtensions()` pour que l'objet soit extensible, soit ajouter la propriété avant que l'objet devienne non-extensible, soit retirer l'ajout de cette propriété si elle n'est pas nécessaire.


```js
"use strict";

var obj = {};
obj.x = "toto"; // On ajoute la propriété avant de
// bloquer l'ajout d'autres propriétés

Object.preventExtensions(obj);
```

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

* `Object.preventExtensions()`
SyntaxError: missing } after function body
==========================================

Message
-------
```

SyntaxError: Expected '}' (Edge)
SyntaxError: missing } after function body (Firefox)
```

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

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

Il y a une erreur de syntaxe près d'une création de fonction. Dans ce cas, il est préférable de vérifier que les parenthèses et accolades fermantes sont bien présentes et dans le bon ordre. Indenter et formater le code peut vous aider à vous y retrouver parmi les éventuels différents niveaux d'imbrication.

Exemples
--------

### Oubli d'une accolade fermante

La plupart du temps, il s'agit d'une accolade manquante dans le code de la fonction :


```js
var charge = function() {
  if (soleil) {
    utiliserPanneauSolaire();
  } else {
    utiliserVelo();
};
```


La forme correcte est :


```js
var charge = function () {
  if (soleil) {
    utiliserPanneauSolaire();
  } else {
    utiliserVelo();
  }
};
```


Une erreur de ce type peut être moins visible lorsqu'on utilise les fonctions qui sont appelées immédiatement, les fermetures ou d'autres formes qui utilisent de nombreuses parenthèses et/ou accolades comme par exemple :


```js
(function() { if (true) { return false; } );
```


Généralement, mettre en forme et vérifier l'indentation permet de repérer ces erreurs.


```js
(function () {
  if (true) {
    return false;
  }
});
```

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

* Les fonctions
TypeError: can't redefine non-configurable property "x"
=======================================================

Message
-------
```

TypeError: Cannot modify non-writable property {x} (Edge)
TypeError: can't redefine non-configurable property "x" (Firefox)
TypeError: Cannot redefine property: "x" (Chrome)
```

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

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

On essaie de redéfinir une propriété alors que celle-ci est non-configurable. L'attribut `configurable` permet d'indiquer si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés. Généralement, les propriétés d'un objet créées avec un initialisateur d'objet sont configurables. Cependant, lorsqu'on utilise la méthode `Object.defineProperty()`, la propriété n'est pas configurable par défaut.

Exemples
--------

### Propriétés non-configurables créées avec `Object.defineProperty()`

La méthode `Object.defineProperty()` crée des propriétés non-configurables si on n'indique pas le contraire :


```js
var obj = Object.create({});
Object.defineProperty(obj, "toto", { value: "machin" });

Object.defineProperty(obj, "toto", { value: "bidule" });
// TypeError: can't redefine non-configurable property "toto"
```


Si on veut pouvoir redéfinir la propriété "toto" dans la suite du code, il faudra la créer comme étant configurable.


```js
var obj = Object.create({});
Object.defineProperty(obj, "toto", { value: "machin", configurable: true });
Object.defineProperty(obj, "toto", { value: "bidule", configurable: true });
```

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

* [[Configurable]]
* `Object.defineProperty()`
RangeError: BigInt division by zero
===================================

L'exception JavaScript *"BigInt division by zero"* se produit lorsqu'une valeur `BigInt` est divisée par `0n`.

Message
-------
```

RangeError: Division by zero (moteur JavaScript basé sur V8)
RangeError: BigInt division by zero (Firefox)
RangeError: 0 is an invalid divisor value. (Safari)
```

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

`RangeError`.

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

Le diviseur utilisé pour une division ou le calcul d'un reste est `0n`. Pour les valeurs de type `Number`, la division arithmétique par 0 produit l'infini (`Infinity`), mais il n'existe pas de telle valeur infinie avec les grands entiers et une erreur est donc déclenchée. Vérifiez si le diviseur vaut `0n` avant d'effectuer la division.

Exemples
--------

### Division par `0n`


```js
const a = 1n;
const b = 0n;
const quotient = a / b;
// RangeError: BigInt division by zero
```


À la place, on vérifiera d'abord si le diviseur vaut `0n`, puis on produira une erreur avec un message plus spécifique ou on fournira un résultat différent avec une valeur comme `Infinity` ou `undefined`.


```js
const a = 1n;
const b = 0n;
const quotient = b === 0n ? undefined : a / b;
```

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

* `BigInt`
* Division
* Opérateur du reste
RangeError: BigInt negative exponent
====================================

L'exception JavaScript *"BigInt negative exponent"* se produit lorsqu'une valeur `BigInt` est élevée à une puissance négative exprimée avec une valeur `BigInt`.

Message
-------
```

RangeError: Exponent must be positive (moteur JavaScript basé sur V8)
RangeError: BigInt negative exponent (Firefox)
RangeError: Negative exponent is not allowed (Safari)
```

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

`RangeError`.

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

L'exposant utilisé pour une opération d'exponentiation doit être positif. Un exposant négatif conduirait à prendre un inverse de la base, le résultat sera alors compris entre `-1` et `1` pour presque tous les cas, ce qui finirait arrondi en `0n`. Pour éviter de tels problèmes, les exposants négatifs ne sont pas autorisés. Vérifiez le signe de l'exposant avant de réaliser l'exponentiation.

Exemples
--------

### Utiliser un grand entier négatif comme exposant


```js
const a = 1n;
const b = -1n;
const c = a \*\* b;
// RangeError: BigInt negative exponent
```


À la place, on vérifiera au préalable si l'exposant est négatif, si c'est le cas, on produira un message d'erreur plus spécifique ou on utilisera une valeur alternative comme `0n` ou `undefined`.


```js
const a = 1n;
const b = -1n;
const quotient = b >= 0n ? a \*\* b : 0n;
```

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

* `BigInt`
* Exponentiation
ReferenceError: deprecated caller or arguments usage
====================================================

Message
-------
```

TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge)
Warning: ReferenceError: deprecated caller usage (Firefox)
Warning: ReferenceError: deprecated arguments usage (Firefox)
TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
```

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

Un avertissement uniquement affiché en mode strict qui prend la forme d'une `ReferenceError`. L'exécution du script JavaScript n'est pas interrompue.

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

En mode strict, les propriétés `Function.caller` et/ou `Function.arguments` sont utilisées alors qu'elles ne devraient pas l'être. Ces propriétés sont dépréciées car elles font fuiter des informations sur l'appelant de la fonction et ne sont pas standards. De plus, ces propriétés rendent certaines optimisations plus complexe et peuvent nuire aux performances.

Exemples
--------

### Utilisation de `function.caller` ou de `arguments.callee.caller`

`Function.caller` et `arguments.callee.caller` sont dépréciées (se référer aux articles de la référence pour plus d'informations).


```js
"use strict";

function myFunc() {
  if (myFunc.caller == null) {
    return "La fonction a été appelée depuis la portée globale !";
  } else {
    return "L'appelant est " + myFunc.caller;
  }
}

myFunc();
// Warning: ReferenceError: deprecated caller usage
// "La fonction a été appelée depuis la portée globale !"
```

### `Function.arguments`

`Function.arguments` est dépréciée (se référer à l'article sur cette propriété pour plus d'informations).


```js
"use strict";

function f(n) {
  g(n - 1);
}

function g(n) {
  console.log("before: " + g.arguments[0]);
  if (n > 0) {
    f(n);
  }
  console.log("after: " + g.arguments[0]);
}

f(2);

console.log("returned: " + g.arguments);
// Warning: ReferenceError: deprecated arguments usage
```

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

* Les fonctionnalités obsolètes et dépréciées
* Le mode strict
* `Function.arguments`
* `Function.caller` and `arguments.callee.caller`
TypeError: "x" is (not) "y"
===========================

Message
-------
```

TypeError: Unable to get property {x} of undefined or null reference (Edge)
TypeError: "x" is (not) "y" (Firefox)
```


Exemples :
```

TypeError: "x" is undefined
TypeError: "x" is null
TypeError: "undefined" is not an object
TypeError: "x" is not an object or null
TypeError: "x" is not a symbol
```

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

`TypeError`.

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

Un type inattendu a été rencontré. Cela se produit la plupart du temps avec les valeurs `undefined` ou `null`.

Certaines méthodes comme `Object.create()` ou `Symbol.keyFor()` ont des contraintes sur le type de valeur qui peut être passé en argument.

Exemples
--------

### Exemples invalides


```js
// undefined et null : des valeurs
// sur lesquelles la méthode substring
// ne fonctionnera pas
var toto = undefined;
toto.substring(1); // TypeError: toto is undefined

var toto = null;
toto.substring(1); // TypeError: toto is null

// Certaines méthodes nécessitent une valeur
// d'un type spécifique
var toto = {};
Symbol.keyFor(toto); // TypeError: toto is not a symbol

var toto = "truc";
Object.create(toto); // TypeError: "toto" is not an object or null
```

### Résoudre le problème

Pour résoudre ce problème et écarter les cas où la valeur vaut `undefined`, on peut par exemple utiliser l'opérateur `typeof`.


```js
if (typeof toto !== "undefined") {
  // Désormais, on sait que toto est bien
  // défini et on peut poursuivre.
}
```

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

* `undefined`
* `null`