recursal/MDN huggingface dataset:
Warning: -file- is being assigned a //# sourceMappingURL, but already has one
=============================================================================

Message
-------
```

Warning: -fichier- is being assigned a //# sourceMappingURL, but already has one.
```

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

Un avertissement. L'exécution du script JavaScript n'est pas interrompue.

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

Un fichier *source map* a été défini plus d'une fois pour un fichier source JavaScript donné.

La plupart du temps, les fichiers sources des scripts JavaScript sont fusionnés et minifiés afin que les transferts de fichiers du serveur vers le navigateur soient plus efficaces. Grâce aux fichiers de correspondance des sources (*source maps*), il est possible d'indiquer au débogueur le code original correspondant. Il existe deux méthodes pour déclarer une correspondance de sources : en utilisant un commentaire ou définissant un en-tête pour le fichier JavaScript.

Exemples
--------

Voici une correspondance de source déclarée via un commentaire dans le fichier :


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


Une autre méthode consiste à indiquer la source originale dans l'en-tête du fichier JavaScript :


```js
X-SourceMap: /chemin/vers/le/fichier.js.map
```

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

* Comment utiliser une correspondance de source - Les outils de développement Firefox
* Une introduction aux correspondances de sources – HTML5 Rocks (en anglais)
TypeError: "x" has no properties
================================

Message
-------
```

TypeError: Unable to get property {x} of undefined or null reference (Edge)
TypeError: null has no properties (Firefox)
TypeError: undefined has no properties (Firefox)
```

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

`TypeError`.

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

Les valeurs `null` et `undefined` n'ont aucunes propriétés auxquelles accéder.

Exemples
--------


```js
null.toto;
// TypeError: null has no properties

undefined.truc;
// TypeError: undefined has no properties
```

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

* `null`
* `undefined`
SyntaxError: invalid BigInt syntax
==================================

L'exception JavaScript *"invalid BigInt syntax"* se produit lors d'une tentative de conversion d'une chaîne de caractères en `BigInt` qui échoue, parce que la chaîne de caractères ne peut pas être analysée comme un nombre entier.

Message
-------
```

SyntaxError: Cannot convert x to a BigInt (moteur JavaScript basé sur V8)
SyntaxError: invalid BigInt syntax (Firefox)
SyntaxError: Failed to parse String to BigInt (Safari)
```

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

`SyntaxError`.

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

Lorsqu'on utilise la fonction `BigInt()` afin de convertir une chaîne de caractères en grand entier, la chaîne de caractères sera analysée comme du code source et la valeur résultante doit être un nombre entier.

Exemples
--------

### Exemples invalides


```js
const a = BigInt("1.5");
const b = BigInt("1n");
const c = BigInt.asIntN(4, "8n");
// SyntaxError: invalid BigInt syntax
```

### Exemples valides


```js
const a = BigInt("1");
const b = BigInt(" 1 ");
const c = BigInt.asIntN(4, "8");
```

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

* `BigInt`
TypeError: setting a property that has only a getter
====================================================

Message
-------
```

TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
TypeError: setting getter-only property "x" (Firefox)
TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
```

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

`TypeError`, uniquement en mode strict.

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

On essaie de fournir une nouvelle valeur pour une propriété qui ne dispose que d'un accesseur. Ceci échouera en mode non-strict mais lèvera une exception `TypeError` en mode strict.

Exemples
--------

Dans l'exemple qui suit, on voit comment créer un accesseur sur une propriété. En revanche, dans la définition de l'objet, on n'inclut aucun mutateur et une exception `TypeError` sera déclenchée lorsqu'on voudra modifier la propriété `temperature` pour la passer à `30`. Pour plus de détails, on pourra consulter la page `Object.defineProperty()`.


```js
"use strict";

function Archiver() {
  var temperature = null;
  Object.defineProperty(this, "temperature", {
    get: function () {
      console.log("get!");
      return temperature;
    },
  });
}

var arc = new Archiver();
arc.temperature; // 'get!'

arc.temperature = 30;
// TypeError: setting a property that has only a getter
```


Pour corriger cette erreur, soit on retire la ligne 16 (où on tente de modifier la propriété) soit on implémente un mutateur, comme ceci :


```js
"use strict";

function Archiver() {
  var temperature = null;
  var archive = [];

  Object.defineProperty(this, "temperature", {
    get: function () {
      console.log("get!");
      return temperature;
    },
    set: function (value) {
      temperature = value;
      archive.push({ val: temperature });
    },
  });

  this.getArchive = function () {
    return archive;
  };
}

var arc = new Archiver();
arc.temperature; // 'get!'
arc.temperature = 11;
arc.temperature = 13;
arc.getArchive(); // [{ val: 11 }, { val: 13 }]
```

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

* `Object.defineProperty()`
* `Object.defineProperties()`
ReferenceError: invalid assignment left-hand side
=================================================

Message
-------
```

ReferenceError: invalid assignment left-hand side
```

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

`ReferenceError`.

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

Un affectation inattendue a eu lieu. Cela peut être dû à un mélange entre un opérateur d'affectation et un opérateur de comparaison. Un seul signe égal affectera une valeur à une variable alors que les opérateurs `==` ou `===` comparent des valeurs entre elles.

Exemples
--------


```js
if (Math.PI = 3 || Math.PI = 4) {
  console.log('Nope !');
}
// ReferenceError: invalid assignment left-hand side

var str = 'Hello, '
+= 'is it me '
+= 'you\'re looking for?';
// ReferenceError: invalid assignment left-hand side
```


Dans l'instruction `if`, plutôt qu'une affectation, on voudra plutôt utiliser un opérateur `==` ou `===` et l'opérateur de concaténation (+) à la place pour la chaîne.


```js
if (Math.PI == 3 || Math.PI == 4) {
  console.log("no way!");
}

var str = "Hello, " + "from the " + "other side!";
```

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

* Opérateurs d'affectation
* Opérateurs de comparaison
SyntaxError: cannot use `??` unparenthesized within `||` and `&&` expressions
=============================================================================

L'exception JavaScript *"cannot use `??` unparenthesized within `||` and `&&` expressions"* se produit lorsque l'opérateur de coalescence des nuls est utilisé avec un OU logique ou avec un ET logique, dans la même expression et sans parenthèses.

Message
-------
```

SyntaxError: Unexpected token '??' (moteur JavaScript basé sur V8)
SyntaxError: cannot use `??` unparenthesized within `||` and `&&` expressions (Firefox)
SyntaxError: Unexpected token '??'. Coalescing and logical operators used together in the same expression; parentheses must be used to disambiguate. (Safari)
```

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

`SyntaxError`

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

La précédence des opérateurs ressemble à ceci :
```

|   >   &&   >   ||   >   =
|   >   ??   >   =
```


Toutefois, la précédence *entre* `??` et `&&`/`||` est intentionnellement indéfinie, car le comportement en court-circuit des opérateurs logiques peut rendre l'évaluation d'une expression contre-intuitive. Ainsi, toutes les combinaisons qui suivent entraînent des erreurs de syntaxe, car le langage ne permet pas de savoir quelle opération a la priorité :


```js
a ?? b || c
a || b ?? c
a ?? b && c
a && b ?? c
```


À la place, on utilisera des parenthèses pour rendre explicite l'ordre des opérations voulu :


```js
(a ?? b) || c;
a ?? (b && c);
```

Exemples
--------

Lorsqu'on migre du code historique qui utilise `||` et `&&` afin de se protéger des valeurs `null` ou `undefined`, on peut aboutir à une conversion partielle :


```js
function getId(user, fallback) {
  // Avant, on avait : user && user.id || fallback
  return user && user.id ?? fallback; // SyntaxError: cannot use `??` unparenthesized within `||` and `&&` expressions
}
```


À la place, on privilégiera l'utilisation de parenthèses autour des opérandes de `&&` :


```js
function getId(user, fallback) {
  return (user && user.id) ?? fallback;
}
```


Mieux encore, on peut utiliser le chaînage optionnel à la place de `&&` :


```js
function getId(user, fallback) {
  return user?.id ?? fallback;
}
```

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

* Discussion originale à propos de la précédence de l'opérateur de coalescence des nuls (en anglais)
* L'opérateur de coalescence des nuls
* La précédence des opérateurs
SyntaxError: missing formal parameter
=====================================

Message
-------
```

SyntaxError: missing formal parameter (Firefox)
```

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

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

« *Formal parameter* » (ou « paramètre formel ») est une façon de désigner un paramètre d'une fonction. Ici, certains des paramètres de la fonction sont invalides. Lorsqu'on déclare une fonction, les paramètres doivent être des identifiants et non des valeurs (telles que des nombres, des chaînes de caractères ou des objets). La déclaration et l'appel de la fonction forment deux étapes distinctes. Les déclarations utilisent uniquement des identifiants comme paramètres. Lorsqu'on appelle une fonction, on fournit les valeurs à utiliser.

En JavaScript, les identifiants peuvent contenir n'importe quel caractère alphanumérique (ou "$" or "\_") et ne doivent pas commencer par un nombre. Un identifiant n'est pas une chaîne de caractères, une chaîne de caractères est une donnée alors qu'un identifiant fait partie du code.

Exemples
--------

Lorsqu'on définit une fonction, les paramètres doivent être des identifiants. Aucune des fonctions suivantes ne répond à ce critère (elles lèvent donc toutes une erreur) car elles utilisent des valeurs :


```js
function carre(3) {
  return nombre \* nombre;
};
// SyntaxError: missing formal parameter

function salutation("Coucou") {
  return salut;
};
// SyntaxError: missing formal parameter

function log({ obj: "value"}) {
  console.log(arg)
};
// SyntaxError: missing formal parameter
```


Il faut utiliser des identifiants lors de la déclaration des fonctions :


```js
function carre(nombre) {
  return nombre \* nombre;
}

function salutation(salut) {
  return salut;
}

function log(arg) {
  console.log(arg);
}
```


Ensuite, on pourra appeler ces fonctions avec les arguments voulus :


```js
carre(2); // 4
salutation("Coucou"); // "Coucou"
log({ obj: "value" }); // Object { obj: "value" }
```

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

* Les autres erreurs relatives aux paramètres formels :
    + SyntaxError: Malformed formal parameter
    + SyntaxError: redeclaration of formal parameter "x"
SyntaxError: missing ] after element list
=========================================

Message
-------
```

SyntaxError: missing ] after element list
```

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

`SyntaxError`.

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

Il y a une erreur dans le littéral de tableau qui est uilisé. Il manque un crochet fermant ("`]`") ou une virgule qui sépare les éléments.

Exemples
--------

### Littéraux de tableaux incomplets


```js
var liste = [1, 2,

var instruments = [
  "Ukulele",
  "Guitare",
  "Piano"
};

var data = [{toto: "truc"} {titi: "bidule"}];
```


Les versions correctes seraient :


```js
var liste = [1, 2];

var instruments = ["Ukulele", "Guitare", "Piano"];

var data = [{ toto: "truc" }, { titi: "bidule" }];
```

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

* `Array`
SyntaxError: return not in function
===================================

Message
-------
```

SyntaxError: 'return' statement outside of function (Edge)
SyntaxError: return not in function (Firefox)
SyntaxError: yield not in function (Firefox)
```

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

`SyntaxError`.

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

Une instruction `return` ou `yield` est utilisée en dehors d'une fonction. Il est possible que des accolades soient manquantes. Les mots-clés `return` et `yield` doivent être utilisés dans une fonction car ils permettent de terminer ou d'arrêter/reprendre l'exécution d'une fonction et de définir une valeur qui doit être renvoyée à l'appelant de la fonction.

Exemples
--------


```js
var encouragement = function(score) {
  if (score === 147)
    return "Super !";
  };
  if (score > 100) {
    return "Un record!";
  }
}

// SyntaxError: return not in function
```


À première vue, les accolades semblent correctes mais en regardant de plus près, on voit qu'il manque une accolade ouvrante ("{") après la première instruction `if`. La version correcte serait :


```js
var encouragement = function (score) {
  if (score === 147) {
    return "Maximum!";
  }
  if (score > 100) {
    return "Century!";
  }
};
```

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

* `return`
* `yield`
TypeError: can't assign to property "x" on "y": not an object
=============================================================

Message
-------
```

TypeError: can't assign to property "x" on {y}: not an object (Firefox)
TypeError: Cannot create property 'x' on {y} (Chrome)
```

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

`TypeError`.

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

En mode strict, une exception `TypeError` est déclenchée lorsqu'on tente de créer une propriété sur une valeur primitive telle qu'un symbole, une chaîne de caractères, un nombre ou un booleén.

Le problème peut être lié à une valeur qui se trouve à un endroit inattendu ou qu'un équivalent objet d'une valeur primitive est attendu (ex. `String` pour la chaîne de caractères ou `Number` pour un nombre).

Exemples
--------

### Exemple invalide


```js
"use strict";

var foo = "my string";
// The following line does nothing if not in strict mode.
foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object
```

### Exemple valide

On pourra corriger le problème en convertissant la valeur primitive en sont équivalent objet avec un constructeur (ici `String` pour .


```js
"use strict";

var foo = new String("my string");
foo.bar = {};
```

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

* `Strict_mode`
* primitive
TypeError: can't delete non-configurable array element
======================================================

Message
-------
```

TypeError: can't delete non-configurable array element (Firefox)
TypeError: Cannot delete property '2' of [object Array] (Chrome)
```

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

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

On a voulu raccourcir la longueur d'un tableau mais l'un des éléments de ce tableau est non-configurable. Lorsqu'on tronque un tableau, les éléments situés au-delà de la nouvelle longueur seront supprimés. Dans ce cas, c'est cette suppression qui n'a pas pu être effectuée.

L'attribut `configurable` permet de contrôler si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés.

La plupart du temps, les propriétés d'un objet créé avec un littéral de tableau sont configurables. Toutefois, si on utilise `Object.defineProperty()` par exemple, la propriété n'est pas configurable par défaut.

Exemples
--------

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

Par défaut, la méthode `Object.defineProperty()` crée des propriétés non-configurables si on n'indique pas expressément le contraire :


```js
var arr = [];
Object.defineProperty(arr, 0, { value: 0 });
Object.defineProperty(arr, 1, { value: "1" });

arr.length = 1;
// TypeError: can't delete non-configurable array element
```


Si on veut tronquer le tableau, il faut que les éléments excédants soient configurables :


```js
var arr = [];
Object.defineProperty(arr, 0, { value: 0, configurable: true });
Object.defineProperty(arr, 1, { value: "1", configurable: true });

arr.length = 1;
```

### Tableaux scellés (`seal`)

La méthode `Object.seal()` permet de marquer l'ensemble des propriétés (ici les éléments du tableau) comme non-configurables :


```js
var arr = [1, 2, 3];
Object.seal(arr);

arr.length = 1;
// TypeError: can't delete non-configurable array element
```


Pour corriger l'erreur, il faut retirer l'appel à `Object.seal()` ou réaliser une copie du tableau. Dans ce dernier cas, on notera que tronquer la copie du tableau ne modifie pas la longueur du tableau original.


```js
var arr = [1, 2, 3];
Object.seal(arr);

// On copie le tableau initial pour tronquer cette copie
var copie = Array.from(arr);
copie.length = 1;
// arr.length == 3
```

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

* La propriété interne `[[Configurable]]`
* `Array.length`
* `Object.defineProperty()`
* `Object.seal()`
SyntaxError: "x" is a reserved identifier
=========================================

Message
-------
```

SyntaxError: The use of a future reserved word for an identifier is invalid (Edge)
SyntaxError: "x" is a reserved identifier (Firefox)
SyntaxError: Unexpected reserved word (Chrome)
```

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

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

Les mots-clés réservés lèveront une exception s'ils sont utilisés en tant qu'identifiants. Voici les mots-clés réservés en mode strict et en mode *sloppy* :

* `enum`

Voici les mots-clés uniquement réservés en mode strict :

* `implements`
* `interface`
* `let`
* `package`
* `private`
* `protected`
* `public`
* `static`
Exemples
--------

### Mots-clés réservés en modes strict et non-strict

L'identifiant `enum` est réservé dans les différents cas :


```js
var enum = { RED: 0, GREEN: 1, BLUE: 2 };
// SyntaxError: enum is a reserved identifier
```


En mode strict, d'autres mots-clés sont réservés :


```js
"use strict";
var package = ["pomme", "poire", "pêches"];
// SyntaxError: package is a reserved identifier
```


Pour ne pas avoir l'erreur, il faudra renommer les variables :


```js
var enumCouleurs = { RED: 0, GREEN: 1, BLUE: 2 };
var liste = ["pomme", "poire", "pêches"];
```

### Mettre à jour les anciens navigateurs

Si vous utilisez un ancien navigateur qui n'implémente pas `let` ou `class`, vous devrez mettre à jour votre navigateur :


```js
"use strict";
class DocArchiver {}

// SyntaxError: class is a reserved identifier
// (lève une exception dans les anciens navigateurs
// tels que Firefox 44 et les versions antérieures)
```

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

* Utiliser de bons noms de variable
TypeError: invalid assignment to const "x"
==========================================

Message
-------
```

TypeError: invalid assignment to const "x" (Firefox)
TypeError: Assignment to constant variable. (Chrome)
TypeError: Redeclaration of const 'x' (Edge)
```

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

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

Une constante est une valeur qui ne peut pas être modifiée lors de l'exécution du programme. Elle ne peut pas être modifiée grâce à une réaffectation ou grâce à une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé `const`.

Exemples
--------

### Redéclaration invalide

Si on affecte une valeur à une constante dans la même portée de bloc que celui qui contient l'affectation initiale, une exception sera levée :


```js
const COLUMNS = 80;

// ...

COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'
```

### Résoudre le problème

Il existe plusieurs façons de résoudre ce problème et il faut au préalable comprendre le rôle de la constante en question.

#### Utiliser un autre nom

Si on souhaite déclarer une autre constante, on peut utiliser un autre nom que celui qui est déjà pris dans cette portée :


```js
const COLUMNS = 80;
const WIDE\_COLUMNS = 120;
```


#### `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`.


```js
let columns = 80;

// ...

let columns = 120;
```


#### Gérer les portées

On peut également vérifier qu'on est dans la bonne portée. Est-ce que la constante devait apparaître dans la portée en question ou devait être utilisée dans une fonction ?


```js
const COLUMNS = 80;

function setupBigScreenEnvironment() {
  const COLUMNS = 120;
}
```

### `const` et l'immuabilité

La déclaration `const` crée une référence en lecture seule vers une valeur. Elle ne signifie pas que la valeur en question est immuable mais uniquement que l'identifiant de la référence ne peut pas recevoir de nouvelle valeur. Ainsi, si le contenu est un objet, celui-ci pourra toujours être modifié :


```js
const obj = { toto: "truc" };
obj = { toto: "bidule" }; // TypeError: invalid assignment to const `obj'
```


En revanche, on peut modifier les propriétés :


```js
obj.toto = "bidule";
obj; // Object { toto: "bidule" }
```

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

* `const`
* `let`
* `var`
RangeError: repeat count must be non-negative
=============================================

Message
-------
```

RangeError: argument out of range (Edge)
RangeError: repeat count must be non-negative (Firefox)
RangeError: Invalid count value (Chrome)
```

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

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

La méthode `String.prototype.repeat()` a été utilisée avec un argument négatif. Or, cet argument doit être compris dans l'intervalle [0, +∞).

Exemples
--------

### Exemples invalides


```js
"abc".repeat(-1); // RangeError
```

### Exemples valides


```js
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (converti en entier)
```

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

* `String.prototype.repeat()`
length
======

La propriété **`arguments.length`** contient le nombre d'arguments passés à la fonction.

Syntaxe
-------


```js
arguments.length;
```

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

La propriété `arguments.length` fournit le nombre d'arguments qui ont été passés à la fonction. Cette quantité peut être inférieure ou supérieure au nombre de paramètres explicitement déclarés dans la définition de la fonction (voir également `Function.length`).

Exemple
-------

### Utiliser `arguments.length`

Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs nombres.


```js
function somme(x /\*, y, z, ...\*/) {
  x = Number(x);
  for (var i = 1; i < arguments.length; i++) {
    x += Number(arguments[i]);
  }
  return x;
}
```



```js
résultat = somme(3, 4, 5); // renvoie 12
résultat = somme(3, 4); // renvoie 7
résultat = somme(103, 104, 105); // renvoie 312
```


**Note :** `arguments.length` ne doit pas être confondu avec `Function.length`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-arguments-exotic-objects |

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

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

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

* `Function`
* `Function.length`
arguments[@@iterator]()
=======================

La valeur initiale de la propriété **`@@iterator`** est le même objet que la fonction utilisée pour la valeur initiale de la propriété `Array.prototype.values`.

Syntaxe
-------


```js
arguments[Symbol.iterator]();
```

Exemples
--------

### Utiliser une boucle `for...of`


```js
function f() {
  // votre environnement doit supporter les
  // boucles for..of et les variables
  // définies avec let dans les boucles
  for (let letter of arguments) {
    console.log(letter);
  }
}
f("w", "y", "k", "o", "p");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-createunmappedargumentsobject |
| ECMAScript Language Specification # sec-createmappedargumentsobject |

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

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

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

* `Array.prototype.values()`