recursal/MDN huggingface dataset:
Error.prototype.lineNumber
==========================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété **`lineNumber`** contient le numéro de la ligne qui a déclenché l'erreur dans le fichier.

Exemples
--------

### Utiliser `lineNumber`


```js
var e = new Error("Ne peut pas lire la donnée");
throw e;
console.log(e.lineNumber); // 2
```

### Alternative en utilisant l'événement `error`


```js
window.addEventListener("error", function (e) {
  console.log(e.lineNumber); //5
});
var e = new Error("Ne peut pas lire la donnée");
throw e;
```

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

Ne fait partie d'aucune spécification. Non standard.

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

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

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

* `Error.prototype.stack` 
Non-standard
* `Error.prototype.columnNumber` 
Non-standard
* `Error.prototype.fileName` 
Non-standard
Error.prototype.fileName
========================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété **`fileName`** contient le chemin vers le fichier qui a déclenché l'erreur.

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

Cette propriété non-standard contient le chemin vers le fichier qui a déclenché cette erreur. Si elle est appelée depuis un débugger (les outils de développement de Firefox par exemple), "debugger eval code" sera renvoyé.

Exemples
--------

### Utiliser `fileName`


```js
var e = new Error("Ne peut pas lire la donnée");
throw e;
// e.fileName peut ressembler à "file:///C:/exemple.html"
```

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

Ne fait partie d'aucune spécification. Non standard.

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

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

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

* `Error.prototype.stack` 
Non-standard
* `Error.prototype.columnNumber` 
Non-standard
* `Error.prototype.lineNumber` 
Non-standard
Error.prototype.toString()
==========================

La méthode **`toString()`** renvoie une représentation de l'objet `Error` sous la forme d'une chaine de caractères.

Syntaxe
-------


```js
e.toString();
```

### Valeur de retour

Une chaîne de caractères représentant l'objet `Error`.

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

L'objet `Error` surcharge la méthode `Object.prototype.toString()` héritée par tous les objets. Sa sémantique est la suivante (en partant du principe que `Object` et `String` ont leurs valeurs originales) :


```js
Error.prototype.toString = function () {
  "use strict";

  var obj = Object(this);
  if (obj !== this) throw new TypeError();

  var name = this.name;
  name = name === undefined ? "Error" : String(name);

  var msg = this.message;
  msg = msg === undefined ? "" : String(msg);

  if (name === "") return msg;
  if (msg === "") return name;

  return name + ": " + msg;
};
```

Exemples
--------


```js
var e = new Error("Erreur fatale");
console.log(e.toString()); // "Error: Erreur fatale"

e.name = undefined;
console.log(e.toString()); // "Error: Erreur fatale"

e.name = "";
console.log(e.toString()); // "Erreur fatale"

e.message = undefined;
console.log(e.toString()); // ""

e.name = "salut";
console.log(e.toString()); // "salut"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.tostring |

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

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

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

* `Error.prototype.toSource()` 
Non-standard
Promise.allSettled()
====================

La méthode **`Promise.allSettled()`** renvoie une promesse qui est résolue une fois que l'ensemble des promesses de l'itérable passée en argument sont réussies ou rejetées. La valeur de résolution de cette promesse est un tableau d'objets dont chacun est le résultat de chaque promesse de l'itérable.

Exemple interactif
------------------

Syntaxe
-------


```js
p.allSettled(iterable);
```

### Paramètres

`iterable`

Un objet itérable tel qu'un tableau (`Array`) dont chaque élément est une promesse (`Promise`.

### Valeur de retour

Une promesse (`Promise`) **en cours** qui sera résolue de façon **asynchrone** une fois que chaque promesse de l'itérable a été résolue (tenue/réussie ou rejetée/échouée). Le gestionnaire passé à la promesse retournée recevra comme argument un tableau de valeur dont chacune est le résultat de chaque promesse de l'itérable initial.

Pour chaque objet contenu dans ce tableau, il y aura une propriété `status` qui est une chaîne de caractères. Si `status` vaut `fulfilled`, alors on aura une propriété `value`. Si `status` vaut `rejected`, alors une propriété `reason` sera présente. La valeur (ou la raison) reflète la valeur de résolution de la promesse.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.allsettled |

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

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

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

* Guide - Utiliser les promesses
* Programmation asynchrone à l'aide des promesses
* `Promise`
* `Promise.all()`
Promise.prototype.finally()
===========================

La méthode **`finally()`** renvoie un objet `Promise` et accepte en argument une fonction de *callback* qui est appelée lorsque la promesse a été résolue (qu'elle ait été tenue ou rejetée). Cela permet d'exécuter du code une fois que la promesse a été traitée, quel que soit le résultat. On évite ainsi de dupliquer du code entre les gestionnaires `then()` et `catch()`.

Syntaxe
-------


```js
p.finally(onFinally);

p.finally(function () {
  // appelée dans tous les
  // cas de terminaison
});
```

### Paramètres

`onFinally`

Une fonction (objet `Function`) appelé lorsque la promesse courante est résolue.

### Valeur de retour

Cette méthode renvoie un objet `Promise`.

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

La méthode `finally` peut être utile si on souhaite effectuer un traitement ou du nettoyage (fermetures de flux, libération de ressources, etc.) une fois qu'une promesse est résolue, quel que soit l'état de la résolution (tenue ou rejetée).

La méthode `finally` est similaire à l'utilisation de la forme `.then(onFinally, onFinally)`, on notera toutefois quelques différences :

* Lorsqu'on crée une fonction en ligne, on peut ne la passer qu'une seule fois et éviter d'avoir à déclarer une variable ou à la déclarer à deux reprises.
* Un *callback* `finally` ne recevra pas d'argument car on ne peut pas savoir si la promesse a été tenue ou rompue. Cette fonction est précisément appelée lorsqu'on ne s'intéresse pas à la raison du rejet ou à la réussite de la promesse. Une telle valeur est donc superflue. Ainsi :
    + À la différence de `Promise.resolve(2).then(() => {}, () => {})` qui sera résolue avec la valeur `undefined`, `Promise.resolve(2).finally(() => {})` sera résolue avec la valeur `2`.
    + De même, à la différence de `Promise.reject(3).then(() => {}, () => {})` qui sera résolue avec la valeur `undefined`, `Promise.reject(3).finally(() => {})` sera rejetée avec `3`.

**Note :** Toutefois, on notera qu'utiliser `throw` (ou que renvoyer une promesse rompue) dans le *callback* `finally` rejettera la promesse avec l'exception indiquée dans l'appel à `throw`.

Exemples
--------


```js
let isLoading = true;

fetch(myRequest)
  .then(function (response) {
    var contentType = response.headers.get("content-type");
    if (contentType && contentType.includes("application/json")) {
      return response.json();
    }
    throw new TypeError("Oups, ceci n'est pas du JSON !");
  })
  .then(function (json) {
    /\* traiter le JSON \*/
  })
  .catch(function (error) {
    console.log(error);
    /\* La ligne précédent peut aussi déclencher une
 erreur (si console vaut {} par exemple) \*/
  })
  .finally(function () {
    isLoading = false;
  });
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.finally |

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

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

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

* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()`
Promise.reject()
================

La méthode **`Promise.reject(raison)`** renvoie un objet `Promise` qui est rejeté (la promesse n'est pas tenue) à cause d'une raison donnée.

Exemple interactif
------------------

Syntaxe
-------


```js
Promise.reject(raison);
```

### Paramètres

`raison`

La raison pour laquelle la `Promise` n'a pas été tenue.

### Valeur de retour

Une promesse (`Promise`) qui est rompue avec la raison passée en argument.

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

La fonction statique `Promise.reject` renvoie une `Promise` qui est rejetée. Pour faciliter le débogage (comprendre plus rapidement le problème et sélectionner une erreur précise), il peut être utile que l'argument `raison` soit une instance d'`Error`.

Exemples
--------


```js
Promise.reject(new Error("échec")).then(
  function () {
    // n'est pas appelée
  },
  function (erreur) {
    console.log(erreur); // Analyse de la pile d'appels
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

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

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

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

* `Promise`
SyntaxError: a declaration in the head of a for-of loop can't have an initializer
=================================================================================

Message
-------
```

SyntaxError: for-of loop head declarations cannot have an initializer (Edge)
SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox)
SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome)
```

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

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

L'en-tête d'une boucle `for...of` 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é pour les boucles `for-of`. En revanche, les boucles `for` permettent d'avoir un initialisateur.

Exemples
--------

### Boucles `for-of` invalides


```js
let iterable = [10, 20, 30];

for (let value = 50 of iterable) {
  console.log(value);
}

// SyntaxError: a declaration in the head of a for-of loop can't
// have an initializer
```

### Boucles `for-of` valides

Il faut retirer l'initialisateur de l'en-tête de la boucle pour ne plus avoir l'erreur. Si cette valeur devait servir d'incrément, on peut ajouter l'addition dans le corps de la boucle.


```js
let iterable = [10, 20, 30];

for (let value of iterable) {
  value += 50;
  console.log(value);
}
// 60
// 70
// 80
```

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

* `for...of`
* `for...in` interdit également d'utiliser un initialisateur en mode strict (SyntaxError: for-in loop head declarations may not have initializers)
* `for` permet de définir un initialisateur lors de l'itération
ReferenceError: "x" is not defined
==================================

Message
-------
```

ReferenceError: "x" is not defined
```

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

`ReferenceError`.

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

Une variable qui n'existe pas est référencée quelque part. Cette variable doit être déclarée ou il faut vérifier qu'elle est disponible dans le script concerné ou dans la portée utilisée.

**Note :** Lors du chargement d'une bibliothèque comme jQuery, assurez-vous de bien charger la bibliothèque avant d'accéder aux variables comme `$`. La balise `<script>` utilisée pour charger la bibliothèque doit être présente avant le code qui l'utilise.

Exemples
--------

### Exemple de variable non déclarée


```js
toto.substring(1); // ReferenceError: toto is not defined
```


La variable `toto` n'est définie nulle part. De plus, il faut qu'elle soit une chaîne de caractères afin que la méthode `String.prototype.substring()` puisse fonctionner.


```js
var toto = "truc";
toto.substring(1); // "ruc"
```

### Exemple de portée invalide

Une variable doit être disponible dans le contexte d'exécution où elle est utilisée. Les variables définies au sein d'une fonction ne peuvent pas être utilisées en dehors de cette fonction car la variable appartient à la *portée* de la fonction.


```js
function numbers() {
  var num1 = 2,
    num2 = 3;
  return num1 + num2;
}

console.log(num1); // ReferenceError num1 is not defined.
```


Toutefois, une fonction peut accéder aux variables et aux fonctions définies dans la portée dans laquelle elle s'inscrit. Ainsi, une fonction définie dans la portée globale peut utiliser toutes les variables définies dans la portée globale.


```js
var num1 = 2,
  num2 = 3;

function numbers() {
  return num1 + num2;
}

console.log(num1); // 2
```

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

* La déclaration de variables dans le guide JavaScript
* Les notions de portées dans le guide JavaScript
SyntaxError: missing : after property id
========================================

Message
-------
```

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

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

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

Lorsqu'on crée un objet en utilisant un initialisateur d'objet, il faut utiliser un deux-points ( : ) afin de séparer les clés des valeurs pour les propriétés de l'objet.


```js
var obj = { cleDeLaPropriete: "valeur" };
```

Exemples
--------

### Deux-points et signe égal

Le code qui suit provoquera une erreur car on utilise un signe égal (=) à la place du deux-points.


```js
var obj = { cleDeLaPropriete = 'valeur' };
// SyntaxError: missing : after property id
```


Pour corriger ce problème, on peut utiliser un deux-points ou bien affecter la nouvelle propriété après avoir créé l'objet :


```js
var obj = { cleDeLaPropriete: "valeur" };

// ou encore :

var obj = {};
obj["cleDeLaPropriete"] = "valeur";
```

### Propriétés vides

On ne peut pas créer de propriétés vides de cette façon :


```js
var obj = { cleDeLaPropriete; };
// SyntaxError: missing : after property id
```


Si vous souhaitez définir une propriété sans valeur, vous pouvez utiliser le mot-clé `null` :


```js
var obj = { cleDeLaPropriete: null };
```

### Propriétés calculées

Si vous souhaitez créer une clé de propriété à partir d'une expression, il faudra utiliser des crochets pour encadrer l'expression (sinon le nom de la propriété ne pourra pas être calculé) :


```js
var obj = { 'tr'+'uc': 'toto' };
// SyntaxError: missing : after property id
```


Pour corriger l'erreur, il faudra placer l'expression entre crochets :


```js
var obj = { ["tr" + "uc"]: "toto" };
```

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

* Initialisateur d'objet
ReferenceError: reference to undefined property "x"
===================================================

Message
-------
```

ReferenceError: reference to undefined property "x" (Firefox)
```

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

Uniquement pour Firefox. Une erreur `ReferenceError` lancée en avertissement, uniquement si la préférence `javascript.options.strict` vaut `true`.

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

Le code tente d'accéder à une propriété inexistante d'un objet. Il existe deux méthodes pour accéder aux propriétés. Pour plus de détails, on pourra lire la page de la référence sur les accesseurs de propriété.

Exemples
--------

### Exemples invalides

Ici, la propriété `truc` n'est pas une propriété définie et on obtient alors une `ReferenceError`.


```js
"use strict";

var toto = {};
toto.truc; // ReferenceError: reference to undefined property "bar"
```

### Exemples valides

Pour éviter cette erreur, il faut que `truc` soit une variable « définie » ou vérifier son existence avant de l'utiliser (en utilisant par exemple la méthode `Object.prototype.hasOwnProperty()`).


```js
"use strict";

var toto = {};

toto.truc = "lune";
console.log(toto.truc); // "lune"

if (foo.hasOwnProperty("truc")) {
  console.log(toto.truc);
}
```

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

* Accesseurs de propriété
SyntaxError: illegal character
==============================

Message
-------
```

SyntaxError: Invalid character (Edge)
SyntaxError: illegal character (Firefox)
SyntaxError: Invalid or unexpected token (Chrome)
```

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

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

Dans le code, il y a un élément de la syntaxe qui n'est pas à la bonne place. Pour détecter les erreurs de ce type, vous pouvez utiliser un éditeur de texte qui prend en charge la coloration syntaxique et qui met en évidence les caractères problématiques (par exemple si on a utilisé un tiret (`–`) au lieu d'un moins ( - ) ou des guillemets anglais (`“`) à la place de doubles quotes ( " ).

Exemples
--------

### Caractères ressemblants

Certains caractères ressemblent à des caractères spéciaux en JavaScript mais n'en sont pas. Dans ce cas, lorsque le moteur analysera le code, il échouera.


```js
“Ceci ressemble à une chaîne de caractères.”;
// “ n'est pas le caractère "
// SyntaxError: illegal character

42 – 13;
// – n'est pas le caractère -
// SyntaxError: illegal character

var toto = "truc";
// ; (<37e>) n'est pas le caractère ;
// SyntaxError: illegal character
```


On peut corriger ce point en utilisant les bons caractères :


```js
"Ceci est vraiment une chaîne de caractères.";
42 - 13;
var toto = "truc";
```


Certains éditeurs et environnements de développement intégrés indiqueront la présence de tels caractères avec une coloration syntaxique différente. Toutefois, tous les éditeurs n'ont pas une telle fonctionnalité et si vous n'arrivez pas à déterminer l'origine du problème, il vaudra sans doute mieux supprimer la ligne incriminée et la resaisir manuellement.

### Caractères oubliés

On oublie parfois un caractère.


```js
var couleurs = ['#000', #333', '#666'];
// SyntaxError: illegal character
```


Dans ce cas, il suffit de rajouter la quote pour `'#333'`.


```js
var couleurs = ["#000", "#333", "#666"];
```

### Caractères cachés

Lorsque vous copiez/collez du code depuis des sources externes, celles-ci peuvent contenir des caractères invalides difficiles à discerner.


```js
var toto = "truc";
// SyntaxError: illegal character
```


Lorsqu'on inspecte ce code grâce à un éditeur de texte (par exemple Vim), on peut voir qu'il y en fait un espace sans chasse (ZWSP) (U+200B).


```js
var toto = 'truc';<200b>
```

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

* La grammaire lexicale de JavaScript
SyntaxError: Unexpected token
=============================

Message
-------
```

SyntaxError: expected expression, got "x"
SyntaxError: expected property name, got "x"
SyntaxError: expected target, got "x"
SyntaxError: expected rest argument name, got "x"
SyntaxError: expected closing parenthesis, got "x"\SyntaxError: expected '=>' after argument list, got "x"
```

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

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

La syntaxe du langage « attendait » un élément mais quelque chose d'autre est écrit à la place dans le script. Cela peut simplement être dû à une coquille dans le code.

Exemples
--------

### Expression attendue

Lorsqu'on enchaîne des expressions, par exemple, les virgules ne sont pas autorisées en fin d'expression :


```js
for (let i = 0; i < 5,; ++i) {
  console.log(i);
}
// SyntaxError: expected expression, got ')'
```


Pour corriger cette erreur, on peut retirer la virgule superflue ou bien ajouter une autre expression :


```js
for (let i = 0; i < 5; ++i) {
  console.log(i);
}
```

### Parenthèses manquantes

Il peut également arriver que des parenthèses manquent autour des instructions `if` :


```js
function round(n, upperBound, lowerBound){
  if(n > upperBound) || (n < lowerBound){
    throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);
  }else if(n < ((upperBound + lowerBound)/2)){
    return lowerBound;
  }else{
    return upperBound;
  }
} // SyntaxError: expected expression, got '||'
```


Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut voir que le OU logique (`||`) n'est contenu au sein d'aucune paire de parenthèses.

Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante :


```js
function round(n, upperBound, lowerBound) {
  if (n > upperBound || n < lowerBound) {
    throw (
      "Number " +
      String(n) +
      " is more than " +
      String(upperBound) +
      " or less than " +
      String(lowerBound)
    );
  } else if (n < (upperBound + lowerBound) / 2) {
    return lowerBound;
  } else {
    return upperBound;
  }
}
```
TypeError: property "x" is non-configurable and can't be deleted
================================================================

Message
-------
```

TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)
TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
TypeError: Cannot delete property 'x' of #<Object> (Chrome)
```

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

`TypeError` in strict mode only.

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

Une instruction demande la suppression d'une propriété non-configurable. L'attribut `configurable` permet de contrôler si la propriété peut être supprimée de l'objet auquel elle est rattachée et si ces attributs (en dehors de `writable`) peuvent être modifiés.

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

Exemples
--------

Les propriétés non-configurables ne sont pas très fréquentes mais il est possible d'en créer grâce à `Object.defineProperty()` ou à `Object.freeze()`.


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

("use strict");
var obj = {};
Object.defineProperty(obj, "toto", { value: 2, configurable: false });
delete obj.toto; // TypeError

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


Certaines propriétés natives de JavaScript sont non-configurables. Peut-être que le code tente de supprimer une constante mathématique :


```js
"use strict";
delete Math.PI; // TypeError
```

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

* L'opérateur `delete`
* `Object.defineProperty()`
* `Object.freeze()`