recursal/MDN huggingface dataset:
SyntaxError: unterminated string literal
========================================

Message
-------
```

SyntaxError: Unterminated string constant (Edge)
SyntaxError: unterminated string literal (Firefox)
```

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

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

Une chaîne de caractères (`String`) n'est pas bien délimitée quelque part. Les littéraux de chaînes de caractères doivent être délimités par des simples quotes (') ou par des doubles quotes ("). Les séquences d'échappement permet de représenter dans ces chaînes de caractères. Pour réparer cette erreur :

* Vérifiez que la chaîne est bien délimitée au début et à la fin par des doubles quotes ou par des simples quotes,
* Vérifiez que les caractères spéciaux de la chaîne ont bien été échappés,
* Vérifiez que le littéral est bien découpé pour gérer plusieurs lignes (si c'est le cas).
Exemples
--------

### Gérer plusieurs lignes

En JavaScript, on ne peut pas écrire une chaîne simple sur plusieurs lignes comme ceci :


```js
var longString = "This is a very long string which needs
                  to wrap across multiple lines because
                  otherwise my code is unreadable.";
// SyntaxError: unterminated string literal
```


Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser :

* L'opérateur +,
* Une barre oblique inversée ("\")
* Des littéraux de gabarits

Voici la première variante avec l'opérateur de concaténation :


```js
var longString =
  "This is a very long string which needs " +
  "to wrap across multiple lines because " +
  "otherwise my code is unreadable.";
```


Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) :


```js
var longString =
  "This is a very long string which needs \
to wrap across multiple lines because \
otherwise my code is unreadable.";
```


On pourra également utiliser les littéraux de gabarits qui sont pris en charge par les environnement ECMAScript 2015 :


```js
var longString = `This is a very long string which needs
 to wrap across multiple lines because
 otherwise my code is unreadable.`;
```

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

* `String`
* Les littéraux de gabarits
SyntaxError: missing variable name
==================================

Message
-------
```

SyntaxError: missing variable name (Firefox)
SyntaxError: Unexpected token = (Chrome)
```

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

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

Il manque un nom pour une variable. Cela est probablement dû à une erreur de syntaxe dans le code. Peut-être qu'une variable est placée au mauvais endroit ou peut-être qu'il manque un nom car on n'a pas trouvé de nom pertinent… (ce qui est souvent assez difficile).

Exemples
--------

### Absence d'un nom pour une variable


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


Il est souvent compliqué de trouver le bon nom pour une variable…


```js
var àDéfautDeMieux = "toto";
```

### Les mots-clés réservés ne peuvent pas être utilisés comme noms de variables

Quelques mots-clés sont réservés et ne peuvent pas être utilisés comme noms de variable :


```js
var debugger = "zuuuuut";
// SyntaxError: missing variable name
```

### Déclarer plusieurs variables

Attention aux virgules lorsqu'on déclare plusieurs variables… Y a-t-il plus de virgules que nécessairee ? Une virgule est-elle utilisée à la place d'un point-virgule ?


```js
var x, y = "toto",
var x, = "toto"

var un = document.getElementById('un'),
var deux = document.getElementById('deux'),

// SyntaxError: missing variable name
```


Voici une version corrigée :


```js
var x,
  y = "toto";
var x = "toto";

var un = document.getElementById("un");
var deux = document.getElementById("deux");
```

### Tableaux

Pour former un littéral de tableau (`Array`), il est nécessaire d'ajouter des crochets autour des valeurs des éléments. Le fragment de code suivant ne fonctionnera pas :


```js
var arr = 1,2,3,4,5;
// SyntaxError: missing variable name
```


Voici la forme équivalente correcte :


```js
var arr = [1, 2, 3, 4, 5];
```

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

* Choisir de bons noms de variable (en anglais)
* `var`
* Guide JavaScript : Les déclarations de variable
SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
===================================================================================

Message
-------
```

Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead

Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead
```

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

Un avertissement prenant la forme d'une exception `SyntaxError`. L'exécution du code JavaScript n'est pas interrompue.

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

Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de source (*source map*) dans le code JavaScript.

Il arrive souvent que les fichiers sources JavaScript soient combinés et minifiés afin que le transfert depuis le serveur vers le client soit plus efficace. Grâce aux correspondances de source (ou *source maps*), le débogueur peut utiliser les sources des fichiers correspondants aux fichiers minifiés.

La spécification sur cet outil a évolué car il existait un conflit de syntaxe avec IE (après `//@cc_on`, la correspondance était interprétée comme un test conditionnel de compilation du moteur JScript). Ce commentaire de compilation conditionnelle pour IE est peu connu mais son existence entraînait des erreurs avec jQuery et d'autres bibliothèques.

Exemples
--------

### Syntaxe dépréciée

La syntaxe utilisant l'arobase (@) est dépréciée :


```js
//@ sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
```

### Syntaxe standard

Il faut utiliser le dièse (#) :


```js
//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
```


Autrement, on peut indiquer la correspondance dans un en-tête `SourceMap` (en-US) pour servir le fichier JavaScript afin d'éviter tout commentaire :


```js
X-SourceMap: /path/to/file.js.map
```

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

* Comment utiliser les *source map* – Documentation des outils Firefox
* Introduction to source maps – HTML5 rocks
* `SourceMap` (en-US)
Warning: unreachable code after return statement
================================================

Message
-------
```

Warning: unreachable code after return statement (Firefox)
```

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

Avertissement

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

Ce problème peut avoir deux origines :

* Une expression a été utilisée après l'instruction `return`
* Une instruction `return` a été utilisée sans point virgule mais une expression suivait cette instruction.

Lorsqu'une expression existe après une instruction `return` valide, un avertissement est produit pour alerter qu'une portion du code ne peut pas être atteinte et ne sera donc jamais lue et exécutée.

Pourquoi est-il préférable d'ajouter des points-virgules après les instructions `return` ? Si on utilise une instruction `return` sans point-virgule, cela peut créer une ambiguïté : est-ce que le développeur souhaite que le code qui suit sur la ligne d'après soit exécuté ou non ? L'avertissement relève cette ambiguïté afin de mieux la percevoir pour la lever.

Les avertissements ne seront pas affichés pour les `return` sans point-virgule si ces instructions suivent :

* `throw`
* `break`
* `var`
* `function`
Exemples
--------

### Exemples invalides


```js
function f() {
  var x = 3;
  x += 4;
  return x; // return permet de finir la fonction sur le champ
  x -= 3; // Cette ligne ne sera jamais lue donc exécutée
}

function f() {
  return; // Cette instruction est traitée `return;`
  3 + 4; // La fonction termine et cette ligne n'est jamais traitée
}
```

### Exemples valides


```js
function f() {
  var x = 3;
  x += 4;
  x -= 3;
  return x; // OK : return est après
  // toutes les autres instructions
}

function f() {
  return 3 + 4; // OK : un return sans point-virgule
  // avec une expression sur la même ligne
}
```

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

* L'ajout automatique de point-virgule
RangeError: precision is out of range
=====================================

Message
-------
```

RangeError: The number of fractional digits is out of range (Edge)
RangeError: The precision is out of range (Edge)
RangeError: precision {0} out of range (Firefox)
RangeError: toExponential() argument must be between 0 and 20 (Chrome)
RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
```

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

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

Un argument dont la précision est en dehors de l'intervalle valide, prévu par le moteur JavaScript, a été utilisé pour une de ces méthodes :

* `Number.prototype.toExponential()`
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`

Généralement, ces méthodes acceptent des arguments de précision compris entre 0 et 20 (voire 21). Cependant, la spécification ECMAScript permet de gérer des valeurs en dehors de cet intervalle.

| Méthode | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
| --- | --- | --- |
| `Number.prototype.toExponential()` | 0 to 100 | 0 to 20 |
| `Number.prototype.toFixed()` | -20 to 100 | 0 to 20 |
| `Number.prototype.toPrecision()` | 1 to 100 | 1 to 21 |

Exemples
--------

### Exemples invalides


```js
(77.1234).toExponential(-1); // RangeError
(77.1234).toExponential(101); // RangeError

(2.34).toFixed(-100); // RangeError
(2.34).toFixed(1001); // RangeError

(1234.5).toPrecision(-1); // RangeError
(1234.5).toPrecision(101); // RangeError
```

### Exemples valides


```js
(77.1234).toExponential(4); // 7.7123e+1
(77.1234).toExponential(2); // 7.71e+1

(2.34).toFixed(1); // 2.3
(2.35).toFixed(1); // 2.4 (note that it rounds up in this case)

(5.123456).toPrecision(5); // 5.1235
(5.123456).toPrecision(2); // 5.1
(5.123456).toPrecision(1); // 5
```

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

* `Number.prototype.toExponential()`
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
SyntaxError: missing name after . operator
==========================================

Message
-------
```

SyntaxError: missing name after . operator
```

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

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

L'opérateur `.` (le point) est utilisé pour accéder aux propriétés d'un objet. Il est nécessaire d'indiquer le nom de la propriété à laquelle on souhaite accéder. Pour les propriétés dont le nom est calculé, il est préférable d'utiliser les crochets pour encadrer le nom. Cela permet de calculer une expression dont le résultat sera le nom de la propriété recherchée. Peut-être cherchiez-vous à utiliser l'opérateur de concaténation ? C'est l'opérateur `+` qu'il faut utiliser dans ce cas. Pour plus de détails, voir les exemples ci-après.

Exemples
--------

### Accéder à une propriété

Pour accéder à une propriété en JavaScript, on utilise le point (.) ou les crochets (`[]`) mais pas une combinaison des deux. Les crochets sont notamment utiles lorsqu'on souhaite accéder à des propriétés dont le nom est calculé.


```js
var obj = { toto: { truc: "bidule", machin2: "bidule2" } };
var i = 2;

obj.[toto].[truc]
// SyntaxError: missing name after . operator

obj.toto."machin"+i;
// SyntaxError: missing name after . operator
```


Pour corriger ce fragment de code, on pourra accéder aux propriétés de la façon suivante :


```js
obj.toto.truc; // "bidule"
// ou autrement
obj["toto"]["truc"]; // "bidule"

// pour les propriétés dont le
// nom est calculé, il faut les
// crochets
obj.toto["machin" + i]; // "bidule2"
```

### Accéder à une propriété ou concaténer ?

Si vous avez l'habitude de développer en utilisant un autre langage de programmation tel que PHP, il est possible de mélanger certains opérateurs et d'utiliser le point comme opérateur de concaténation, qui est l'opérateur `+` en JavaScript :


```js
console.log("Coucou " . "monde");

// SyntaxError: missing name after . operator
```


À la place, on écrira :


```js
console.log("Coucou " + "monde");
```

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

* Les accesseurs de propriété
RangeError: argument is not a valid code point
==============================================

Message
-------
```

RangeError: Invalid code point {0} (Edge)
RangeError: {0} is not a valid code point (Firefox)
RangeError: Invalid code point {0} (Chrome)
```

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

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

La méthode `String.fromCodePoint()` a été utilisée mais elle n'accepte que les points de code valides (*code points*) et la valeur fournie en argument n'est pas un point de code valide (ex. `NaN`, `-1`).

Un point de code est une valeur de code Unicode et s'inscrit dans un intervalle allant de `0` à `0x10FFFF`.

Les valeurs `NaN`, les entiers négatifs (`-1`), les flottants (`3.14`) ou les valeur supérieures à `0x10FFFF` (`1114111`) ne peuvent pas être utilisées avec cette méthode.

Examples
--------

### Exemples invalides


```js
String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

### Exemples valides


```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"
```

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

* `String.fromCodePoint()`
InternalError: too much recursion
=================================

Message
-------
```

Error: Out of stack space (Edge)
InternalError: too much recursion (Firefox)
RangeError: Maximum call stack size exceeded (Chrome)
```

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

`InternalError`.

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

Une fonction qui s'appelle elle-même est une fonction *recursive*. Lorsqu'une certaine condition est respectée, la fonction arrête de s'appeler elle-même, c'est ce qu'on appelle le cas initial.

D'une certaine façon, une récursion est semblable à une boucle. Les deux exécutent le même code plusieurs fois, et les deux ont besoin d'une condition d'arrêt afin d'éviter une boucle infinie ou une récursion infinie. Lorsqu'il y a trop de niveaux de récursion ou une récursion infinie, JavaScript lèvera cette erreur.

Exemples
--------

Cette fonction récursive est exécutée 10 fois comme l'indique la condition de sortie :


```js
function loop(x) {
  if (x >= 10) {
    // "x >= 10" is the exit condition
    return;
  }
  // do stuff
  loop(x + 1); // the recursive call
}
loop(0);
```


Si la condition d'arrêt est beaucoup trop grande, cela ne fonctionnera pas :


```js
function loop(x) {
  if (x >= 1000000000000) {
    return;
  }
  // do stuff
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion
```


Si la fonction récursive ne possède pas de cas initial, il n'y aura pas de condition de sortie et la fonction continuera de s'appeler indéfiniment.


```js
function boucle(x) {
  boucle(x + 1);
  // il n'y a pas de cas initial
}

boucle(0);
```

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

* Récursion
* Les fonctions récursives
TypeError: invalid Array.prototype.sort argument
================================================

Message
-------
```

TypeError: argument is not a function object (Edge)
TypeError: invalid Array.prototype.sort argument (Firefox)
```

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

`TypeError`Que s'est-il passé ?
--------------------

L'argument passé à `Array.prototype.sort()` devrait être `undefined` ou être une fonction comparant ses opérandes.

Exemples
--------

### Cas invalides


```js
[1, 3, 2].sort(5); // TypeError

var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key] || "asc"); // TypeError
```

### Cas valides


```js
[1, 3, 2].sort(); // [1, 2, 3]

var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key || "asc"]); // [1, 2, 3]
```

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

* `Array.prototype.sort()`
TypeError: can't convert BigInt to number
=========================================

L'exception JavaScript *"can't convert BigInt to number"* se produit lorsqu'une opération arithmétique porte sur un mélange de valeurs `BigInt` et `Number`.

Message
-------
```

TypeError: Cannot mix BigInt and other types, use explicit conversions (moteur basé sur V8)
TypeError: BigInts have no unsigned right shift, use >> instead (moteur basé sur V8)
TypeError: can't convert BigInt to number (Firefox)
TypeError: Invalid mix of BigInt and other type in addition/multiplication/…. (Safari)
TypeError: BigInt does not support >>> operator (Safari)
```

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

`TypeError`.

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

Les deux opérandes d'un opérateur arithmétique doivent tous les deux être des grands entiers ou tous les deux être des nombres. Si une opération porte sur un mélange des deux, on ne sait pas si le résultat devrait être un grand entier ou un nombre, car les deux cas causeraient une perte de précision.

L'erreur peut également se produire lorsque l'opérateur de décalage non signé à droite (`>>>`) est utilisé entre deux valeurs `BigInt`. Dans Firefox, le message est le même : *"can't convert BigInt to number"*.

Exemples
--------

### Mélanger des nombres et des grands entiers dans des opérations


```js
const somme = 1n + 1;
// TypeError: can't convert BigInt to number
```


À la place, on convertira explicitement l'un des deux opérandes en nombre ou en grand entier.


```js
const somme = 1n + BigInt(1);
const somme2 = Number(1n) + 1;
```

### Utiliser un décalage à droite non signé sur des grands entiers


```js
const a = 4n >>> 2n;
// TypeError: can't convert BigInt to number
```


On utilisera un décalage à droite normal à la place.


```js
const a = 4n >> 2n;
```

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

* `BigInt`
SyntaxError: invalid regular expression flag "x"
================================================

Message
-------
```

SyntaxError: Syntax error in regular expression (Edge)
SyntaxError: invalid regular expression flag "x" (Firefox)
SyntaxError: Invalid regular expression flags (Chrome)
```

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

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

Un marqueur (*flag*) invalide est utilisé dans une expression rationnelle. Un littéral d'expression rationnelle se compose d'un motif entouré de deux barres obliques, les marqueurs sont ajoutés après la seconde barre oblique. On peut également les indiquer dans le deuxième paramètre du constructeur `RegExp`. Les marqueurs d'une expression rationnelle peuvent être utilisés séparément ou combinés, dans n'importe quel ordre. Il existe uniquement cinq marqueurs autorisés en ECMAScript.

Pour ajouter un marqueur sur une expression rationnelle, on utilisera cette syntaxe :


```js
var re = /motif/marqueurs;
```


ou encore :


```js
var re = new RegExp("motif", "marqueurs");
```


| Marqueur | Description |
| --- | --- |
| `g` | Recherche globale. |
| i | Recherche non-sensible à la casse. |
| m | Recherche sur plusieurs lignes. |
| u | Unicode : le motif est interprété comme une suite de codets Unicode. |
| y | La recherche effectuée est « adhérente » et recherche une correspondance à la position indiquée dans la chaîne cible (cf. `sticky`). |

Exemples
--------

Seuls cinq marqueurs d'expression rationnelle sont valides :


```js
/toto/truc;

// SyntaxError: invalid regular expression flag "t"
```


Peut-être souhaitiez-vous créer une expression rationnelle ? Une expression qui contient deux barres obliques est interprétée comme un littéral d'expression rationnelle :


```js
let obj = {
  url: /docs/Web
};

// SyntaxError: invalid regular expression flag "W"
```


Peut-être souhaitiez-vous créer une chaîne de caractères ? Dans ce cas, il faut ajouter des quotes (simples ou doubles) afin de former un littéral de chaîne de caractères :


```js
let obj = {
  url: "/docs/Web",
};
```

### Marqueurs valides

Voir le tableau ci-avant pour la liste des marqueurs autorisés pour manipuler les expressions rationnelles en JavaScript.


```js
/toto/g;
/toto/gim;
/toto/uy;
```

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

* Les expressions rationnelles
* XRegEx – une bibliothèque relative aux expressions rationnelles qui fournit quatre nouveaux marqueurs (*flags*) (`n`, `s`, `x`, `A`)
SyntaxError: missing ) after argument list
==========================================

Message
-------
```

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

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

`SyntaxError`.

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

Il y a une erreur avec la façon dont une fonction est appelée . Cela peut être une faute de frappe, un opérateur manquant, ou une chaîne non-échappée, par exemple .

Exemple
-------

Parce qu'il n'y a pas d'opérateur "+" pour concaténer la chaîne de caractères, JavaScript s'attend à trouver une parenthèse après "PI : ", qu'il considère comme l'argument de la fonction `log`.


```js
console.log("PI: " Math.PI);
// SyntaxError: missing ) after argument list
```


La fonction `log` peut être corrigée en ajoutant un opérateur "+".


```js
console.log("PI: " + Math.PI);
// "PI: 3.141592653589793"
```

### Chaînes non terminées


```js
console.log('"Java" + "Script" = \"' + 'Java' + 'Script\");
// SyntaxError: missing ) after argument list
```


Dans cet exemple, le moteur JavaScript considère qu'on souhaitait avoir `);` dans la chaîne de caractères et l'ignore. Aussi, le moteur considère que l'appelle à `console.log` n'est pas terminé et qu'il manque une parenthèse fermante. Pour corriger ce problème, on peut rajouter une quote `'` après la chaîne de caractères `"Script"` :


```js
console.log('"Java" + "Script" = "' + "Java" + 'Script"');
// '"Java" + "Script" = "JavaScript"'
```

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

* Functions