recursal/MDN huggingface dataset:
Assignement (=)
===============

L'opérateur d'assignement simple (`=`) est utilisé pour définir la valeur d'une variable. Il est possible d'ajouter une valeur à plusieurs variables en chaînant les variables.

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

Syntaxe
-------


```js
x = y;
```

Exemples
--------

### Assignement simple et variables en chaînes


```js
// On considère les variables suivantes :
var x = 5;
var y = 10;
var z = 25;

x = y;
// x est égale à 10

x = y = z;
// x, y et z sont égales à 25
```

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

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

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

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

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

* Assignment operators in the JS guide
Négation unaire (-)
===================

L'opérateur de négation unaire (`-`) se place devant son opérande et le transforme en son opposé.

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

Syntaxe
-------


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

Exemples
--------

### Avec des nombres


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

// y = -3
// x = 3
```

### Avec des valeurs non-numériques

L'opérateur de négation unaire peut être utilisé pour convertir une valeur non-numérique en nombre.


```js
const x = "4";
const y = -x;

// y = -4
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-minus-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 décrémentation
* Opérateur plus unaire
Affectation après exponentiation (\*\*=)
========================================

L'opérateur d'exponentiation et d'affectation (`**=`) élève la valeur de la variable fournie par son opérande gauche à la puissance indiquée par son opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.

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

Syntaxe
-------


```js
Opérateur: x \*\*= y;
Signification: x = x \*\* y;
```

Exemples
--------

### Utiliser l'opérateur d'exponentiation et d'affectation


```js
let truc = 5;
truc \*\*= 2; // 25
truc \*\*= "toto"; // NaN
```

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

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

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

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

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

* Les opérateurs d'affectation dans le guide JavaScript
* L'opérateur d'exponentiation
await
=====

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
L'opérateur **`await`** permet d'attendre la résolution d'une promesse (`Promise`). Il ne peut être utilisé qu'au sein d'une fonction asynchrone (définie avec l'instruction `async function`).

Syntaxe
-------


```js
[rv] = await expression;
```


`expression`

Une promesse (`Promise`) ou toute autre valeur dont on souhaite attendre la résolution.

`rv`

La valeur de retour qui est celle de la promesse lorsqu'elle est résolue ou la valeur de l'expression lorsque celle-ci n'est pas une promesse.

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

L'expression `await` interrompt l'exécution d'une fonction asynchrone et attend la résolution d'une promesse. Lorsque la promesse est résolue (tenue ou rompue), la valeur est renvoyée et l'exécution de la fonction asynchrone reprend. Si la valeur de l'expression n'est pas une promesse, elle est convertie en une promesse résolue ayant cette valeur.

Si la promesse est rompue, l'expression `await` lève une exception avec la raison.

Exemples
--------

Si on passe une promesse à une expression `await`, celle-ci attendra jusqu'à la résolution de la promesse et renverra la valeur de résolution.


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

async function f1() {
  var x = await resolveAfter2Seconds(10);
  console.log(x); // 10
}
f1();
```


Les objets dotés d'une méthode `then()` (*thenable* en anglais) seront également résolus :


```js
async function f0() {
  const thenable = {
    then: function (resolve, \_reject) {
      resolve("résolu :)");
    },
  };
  console.log(await thenable); // résolu :)
}
f0();
```


Si la valeur n'est pas une promesse, elle est convertie en une promesse résolue :


```js
async function f2() {
  var y = await 20;
  console.log(y); // 20
}
f2();
```


Si la promesse est rejetée, la raison est fournie avec l'exception.


```js
async function f3() {
  try {
    var z = await Promise.reject(30);
  } catch (e) {
    console.log(e); // 30
  }
}
f3();
```


On peut également gérer le cas où la promesse est rejetée grâce à `Promise.prototype.catch()` :


```js
var response = await maFonctionPromesse().catch((err) => {
  console.log(err);
});
```

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
----------

* L'instruction `async function`
* L'expression `async function`
* L'objet `AsyncFunction`
L'opérateur virgule
===================

L'opérateur **virgule** permet d'évaluer chacun de ses opérandes (de la gauche vers la droite) et de renvoyer la valeur du dernier opérande.

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

Syntaxe
-------


```js
expr1, expr2, expr3…
```

### Paramètres

`expr1`, `expr2, expr3…`

Des expressions JavaScript.

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

L'opérateur virgule peut être utilisé lorsqu'on souhaite utiliser plusieurs expressions là où la syntaxe n'en attend qu'une seule. Cet opérateur est souvent utilisé dans une boucle `for` afin de fournir plusieurs paramètres.

L'opérateur virgule est à différencier de la virgule utilisée pour séparer les éléments d'un tableau ou les propriétés d'un objet ou encore les arguments d'une fonction.

Exemples
--------

SI on a un tableau à 2 dimensions appelé `monTableau`, qui possède 10 éléments ayant chacun 10 éléments, on peut utiliser le code suivant avec l'opérateur virgule afin d'incrémenter deux variables (`i` et `j`) à la fois. Attention, la virgule utilisée au sein de l'instruction `var` **n'est pas** l'opérateur virgule (car il ne peut exister au sein d'une expression) ; ici c'est un caractère spécial de l'instruction `var`. Le code qui suit affiche les éléments présents sur la diagonale de cette matrice :


```js
for (var i = 0, j = 9; i <= 9; i++, j--) {
  console.log("monTableau[" + i + "][" + j + "] = " + monTableau[i][j]);
}
```


Dans le code suivant, `a` est défini avec la valeur de `b = 3` (qui est 3) et l'expression `c = 4` est toujours évaluée et c'est ce résultat affiché dans la console du fait de la précédence et de l'associativité des opérateurs.


```js
var a, b, c;
(a = b = 3), (c = 4); // Renvoie 4 dans la console
console.log(a); // 3
```


Pour isoler la précédence de l'opérateur, on peut utiliser des parenthèses :


```js
var x, y, z;
x = ((y = 5), (z = 6)); // Renvoie 6 dans la console
console.log(x); // 6
```

### Effectuer un traitement puis renvoyer une valeur

Un autre exemple consiste à effectuer un certain traitement sur la variable puis à renvoyer le résultat. Par définition, seul le dernier élément sera renvoyé mais les instructions précédentes seront bien exécutées. AInsi, on pourrait avoir :


```js
function maFonction() {
  var x = 0;

  return (x += 1), x; // ce qui revient à renvoyer ++x
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-comma-operator |

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

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

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

* Les boucles `for`
Inégalité (!=)
==============

L'opérateur d'inégalité (`!=`) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de l'opérateur d'inégalité stricte, l'opérateur d'inégalité tente une conversion de ses opérandes avant la comparaison si ceux-ci sont de types différents.

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

Syntaxe
-------


```js
x != y;
```

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

L'opérateur d'inégalité vérifie si ses deux opérandes ne sont pas égaux. Il s'agit de la négation de l'opérateur d'égalité et les deux lignes suivantes fourniront donc toujours le même résultat :


```js
x != y;
!(x == y);
```


Pour plus de détails sur l'algorithme de comparaison utilisé, voir la page relative à l'opérateur d'égalité.

À l'instar de l'opérateur d'égalité, l'opérateur d'inégalité tentera une conversion des opérandes si ceux-ci ne sont pas de même type :


```js
3 != "3"; // false
```


Si cette conversion implicite n'est pas souhaitable et qu'on souhaite considérer des valeurs de types différents comme étant différentes, on privilégiera l'opérateur d'inégalité stricte à la place :


```js
3 !== "3"; // true
```

Exemples
--------

### Comparaison sans conversion de types


```js
1 != 2; // true
"hello" != "hola"; // true

1 != 1; // false
"hello" != "hello"; // false
```

### Comparaison avec conversion de types


```js
"1" != 1; // false
1 != "1"; // false
0 != false; // false
0 != null; // true
0 != undefined; // true
0 != !!null; // false, voir la documentation pour !!
0 != !!undefined; // false, voir la documentation pour !!
null != undefined; // false

const number1 = new Number(3);
const number2 = new Number(3);
number1 != 3; // false
number1 != number2; // true
```

### Comparaison d'objets


```js
const objet1 = { clé: "valeur" };
const objet2 = { clé: "valeur" };

objet1 != objet2; // true
objet2 != objet2; // false
```

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

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

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

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

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

* L'opérateur d'égalité
* L'opérateur d'égalité stricte
* L'opérateur d'inégalité stricte
new.target
==========

La syntaxe **`new.target`** est disponible dans toutes les fonctions et permet entre autres de tester si une fonction ou un constructeur a été appelé avec `new`. Dans les constructeurs, il fait référence au constructeur invoqué par `new`. Dans les appels de fonction « normaux », `new.target` vaut `undefined`.

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

Syntaxe
-------


```js
new.target;
```

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

La syntaxe `new.target` se compose du mot-clé `new`, suivi d'un point puis d'un nom de propriété (ici `target`). Généralement et par ailleurs, `new.` est utilisé comme contexte pour accéder à une propriété. Ici, `new.` ne fait pas réellement référence à un objet. Dans les appels de constructeurs, `new.target` fait référence au constructeur qui a été appelé par `new`. Cette syntaxe permet donc de récupérer cette valeur.

`new.target` est une méta-propriété, disponible pour toutes les fonctions. Dans les fonctions fléchées, `new.target` fait référence au `new.target` de la fonction englobante.

Exemples
--------

### Utilisation de `new.target` dans les appels de fonction

Utilisé dans les appels de fonctions « classiques » (autrement dit pour les fonctions qui ne sont pas des constructeurs), `new.target` vaut `undefined`. Cela permet de détecter si une fonction a été appelée comme constructeur avec `new` :


```js
function Toto() {
  if (!new.target) throw "Toto() doit être appelé avec new";
  console.log("Toto instancié avec new");
}

new Toto(); // affiche "Toto instancié avec new" dans la console
Toto(); // lève l'exception avec "Toto doit être appelé avec new"
```

### Utilisation de `new.target` dans les constructeurs

Utilisés dans les appels de constructeurs de classe, `new.target` fait référence au constructeur utilisé directement avec `new`. C'est également le cas quand le constructeur est présent dans une classe parente et est délégué depuis le constructeur fils :


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

var a = new A(); // affiche "A"
var b = new B(); // affiche "B"

class C {
  constructor() {
    console.log(new.target);
  }
}

class D extends C {
  constructor() {
    super();
  }
}

var c = new C(); // function C()
var d = new D(); // function D()
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

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

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

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

* Les fonctions
* Les classes
* `new`
* `this`
* Cet article sur les classes traduit en français
Addition (+)
============

L'opérateur d'addition (`+`) produit la somme de deux opérandes numériques ou la concaténation de deux chaînes de caractères.

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

Syntaxe
-------


```js
Opérateur: x + y;
```

Exemples
--------

### Addition numérique


```js
// Number + Number -> addition
1 + 2; // 3

// Boolean + Number -> addition
true + 1; // 2

// Boolean + Boolean -> addition
false + false; // 0
```

### Concaténation de chaînes de caractères


```js
// String + String -> concatenation
"toto" + "truc"; // "tototruc"

// Number + String -> concatenation
5 + "toto"; // "5toto"

// String + Boolean -> concatenation
"toto" + false; // "totofalse"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-addition-operator-plus |

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

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

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

* Opérateur de soustraction
* Opérateur de multiplication
* Opérateur de division
* Opérateur de reste
* Opérateur d'exponentiation
* Opérateur d'incrémentation
* Opérateur de décrémentation
* Opérateur de négation unaire
* Opérateur plus unaire
null
====

La valeur **`null`** est un littéral JavaScript représentant la nullité au sens où aucune valeur pour l'objet n'est présente. C'est une des valeurs primitives de JavaScript.

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

Syntaxe
-------


```js
null;
```

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

La valeur `null` est un littéral (et non pas une propriété de l'objet global telle que `undefined`). Dans certaines API, `null` est souvent utilisé en valeur de retour lorsqu'un objet est attendu mais qu'aucun objet ne convient. Lors de tests d'égalité avec `null` ou `undefined`, il faut faire attention aux différences entre les opérateurs d'égalité faible (==) et stricte (===) (on aura une conversion de type avec le premier).


```js
// toto n'existe pas, n'a pas été défini et n'a jamais été initialisé
toto;
("ReferenceError: toto is not defined");

// toto existe mais n'a ni type ni valeur
var toto = null;
console.log(toto); // null
```

### Différence entre `null` et `undefined`


```js
typeof null; // "object" (pas null pour des raisons historiques)
typeof undefined; // "undefined"
null === undefined; // false
null == undefined; // true
null === null; // true
null == null; // true
!null; // true
isNaN(1 + null); // false
isNaN(1 + undefined); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-null-value |

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

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

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

* `undefined`
* `NaN`
Soustraction (-)
================

L'opérateur de soustraction (`-`) effectue la soustraction entre les deux opérandes et fournit la différence obtenue.

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

Syntaxe
-------


```js
Opérateur: x - y;
```

Exemples
--------

### Avec des valeurs numériques


```js
5 - 3; // 2
3 - 5; // -2
```

### Avec des valeurs non-numériques


```js
"toto" - 3; // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-subtraction-operator-minus |

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 division
* Opérateur de multiplication
* Opérateur de reste
* Opérateur d'exponentiation
* Opérateur d'incrémentation
* Opérateur de décrémentation
* Opérateur de négation unaire
* Opérateur plus unaire
Division (/)
============

L'opérateur de division (`/`) fournit le quotient de l'opérande gauche (le numérateur) divisé par l'opérande droite (le dénominateur).

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

Syntaxe
-------


```js
Opérateur: x / y;
```

Exemples
--------

### Divisions simples


```js
1 / 2; // 0.5
Math.floor(3 / 2); // 1
1.0 / 2.0; // 0.5
```

### Division par zéro


```js
2.0 / 0; // Infinity
2.0 / 0.0; // Infinity, because 0.0 === 0
2.0 / -0.0; // -Infinity
```

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

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

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 décrémentation
* Opérateur de négation unaire
* Opérateur plus unaire
Affectation après décalage à droite non signé (>>>=)
====================================================

L'**opérateur de décalage à droite non signé et d'affectation** (`>>>=`) décale la séquence de bits fournie par l'opérande gauche vers la droite, d'autant de bits qu'indiqués par l'opérande droit, puis affecte le résultat de l'opération à la variable indiquée par l'opérande gauche.

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

Syntaxe
-------


```js
Opérateur: x >>>= y;
Signification: x = x >>> y;
```

Exemples
--------

### Utiliser l'opérateur de décalage à droite non signé et d'affectation


```js
let a = 5; // (00000000000000000000000000000101)
a >>>= 2; // 1 (00000000000000000000000000000001)

let b = -5; // (-00000000000000000000000000000101)
b >>>= 2; // 1073741822 (00111111111111111111111111111110)
```

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

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

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

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

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

* Les opérateurs d'affectation dans le guide JavaScript
* L'opérateur de décalage à droite
Plus unaire (+)
===============

L'opérateur de plus unaire (`+`) précède son opérande et évalue son opérande en essayant de le convertir en nombre si ce n'est pas déjà une valeur numérique.

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

Syntaxe
-------


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

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

Bien que la négation unaire (`-`) puisse également être utilisée pour convertir des valeurs non-numérique, le plus unaire est plus rapide et plus conventionnel, car il n'effectue pas d'autres opérations que la conversion. Il peut être utilisé pour convertir les représentations textuelles d'entiers ou de flottants ainsi que les valeurs `true`, `false`, et `null`. Les représentations entières au format décimal ou hexadécimal sont toutes les deux prises en charge. Les nombres négatifs sont pris en charge (hors représentation hexadécimale). L'utilisation de cet opérateur sur les valeurs de type `BigInt` déclenchera une exception `TypeError`. Si l'analyse de valeur ne permet pas de déduire une valeur numérique, le résultat sera `NaN`.

Exemples
--------

### Avec des nombres


```js
const x = 1;
const y = -1;

console.log(+x);
// 1
console.log(+y);
// -1
```

### Avec des valeurs non-numériques


```js
+true; // 1
+false; // 0
+null; // 0
+function (val) {
  return val;
}; // NaN
+1n; // throws TypeError: Cannot convert BigInt value to number
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-plus-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 décrémentation
* Opérateur de négation unaire
Décalage binaire à gauche (<<)
==============================

L'opérateur de **décalage binaire à gauche (`<<`)** décale la séquence de bits représentée par le premier opérande d'autant de bits vers la gauche que le nombre indiqué par le second opérande. Les bits en excès à gauche sont écartés et des bits à zéro sont introduits à droite.

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

Syntaxe
-------


```js
a << b;
```

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

Cet opérateur décale les bits du premier opérande vers la gauche, d'autant que le nombre indiqué par le second opérande. Les bits qui dépassent à gauche sont abandonnés et des zéros sont introduits à droite.

Ainsi, `9 << 2` donnera la valeur 36 (en base 10) :


```js
       9 (base 10): 00000000000000000000000000001001 (base 2)
                    --------------------------------
  9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
```


Le décalage binaire de tout nombre `x` de `y` bits vers la gauche donnera comme résultat `x * 2 ** y`. Par exemple, `9 << 3` pourra être reformulé en `9 * (2 ** 3) = 9 * (8) = 72`.

Exemples
--------

### Utiliser le décalage binaire à gauche


```js
9 << 3; // 72

// 9 \* (2 \*\* 3) = 9 \* (8) = 72
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-left-shift-operator |

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

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

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

* Les opérateurs binaires dans le guide JavaScript
* L'opérateur de décalage binaire à gauche et d'affectation