recursal/MDN huggingface dataset:
vide
====

Une **instruction vide** est utilisée pour ne fournir aucune instruction là où JavaScript en attendrait une.

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

Syntaxe
-------


```js
;
```

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

L'instruction vide est représentée par un point-virgule (;) qui indique qu'il n'y a aucune instruction à exécuter, même si JavaScript requiert une instruction à cet emplacement. Le comportement réciproque, où on souhaite exécuter plusieurs instructions là où JavaScript en attend une est possible grâce à l'instruction bloc qui permet de combiner plusieurs instructions en une seule.

Exemples
--------

L'instruction vide peut être utilisée dans les boucles. Par exemple, ici on a un corps de boucle totalement vide :


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

// Affecter 0 pour toutes les valeurs du tableau
for (i = 0; i < arr.length; arr[i++] = 0 /\* instruction vide \*/);

console.log(arr);
// [0, 0, 0]
```


**Note :** Cela peut être raisonnable que de commenter l'utilisation d'une instruction vide pour la rendre visible et l'expliciter. Par exemple, dans le code qui suit, le point-virgule ne semble pas intentionnel :


```js
if (condition); // Attention, ce "if" ne fait rien !
finDuMonde(); // Cette méthode est donc toujours lancée !!!
```


Un autre exemple avec une instruction `Instructions/if...else` sans accolade (`{}`). Si `trois` vaut `true`, rien ne sera exécuté, peu importera la valeur de `quatre`, la fonction `chargerFusée()` ne sera pas exécutée.


```js
if (un) faire1èreEtape();
else if (deux) faire4èmeEtape();
else if (trois);
else if (quatre)
  // rien ici
  faire4èmeEtape();
else chargerFusée();
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-empty-statement |

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

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

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

* L'instruction de bloc
continue
========

L'instruction **`continue`** arrête l'exécution des instructions pour l'itération de la boucle courante ou de la boucle étiquetée. L'exécution est reprise à l'itération suivante.

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

Syntaxe
-------


```js
continue [label];
```


`label`

Paramètre optionnel. Un identifiant associé à l'étiquette (*label*) de l'instruction pour laquelle on souhaite finir l'itération en cours.

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

Contrairement à `break`, `continue` ne termine pas la boucle complètement :

* au sein d'une boucle `while`, elle repart à la phase de la condition.

* au sein d'une boucle `for`, elle repart à l'expression de mise à jour de la boucle.

L'instruction `continue` peut éventuellement contenir une étiquette (*label*) qui permet de tirer parti des instructions de boucles étiquetées (plutôt que de ne traiter que la boucle courante). Dans le cas où l'étiquette est utilisée, il faut que l'instruction `continue` soit imbriquée dans l'instruction étiquetée.

Exemples
--------

### Utiliser `continue` avec `while`

L'instruction suivante illustre comment on peut utiliser continue au sein d'une boucle `while`, ici `continue` est utilisé lorsque `i` vaut 3. On a donc `n` qui prend les valeurs 1, 3, 7, et 12.


```js
var i = 0;
var n = 0;
while (i < 5) {
  i++;
  if (i === 3) {
    continue;
  }
  n += i;
}
```

### Utiliser `continue` avec une étiquette

Dans l'exemple suivant, on a une instruction étiquetée `vérifIetJ` qui contient une autre instruction étiquetée `vérifJ`. Si l'instruction `continue` est utilisée, le programme reprend l'exécution au début de l'instruction `vérifJ`. Chaque fois que `continue` utilisé, `vérifJ` réitère jusqu'à ce que sa condition renvoie `false`. Lorsque c'est le cas, le reste de l'instruction `vérifIetJ` est exécuté.

Si `continue` utilisait l'étiquette `vérifIetJ`, le programme continuerait au début de l'instruction `vérifIetJ`.

Voir aussi `label`.


```js
var i = 0;
var j = 8;

vérifIetJ: while (i < 4) {
  console.log("i : " + i);
  i += 1;

  vérifJ: while (j > 4) {
    console.log("j : " + j);
    j -= 1;
    if (j % 2 == 0) {
      continue vérifJ;
    }
    console.log(j + " est impaire.");
  }
  console.log("i = " + i);
  console.log("j = " + j);
}
```


En utilisant le fragment ci-avant, on aura le résultat suivant :


```js
"i : 0";

// début de vérifJ
"j : 8";
"7 est impair";
"j : 7";
"j : 6";
"5 est impair.";
"j : 5";
// fin de vérifJ

"i = 1";
"j = 4";

"i : 1";
"i = 2";
"j = 4";

"i : 2";
"i = 3";
"j = 4";

"i : 3";
"i = 4";
"j = 4";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-continue-statement |

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

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

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

* `break`
* `label`
do...while
==========

L'instruction **`do...while`** crée une boucle qui exécute une instruction jusqu'à ce qu'une condition de test ne soit plus vérifiée. La condition est testée après que l'instruction soit exécutée, le bloc d'instructions défini dans la boucle est donc exécuté au moins une fois.

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

Syntaxe
-------


```js
do instruction;
while (condition);
```


`instruction`

Une instruction exécutée au moins une fois et ré-exécutée chaque fois que la condition de test est évaluée à `true`. On peut exécuter plusieurs instructions au sein d'une boucle grâce à l'instruction `block` (`{ ... }`) qui permet de grouper différentes instructions en une seule.

`condition`

Une expression évaluée après chaque passage dans la boucle. Si l'évaluation de la `condition` donne `true` (la condition est vérifiée), `instruction` sera exécutée à nouveau. Lorsque `condition` donne `false`, le contrôle passe à l'instruction suivant la boucle `do...while`.

Exemples
--------

### Utiliser `do...while`

Dans l'exemple suivant, la boucle `do...while` est parcourue au moins une fois et répétée jusqu'à ce que `i` ne soit plus strictement inférieur à 5.


```js
var i = 0;
do {
  i += 1;
  console.log(i);
} while (i < 5);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-do-while-statement |

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

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

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

* `while`
* `for`
class
=====

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since March 2017.

* Learn more
* See full compatibility
* Report feedback
La **déclaration class** crée une nouvelle classe avec le nom fourni en utilisant l'héritage à base de prototypes pour émuler le fonctionnement de classe.

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

Il est aussi possible de définir une classe avec une expression class.

Syntaxe
-------


```js
class nom [extends autreNom] {
  // corps de la classe
}
```

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

Les déclarations qui composent le corps de la classe sont exécutées en mode strict. La propriété du constructeur est optionnelle.

Les déclarations utilisées dans les classes ne sont pas remontées (*hoisted*) (à la différence des déclarations de fonctions).

Exemples
--------

### Déclarer une classe simple

Dans l'exemple qui suit, on définit une classe `Polygone` pour laquelle on crée un sous-classe `Carré`. On note ici que la méthode `super()` ne peut être utilisée qu'au sein d'un constructeur et doit être appelée avant l'utilisation du mot-clé `this`.


```js
class Polygone {
  constructor(hauteur, largeur) {
    this.nom = "Polygone";
    this.hauteur = hauteur;
    this.largeur = largeur;
  }
}

class Carré extends Polygone {
  constructor(longueur) {
    super(longueur, longueur);
    this.nom = "Carré";
  }
}
```


**Attention :** Déclarer une classe deux fois lèvera une exception `SyntaxError`. De même, on ne pourra pas réutiliser un nom qui a déjà été utilisé dans une expression de classe.


```js
// Deux déclarations avec le même nom
class Toto {}
class Toto {} // Uncaught SyntaxError: Identifier 'Toto' has already been declared

// Expression puis déclaration
var Truc = class {};
class Truc {} // Uncaught TypeError: Identifier 'Truc' has already been declared
```


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

| Specification |
| --- |
| ECMAScript Language Specification # sec-class-definitions |

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

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

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

* Les déclarations `function`
* Les expressions `class`
* Les classes
return
======

L'instruction **`return`** met fin à l'exécution d'une fonction et définit une valeur à renvoyer à la fonction appelante.

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

Syntaxe
-------


```js
return [expression];
```


`expression`

L'expression dont on souhaite renvoyer la valeur. Si elle est absente, la valeur renvoyée par défaut sera `undefined`.

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

Lorsqu'une instruction `return` est utilisée dans une fonction, l'exécution de la fonction se termine. Si une valeur est fournie, elle sera renvoyée à l'appelant de la fonction. Si l'expression définissant la valeur de retour de la fonction est absente, la valeur `undefined` sera renvoyée. Par exemple, voici une fonction qui renvoie le carré de son argument `x` (où `x` est un nombre) :


```js
function carre(x) {
  return x \* x;
}
var demo = carre(3);
// demo vaudra alors 9
```


Les instructions qui suivent causeront chacune l'arrêt de l'exécution d'une fonction :


```js
return;
return true;
return false;
return x;
return x + y / 3;
```

### Ajout automatique de point-virgule

L'instruction `return` peut être impactée par l'ajout automatique de point-virgule (*ASI* en anglais). Il est interdit d'avoir un caractère de fin de ligne entre le mot-clé `return` et l'expression :


```js
return;
a + b;
```


Après ASI, cela sera transformé en :


```js
return;
a + b;
// Avertissement console : "expression non accessible
// après une instruction return sans point-virgule"
```


**Note :** À partir de Gecko 40, un avertissement sera affiché dans la console si l'analyse du code trouve une instruction semblable à une expression après une instruction `return` sans point-virgule. Voir le bug Firefox 1005110 pour plus d'informations.

Pour éviter ce problème et l'insertion automatique, on peut, si besoin, utiliser des parenthèses.


```js
return (
  a + b;
);
```

Exemples
--------

### Utiliser `return`

La fonction suivante renvoie le carré de son argument :


```js
function carré(x) {
  return x \* x;
}
```

### Interrompre une fonction

Une fonction s'arrête immédiatement à l'instant où l'instruction `return` est traitée.


```js
function compteur() {
  for (var compte = 1; ; compte++) {
    // boucle infinie
    console.log(compte + "A"); // jusqu'à 5
    if (compte === 5) {
      return;
    }
    console.log(compte + "B"); // jusqu'à 4
  }
  console.log(compte + "C"); // cette instruction n'est jamais utilisée
}

compteur();

// Résultat dans la console :
// 1A
// 1B
// 2A
// 2B
// 3A
// 3B
// 4A
// 4B
// 5A
```

### Renvoyer une fonction

Pour en savoir plus sur les fermetures (*closures*), voir cet article sur les fermetures.


```js
function magique() {
  return function calc(x) {
    return x \* 42;
  };
}

var réponse = magique();
réponse(1337); // 56154
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-return-statement |

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

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

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

* Les fonctions
* Les fermetures (closures)
debugger
========

L'instruction **`debugger`** permet de faire appel à un outil de débogage (qui peut par exemple permettre de placer un point d'arrêt). Si cette fonctionnalité de débogage n'est pas disponible, l'instruction n'aura aucun effet.

Syntaxe
-------


```js
debugger;
```

Exemples
--------

Dans l'exemple qui suit, on utilise un code avec l'instruction `debugger` qui permet de démarrer un débogueur (s'il existe) lorsque la fonction est appelée :


```js
function codeProbablementBogue() {
  debugger;
  // exécuter des instructions qu'on veut
  // examiner, exécuter pas à pas etc.
}
```


Lorsque le débogueur est lancé, l'exécution est interrompue au niveau de l'instruction `debugger`. Cela agit comme un point d'arrêt dans le code du script :

![Pause sur une instruction debugger.](/fr/docs/Web/JavaScript/Reference/Statements/debugger/screen_shot_2014-02-07_at_9.14.35_am.png)

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-debugger-statement |

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

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

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

* Le débogueur des outils de développement Firefox
while
=====

L'instruction **`while`** permet de créer une boucle qui s'exécute tant qu'une condition de test est vérifiée. La condition est évaluée avant d'exécuter l'instruction contenue dans la boucle.

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

Syntaxe
-------


```js
while (condition)
  instruction
```


`condition`

Une expression qui est évaluée avant chaque passage dans la boucle. Si cette expression est évaluée à vrai, `instruction` est exécutée. Lorsque la condition n'est pas vérifiée, l'exécution se poursuit avec l'instruction qui suit la boucle `while`.

`instruction`

Une instruction optionnelle qui doit être exécutée tant que la condition d'entrée est vérifiée. Afin d'exécuter plusieurs instructions au sein de la boucle, on utilisera généralement un bloc d'instructions (`{ /* … */ }`) pour les regrouper.

**Note :** On pourra utiliser l'instruction `break` afin d'arrêter une boucle avant que la condition soit vérifiée.

Exemples
--------

### Utiliser `while`

La boucle `while` qui suit s'exécute tant que `n` est strictement inférieur à 3.


```js
let n = 0;
let x = 0;

while (n < 3) {
  n++;
  x += n;
}
```


À chaque itération, la boucle incrémente la valeur de `n` et l'ajoute à `x`. Ainsi, `x` et `n` prennent les valeurs suivantes :

* Après la première itération : `n` = 1 et `x` = 1
* Après la deuxième itération : `n` = 2 et `x` = 3
* Après la troisième itération : `n` = 3 et `x` = 6

Une fois que la troisième itération est exécutée, la condition `n` < 3 n'est plus vérifiée et donc la boucle se termine.

### Attention aux affectations dans les conditions

La condition passée à l'instruction correspond généralement à un test. Si on oublie un signe égal `=`, un test d'égalité ou de comparaison peut devenir une affectation et entraîner un comportement inattendu avec une boucle infinie.

Par exemple, le fragment qui suit causera une boucle infinie :


```js
const seuil = 14;
let compteur = 0;
while ((compteur = seuil)) {
  compteur++;
  /\* Faire quelque chose avec compteur \*/
}
```


Ici, il s'agit de corriger le test en utilisant le bon opérateur de comparaison :


```js
const seuil = 14;
let compteur = 0;
while (compteur <= seuil) {
  compteur++;
  /\* Faire quelque chose avec compteur \*/
}
```


Si on veut explicitement utiliser une affectation comme condition pour la boucle `while`, la convention veut d'ajouter une paire de parenthèses (correspondant à l'opérateur de groupement) autour de l'instruction d'affectation afin d'afficher clairement l'intention, idéalement en utilisant la valeur de retour de cette affectation pour faire la comparaison :


```js
const iterator = document.createNodeIterator(document, NodeFilter.SHOW\_COMMENT);
let currentNode;
while ((currentNode = iterator.nextNode()) !== null) {
  console.log(currentNode.textContent.trim());
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-while-statement |

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

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

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

* `do...while`
* `for`
* `break`
* `continue`
Incrémentation (++)
===================

L'opérateur d'incrémentation (`++`) permet d'incrémenter (c'est-à-dire d'ajouter un) à son opérande et de renvoyer une valeur qui est le résultat avant ou après la modification.

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

Syntaxe
-------


```js
Opérateur : x++ ou ++x
```

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

Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans `x++`, l'opérateur incrémentera la valeur et renverra la valeur avant l'incrément.

Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans `++x`, l'opérateur incrémentera la valeur et renverra la valeur après l'incrément.

Exemples
--------

### Incrément en suffixe


```js
let x = 3;
let y = x++;

// y = 3
// x = 4
```

### Incrément en préfixe


```js
let a = 2;
let b = ++a;

// a = 3
// b = 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-increment-operator |

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

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

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

* Opérateur d'addition
* Opérateur de soustraction
* Opérateur de division
* Opérateur de multiplication
* Opérateur de reste
* Opérateur d'exponentiation
* Opérateur de décrémentation
* Opérateur de négation unaire
* Opérateur de plus unaire
Décrémentation (--)
===================

L'opérateur de décrémentation (`--`) permet de décrémenter (c'est-à-dire de soustraire un) son opérande et renvoie une valeur qui est le résultat avant ou après la modification.

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

Syntaxe
-------


```js
Opérateur : x-- ou --x
```

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

Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans `x--`, l'opérateur décrémentera la valeur et renverra la valeur avant l'incrément.

Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans `--x`, l'opérateur décrémentera la valeur et renverra la valeur après l'incrément.

Exemples
--------

### Décrément en suffixe


```js
let x = 3;
let y = x--;

// y = 3
// x = 2
```

### Décrément en préfixe


```js
let a = 2;
let b = --a;

// a = 1
// b = 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-decrement-operator |

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

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

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

* Opérateur d'addition
* Opérateur de soustraction
* Opérateur de division
* Opérateur de multiplication
* Opérateur de reste
* Opérateur d'exponentiation
* Opérateur d'incrémentation
* Opérateur de négation unaire
* Opérateur de plus unaire
Supérieur strict (>)
====================

L'opérateur supérieur strict (`>`) renvoie `true` si l'opérande gauche est strictement supérieur à l'opérande droit et `false` sinon.

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

Syntaxe
-------


```js
x > y;
```

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

Les opérandes sont comparés avec l'algorithme de comparaison abstraite relationnelle. Voir la documentation de l'opérateur inférieur strict pour un résumé de cet algorithme.

Exemples
--------

### Comparaison numérique


```js
console.log(5 > 3); // true
console.log(3 > 3); // false
console.log(3 > 5); // false
```

### Comparaison entre un nombre et un BigInt


```js
console.log(5n > 3); // true
console.log(3 > 5n); // false
```

### Comparaison entre chaînes de caractères


```js
console.log("a" > "b"); // false
console.log("a" > "a"); // false
console.log("a" > "3"); // true
```

### Comparaison entre nombres et chaînes de caractères


```js
console.log("5" > 3); // true
console.log("3" > 3); // false
console.log("3" > 5); // false

console.log("coucou" > 5); // false
console.log(5 > "coucou"); // false

console.log("5" > 3n); // true
console.log("3" > 5n); // false
```

### Comparaison avec des booléens, null, undefined, NaN


```js
console.log(true > false); // true
console.log(false > true); // false

console.log(true > 0); // true
console.log(true > 1); // false

console.log(null > 0); // false
console.log(1 > null); // true

console.log(undefined > 3); // false
console.log(3 > undefined); // false

console.log(3 > NaN); // false
console.log(NaN > 3); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

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

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

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

* L'opérateur supérieur ou égal
* L'opérateur inférieur strict
* L'opérateur inférieur ou égal
Expression async function
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
Le mot-clé **`async function`** peut être utilisé pour définir une fonction asynchrone au sein d'une expression.

**Note :** Il est aussi possible de définir une fonction asynchrone en utilisant une instruction `async function`.

Syntaxe
-------


```js
async function [name]([param1[, param2[, …, paramN]]]) {
  instructions
}
```

### Paramètres

`name`

Le nom de la fonction. Il est facultatif et s'il n'est pas utilisé, la fonction est *anonyme*. Le nom utilisé est uniquement local pour le corps de la fonction.

`paramN`

Le nom d'un argument à passer à la fonction.

`instructions`

Les instructions qui composent le corps de la fonction.


**Note :** À partir d'ES2015 (ES6), il est aussi possible d'utiliser des fonctions fléchées pour les expressions de fonction asynchrone.

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

Une expression `async function` est très proche, et partage quasiment la même syntaxe avec une instruction async function. La différence principale entre une expression async `function` et une instruction async `function` est qu'on peut omettre le nom de la fonction dans les expressions `async function`. On peut donc utiliser une expression `async function` afin de créer une *IIFE* (pour *Immediately Invoked Function Expression*) qu'on appelle au moment de sa définition. Voir également le chapitre sur les fonctions pour plus d'informations.

Exemples
--------

### Exemple simple


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

(async function (x) {
  // fonction asynchrone immédiatement appelée
  var a = resolveAfter2Seconds(20);
  var b = resolveAfter2Seconds(30);
  return x + (await a) + (await b);
})(10).then((v) => {
  console.log(v); // affiche 60 après 2 secondes.
});

var add = async function (x) {
  var a = await resolveAfter2Seconds(20);
  var b = await resolveAfter2Seconds(30);
  return x + a + b;
};

add(10).then((v) => {
  console.log(v); // affiche 60 après 4 secondes.
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

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

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

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

* `async function`
* L'objet `AsyncFunction`
* `await`