recursal/MDN huggingface dataset:
TypeError: Reduce of empty array with no initial value
======================================================

Message
-------
```

TypeError: reduce of empty array with no initial value
```

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

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

En JavaScript, il existe plusieurs fonctions qui permettent de réduire un tableau :

* `Array.prototype.reduce()`, `Array.prototype.reduceRight()` ainsi que
* `TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()`).

Ces fonctions utilisent un argument optionnel `valeurInitiale` (qui sera utilisée comme premier argument pour le premier appel du `callback`). Toutefois, si aucune valeur initiale explicite est fournie, la méthode utilisera le premier élément de l'objet `Array` / `TypedArray` comme valeur initiale. Cette exception est déclenchée lorsqu'on souhaite réduire un tableau vide car aucune valeur initiale n'a été fournie.

Exemples
--------

### Exemples invalides

Ce problème se produit lorsqu'on combine une méthode de filtrage (`Array.prototype.filter()`, `TypedArray.prototype.filter()`) qui retire tous les éléments du tableau. Si on applique ensuite une réduction, il n'y aura pas de valeur initiale.


```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x > 0) // cet appel retire tous les éléments
  .reduce((x, y) => x + y); // aucun ne peut alors être utilisé comme valeur initiale
```


Cela peut également se produire si on utilise un sélecteur avec une coquille ou que la liste contient un nombre d'élément inattendu:


```js
var names = document.getElementsByClassName("names");
var name_list = Array.prototype.reduce.call(
  names,
  (acc, name) => acc + ", " + name,
);
```

### Exemples valides

On peut résoudre ces problèmes de deux façons.

On peut fournir une valeur initiale qui soit l'élément neutre de la réduction (par exemple 0 si on additionne, 1 si on multiplie ou la chaîne vide si on concatène du texte).


```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x > 0) // removes all elements
  .reduce((x, y) => x + y, 0); // the initial value is the neutral element of the addition
```


On peut également gérer le cas où le tableau est vide, avant d'appeler `reduce` ou dans le *callback* après avoir ajouté une valeur initiale.


```js
var names = document.getElementsByClassName("names");

var nameList1 = "";
if (names1.length >= 1)
  nameList1 = Array.prototype.reduce.call(
    names,
    (acc, name) => acc + ", " + name,
  );
// nameList1 == "" lorsque names est vide

var nameList2 = Array.prototype.reduce.call(
  names,
  (acc, name) => {
    if (acc == "")
      // la valeur initiale
      return name;
    return acc + ", " + name;
  },
  "",
);
// nameList2 == "" lorsque names est vide
```

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

* `Array.prototype.reduce()`
* `Array.prototype.reduceRight()`
* `TypedArray.prototype.reduce()`
* `TypedArray.prototype.reduceRight()`
* `Array`
* `TypedArray`
* `Array.prototype.filter()`
* `TypedArray.prototype.filter()`
TypeError: "x" is not a constructor
===================================

Message
-------
```

TypeError: Object doesn't support this action (Edge)
TypeError: "x" is not a constructor

TypeError: Math is not a constructor
TypeError: JSON is not a constructor
TypeError: Symbol is not a constructor
TypeError: Reflect is not a constructor
TypeError: Intl is not a constructor
TypeError: SIMD is not a constructor
TypeError: Atomics is not a constructor
```

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

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

Une variable ou un objet a été utilisé comme un constructeur alors que cet objet ou cette variable n'est pas un constructeur. Pour plus d'informations sur les constructeurs, voir la page sur l'opérateur `new`.

De nombreux objets globaux tels que `String` ou `Array`, sont constructibles avec `new`. Cependant, d'autres objets globaux ne le sont pas (leurs propriétés et méthodes sont statiques). Les objets standards natifs suivants ne sont pas des constructeur : `Math`, `JSON`, `Symbol`, `Reflect`, `Intl`, `SIMD`, `Atomics`.

Les fonctions génératrices ne peuvent pas non plus être utilisées comme des constructeurs.

Exemples
--------

### Exemples invalides


```js
var Voiture = 1;
new Voiture();
// TypeError: Voiture is not a constructor

new Math();
// TypeError: Math is not a constructor

new Symbol();
// TypeError: Symbol is not a constructor

function\* f() {}
var obj = new f();
// TypeError: f is not a constructor
```

### Créer un constructeur `voiture`

Imaginons qu'on veuille représenter des voitures sous forme d'objets. On appellera ce type `voiture` et on lui ajoutera des propriétés pour le fabricant, le modèle et l'année. Pour cela, on pourra écrire la fonction suivante :


```js
function Voiture(fabriquant, modèle, année) {
  this.fabriquant = fabriquant;
  this.modèle = modèle;
  this.année = année;
}
```


On peut désormais créer un objet `maVoiture` comme ceci :


```js
var maVoiture = new Voiture("Renault", "Twingo", 2006);
```

### Avec les promesses

Lorsqu'on renvoie une promesse immédiatement tenue ou rompue, il n'est pas nécessaire d'utiliser `new Promise()` pour la manipuler. Il faut plutôt utiliser les méthodes statiques `Promise.resolve()` ou `Promise.reject()` :


```js
// Dans ce cas on aura une exception
// "this is not a constructor"
return new Promise.resolve(true);
```



```js
// Cette formulation fonctionne mais
// est inutilement longue
return new Promise((resolve, reject) => {
  resolve(true);
});

// On pourra autrement utiliser les
// méthodes statiques
return Promise.resolve(true);
return Promise.reject(false);
```

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

* constructor
* L'opérateur `new`
RangeError: radix must be an integer
====================================

Message
-------
```

RangeError: invalid argument (Edge)
RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)
RangeError: toString() radix argument must be between 2 and 36 (Chrome)
```

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

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

C'est le paramètre utilisé avec la méthode `Number.prototype.toString()` ou avec la méthode `BigInt.prototype.toString()` pour indiquer la base de conversion qui est en cause. Ce paramètre, optionnel, doit être un nombre entier, compris entre 2 et 36 qui inique la base du système numérique dans lequel on veut représenter les valeurs numériques.

Pourquoi limiter la base à 36 ? Lorsqu'une base est supérieure à 10, on utilise les caractères de l'alphabet pour représenter les chiffres. Or, l'alphabet latin ne possède que 26 caractères. En utilisant donc les 10 chiffres arabes et ces caractères, on possède 36 caractères pour représenter les chiffres d'un nombre.

Généralement, on emploie cette méthode avec des bases fréquemment utilisées :

* 2 pour les nombres binaires,
* 8 pour les nombres octaux,
* 10 pour les nombres décimaux,
* 16 pour les nombres hexadécimaux.
Examples
--------

### Exemples invalides


```js
(42).toString(0);
(42).toString(1);
(42).toString(37);
(42).toString(150);
// On ne peut pas utiliser une telle
// chaîne pour du formatage :
(12071989).toString("MM-dd-yyyy");
```

### Exemples valides


```js
(42).toString(2); // "101010" (binary)
(13).toString(8); // "15" (octal)
(0x42).toString(10); // "66" (decimal)
(100000).toString(16); // "186a0" (hexadecimal)
```

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

* `Number.prototype.toString()`
TypeError: More arguments needed
================================

Message
-------
```

TypeError: argument is not an Object and is not null (Edge)
TypeError: Object.create requires at least 1 argument, but only 0 were passed
TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed
TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed
```

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

`TypeError`.

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

Lors de l'appel de la fonction, il y a eu une erreur due au manque d'argument. La fonction doit recevoir plus de paramètres afin de pouvoir fonctionner.

Exemples
--------

La méthode `Object.create()` nécessite au moins un argument et `Object.setPrototypeOf()` requiert deux paramètres :


```js
var obj = Object.create();
// TypeError: Object.create requires more than 0 arguments

var obj = Object.setPrototypeOf({});
// TypeError: Object.setPrototypeOf requires more than 1 argument
```


On peut corriger cet exemple en utilisant `null` comme prototype :


```js
var obj = Object.create(null);

var obj = Object.setPrototypeOf({}, null);
```

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

* Les fonctions
SyntaxError: function statement requires a name
===============================================

Message
-------
```

Syntax Error: Expected identifier (Edge)
SyntaxError: function statement requires a name [Firefox]
SyntaxError: Unexpected token ( [Chrome]
```

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

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

Une déclaration de fonction présente dans le code requiert un nom. Il faut alors vérifier la façon dont la fonction est définie et s'il est nécessaire de lui fournir un nom ou si la fonction en question est une expression de fonction, une fonction immédiatement invoquée ou si le code de la fonction est simplement bien placé dans son contexte.

Exemples
--------

### Déclaration / Expression

Une déclaration de fonction requiert un nom. Le fragment de code suivant ne fonctionnera pas :


```js
function () {
  return 'Coucou monde :)';
}
// SyntaxError: function statement requires a name
```


On peut utiliser une expression de fonction à la place :


```js
var salutations = function () {
  return "Coucou monde :)";
};
```


Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour :


```js
(function () {})();
```

### Fonctions étiquetées

Si vous utilisez des fonctions étiquetées, il faut toujours fournir un nom après le mot-clé `function`. Le code suivant ne fonctionnera pas :


```js
function Greeter() {
  german: function () {
    return "Moin";
  }
}
// SyntaxError: function statement requires a name
```


En revanche, ceci fonctionnera :


```js
function Greeter() {
  german: function g() {
    return "Moin";
  }
}
```

### Méthodes d'un objet

Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l'objet. Dans ce cas, la syntaxe sans le nom après le mot-clé `function` sera valide :


```js
var greeter = {
  german: function () {
    return "Moin";
  },
};
```

### Syntaxe et fonctions de rappel (*callbacks*)

Lorsqu'on utilise les *callbacks*, il est facile de s'emmêler les pinceaux entre les parenthèses et les virgules :


```js
promise.then(
  function() {
    console.log("success");
  });
  function() {
    console.log("error");
}
// SyntaxError: function statement requires a name
```


La forme correcte serait :


```json
promise.then(
  function() {
    console.log("success");
  },
  function() {
    console.log("error");
  }
);
```

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

* Les fonctions dans le guide JavaScript
* Les déclarations de fonction
* Les expressions de fonction
* Les fonctions immédiatement invoquées (ou *IIFE* en anglais)
* `label`
TypeError: invalid 'instanceof' operand 'x'
===========================================

Message
-------
```

TypeError: invalid 'instanceof' operand "x" (Firefox)
TypeError: "x" is not a function (Firefox)
TypeError: Right-hand side of 'instanceof' is not an object (Chrome)
TypeError: Right-hand side of 'instanceof' is not callable (Chrome)
```

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

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

L'opérateur `instanceof` attend un opérande droit qui soit un objet constructeur, c'est-à-dire un objet possédant une propriété `prototype` et qui puisse être appelé.

Exemples
--------


```js
"test" instanceof ""; // TypeError: invalid 'instanceof' operand ""
42 instanceof 0; // TypeError: invalid 'instanceof' operand 0

function Toto() {}
var f = Toto(); // Toto() est appelé et renvoie undefined
var x = new Toto();

x instanceof f; // TypeError: invalid 'instanceof' operand f
x instanceof x; // TypeError: x is not a function
```


Pour corriger ces erreurs, il faut remplacer l'opérateur `instanceof` avec l'opérateur `typeof` ou s'assurer que l'opérande droit est la fonction et non le résultat de son évaluation.


```js
typeof "test" == "string"; // true
typeof 42 == "number"; // true

function Toto() {}
var f = Toto; // On n'appelle pas Toto.
var x = new Toto();

x instanceof f; // true
x instanceof Toto; // true
```

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

* L'opérateur `instanceof`
* L'opérateur `typeof`
SyntaxError: "use strict" not allowed in function with "x" parameter
====================================================================

Message
-------
```

Edge :
Cannot apply strict mode on functions with non-simple parameter list

Firefox :
SyntaxError: "use strict" not allowed in function with default parameter
SyntaxError: "use strict" not allowed in function with rest parameter
SyntaxError: "use strict" not allowed in function with destructuring parameter

Chrome :
SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list
```

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

`SyntaxError`.

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

Une directive `"use strict"` apparaît au début d'une fonction qui possède l'un des paramètres suivants :

* Des paramètres par défaut
* Des paramètres du reste
* Des paramètres décomposés

Selon la spécification ECMAScript, une directive `"use strict"` ne peut pas être utilisée pour de telles fonctions.

Exemples
--------

### Déclaration de fonction

Dans l'exemple qui suit, la fonction `somme` possède deux paramètres par défaut `a=1` et `b=2`.


```js
function somme(a = 1, b = 2) {
  // SyntaxError: "use strict" not allowed in function with default parameter
  "use strict";
  return a + b;
}
```


Si on veut que la fonction soit en mode strict et que le script entier ou que la fonction englobante peut être en mode strict, il suffira de déplacer l'instruction `"use strict"` en dehors du corps de la méthode.


```js
"use strict";
function somme(a = 1, b = 2) {
  return a + b;
}
```

### Expression de fonction

Il est également possible d'utiliser les expressions de fonction pour résoudre ce problème :


```js
var somme = function somme([a, b]) {
  // SyntaxError: "use strict" not allowed in function with destructuring parameter
  "use strict";
  return a + b;
};
```


On peut convertir le fragment de code précédent avec l'expression suivante :


```js
var somme = (function () {
  "use strict";
  return function somme([a, b]) {
    return a + b;
  };
})();
```

### Fonction fléchée

Si on a une fonction fléchée qui doit accéder à la variable `this` on peut utiliser une fonction fléchée comme fonction englobante :


```js
var callback = (...args) => {
  // SyntaxError: "use strict" not allowed in function with rest parameter
  "use strict";
  return this.run(args);
};
```


This can be converted into following expression.


```js
var callback = (() => {
  "use strict";
  return (...args) => {
    return this.run(args);
  };
})();
```

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

* Le mode strict
* L'instruction function
* Les expressions de fonction
* Les paramètres par défaut
* Les paramètres du reste
* Les paramètres décomposés
TypeError: X.prototype.y called on incompatible type
====================================================

Message
-------
```

TypeError: 'this' is not a Set object (Edge)
TypeError: Function.prototype.toString called on incompatible object (Firefox)
TypeError: Function.prototype.bind called on incompatible target (Firefox)
TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)
TypeError: Bind must be called on a function (Chrome)
```

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

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

Lorsque cette erreur est levée, cela signifie qu'une fonction (d'un objet donné) est appelé avec une valeur `this` qui ne correspond pas au type attendu par la fonction.

Cela peut se produire lorsqu'on utilise les méthodes `Function.prototype.call()` ou `Function.prototype.apply()` et qu'on fournit un argument `this` dont le type n'est pas celui attendu.

Cela peut également se produire quand on fournit une fonction (sous la forme d'un objet) comme argument d'une autre fonction. Dans ce cas, l'objet ne sera pas capturé comme valeur `this` pour la fonction. Pour contourner ce problème, on peut fournir une fonction lambda qui effectue l'appel ou utiliser la fonction `Function.prototype.bind()` afin que `this` soit l'objet attendu.

Exemples
--------

### Exemples invalides


```js
var monSet = new Set();
["truc", "bidule"].forEach(monSet.add);
// monSet.add est une fonction mais
// "monSet" n'est pas capturé en tant que this.

var maFonction = function () {
  console.log(this);
};
["truc", "bidule"].forEach(maFonction.bind);
// maFonction.bind est une fonction
// mais "maFonction" n'est pas capturé en tant
// que this.
```

### Exemples valides


```js
var monSet = new Set();
["truc", "bidule"].forEach(monSet.add.bind(monSet));
// Cela fonctionne car on lie "monSet" avec this.

var maFonction = function () {
  console.log(this);
};
["truc", "bidule"].forEach((x) => maFonction.bind(x));
// Cela fonctionne car on utilise
// la fonction "bind" ce qui permet de
// créer une fonction lambda qui propage
// l'argument.
```

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

* `Function.prototype.call()`
* `Function.prototype.apply()`
* `Function.prototype.bind()`
SyntaxError: for-in loop head declarations may not have initializers
====================================================================

Message
-------
```

SyntaxError: for-in loop head declarations cannot have an initializer (Edge)
SyntaxError: for-in loop head declarations may not have initializers (Firefox)
SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
```

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

`SyntaxError`, uniquement en mode strict.

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

L'en-tête d'une boucle `for...in` contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé en mode strict (et ignoré en mode non-strict).

Exemples
--------

Cet exemple déclenchera une exception `SyntaxError` :


```js
"use strict";

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

for (var i = 0 in obj) {
  console.log(obj[i]);
}

// SyntaxError: for-in loop head declarations may not have initializers
```

### Boucle for-in valide

On peut retirer l'initialisateur de l'en-tête de la boucle :


```js
"use strict";

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

for (var i in obj) {
  console.log(obj[i]);
}
```

### Parcours d'un tableau

Il ne faut pas utiliser de boucle `for...in` pour parcourir un tableau (`Array`). Peut-être souhaitiez-vous utiliser une boucle `for` pour parcourir le tableau ? Cette boucle `for` permet également d'utiliser un initialisateur :


```js
var arr = ["a", "b", "c"];

for (var i = 2; i < arr.length; i++) {
  console.log(arr[i]);
}

// "c"
```

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

* `for...in`
* `for...of` interdit également d'utiliser un initialisateur en mode strict et non-strict
* `for` permet de définir un initialisateur lors de l'itération et doit être privilégié pour parcourir un tableau
RangeError: invalid array length
================================

Message
-------
```

RangeError: Array length must be a finite positive integer (Edge)
RangeError: invalid array length (Firefox)
RangeError: Invalid array length (Chrome)
RangeError: Invalid array buffer length (Chrome)
```

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

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

Deux cas de figures peuvent causer cette erreur :

* La création d'un tableau `Array` ou `ArrayBuffer` dont la longueur est négative ou supérieure ou égale à 2^32
* La modification de la propriété `Array.length` pour que celle-ci ait une valeur négative ou supérieure ou égale à 2^32.

Les tailles des objets `Array` et `ArrayBuffer` sont limitées car leurs longueurs (`length`) sont représentées par des entiers non-signés sur 32 bits. Ces valeurs sont donc nécessairement comprises dans l'intervalle allant de 0 à 2^32-1.

Si vous utilisez le constructeur pour `Array`, il est probable que vous souhaitiez utiliser la notation littérale plutôt que le constructeur. En effet, le premier argument de ce constructeur correspond à la longueur du tableau.

Sinon, vous pouvez réduire la longueur utilisée afin que celle-ci soit dans l'intervalle valide avant de l'utiliser pour une telle création ou modification.

Exemples
--------

### Exemples invalides


```js
new Array(Math.pow(2, 40));
new Array(-1);
new ArrayBuffer(Math.pow(2, 32));
new ArrayBuffer(-1);

let a = [];
a.length = a.length - 1; // set -1 to the length property

let b = new Array(Math.pow(2, 32) - 1);
b.length = b.length + 1; // set 2^32 to the length property
```

### Exemples valides


```js
[Math.pow(2, 40)][-1]; // [ 1099511627776 ] // [ -1 ]
new ArrayBuffer(Math.pow(2, 32) - 1);
new ArrayBuffer(0);

let a = [];
a.length = Math.max(0, a.length - 1);

let b = new Array(Math.pow(2, 32) - 1);
b.length = Math.min(0xffffffff, b.length + 1);

// 0xffffffff est la notation hexadécimale
// pour 2^32 - 1
// ce qu'on peut également écrire (-1 >>> 0)
```

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

* `Array`
* `Array.length`
* `ArrayBuffer`
SyntaxError: missing ; before statement
=======================================

Message
-------
```

SyntaxError: Expected ';' (Edge)
SyntaxError: missing ; before statement (Firefox)
```

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

`SyntaxError`.

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

Un point-virgule est absent quelque part. En JavaScript, les instructions doivent se terminer par des points-virgules. Certaines de ces instructions sont traitées par l'insertion automatique de point-virgule (*ASI* pour *Automatic Semicolon Insertion)*, mais pour le code qui provoque l'erreur, un point-virgule est nécessaire afin que le moteur JavaScript puisse analyser le code source correctement.

La plupart du temps, cette erreur est la conséquence d'une autre erreur : ne pas « fermer » les chaînes de caractères correctement ou utiliser `var` de façon incorrecte. Il peut également y avoir trop de parenthèses à un endroit. Lorsque cette erreur apparaît, faites attention à la syntaxe du code environnant.

Exemples
--------

### Les chaînes laissées ouvertes

Cette erreur est parfois simplement provoquée par une chaîne dont les quotes ne sont pas échappées correctement ou qui ne sont pas correctement délimitées. Le moteur JavaScript s'attend donc à trouver la fin de la chaîne. Par exemple :


```js
var toto = 'Ouvrir l'œil';
// SyntaxError: missing ; before statement
```


Pour éviter cela, on pourra utiliser des doubles quotes ou échapper l'apostrophe :


```js
var toto = "Ouvrir l'œil";
var toto = "Ouvrir l'œil";
```

### Déclarer des propriétés avec `var`

On **ne peut pas** déclarer de propriétés sur un objet ou un tableau avec une déclaration `var`.


```js
var obj = {};
var obj.toto = "coucou"; // SyntaxError missing ; before statement

var array = [];
var array[0] = "monde"; // SyntaxError missing ; before statement
```


Pour éviter cela, on n'utilisera pas le mot-clé `var` qui est inutile dans ces cas :


```js
var obj = {};
obj.toto = "coucou";

var array = [];
array[0] = "monde";
```

### Mauvais mots-clés

Il peut arriver, notamment lorsqu'on provient d'un autre langage de programmation, d'utiliser des mots-clés qui n'ont pas du tout le même sens en JavaScript :


```js
def print(info){
  console.log(info);
}; // SyntaxError missing ; before statement
```


À la place de `def`, on utilisera le mot-clé `function` :


```js
function print(info) {
  console.log(info);
}
```

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

* L'insertion automatique de points-virgules
* Les instructions JavaScript