recursal/MDN huggingface dataset:
Inférieur strict (<)
====================

L'opérateur inférieur strict (`<`) renvoie `true` si son opérande gauche est strictement inférieur à son 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 résumé comme suit :

* Tout d'abord, les objets sont convertis en valeurs primitives avec `Symbol.ToPrimitive` en utilisant le paramètre `hint` avec la valeur `'number'`.
* Si les deux valeurs sont des chaînes de caractères, elles sont comparées comme telles selon les valeurs des codes Unicode qu'elles contiennent.
* Sinon, le moteur JavaScript tente de convertir les valeurs primitives non-numériques en valeurs numériques :
    + Les valeurs booléennes `true` et `false` sont respectivement converties en 1 et 0.
    + `null` est converti en 0.
    + `undefined` est converti en `NaN`.
    + Les chaînes de caractères sont converties en fonction de la valeur qu'elles contiennent et, si elles ne contiennent pas de valeurs numériques, elles sont converties en `NaN`.
* Si l'une des valeurs vaut `NaN`, l'opérateur renverra `false`.
* Sinon, les valeurs sont comparées numériquement.
Exemples
--------

### Comparaison numérique


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

### Comparaison entre un nombre et un BigInt


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

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


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

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


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

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

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

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


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

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

console.log(null < 0); // false
console.log(null < 1); // 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 strict
* L'opérateur supérieur ou égal
* L'opérateur inférieur ou égal
Affectation après multiplication (\*=)
======================================

L'opérateur de multiplication et d'affectation (`*=`) multiplie une variable fournie par l'opérande gauche par la valeur fournie par l'opérande droit puis affecte le résultat de l'opération à 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 de multiplication et d'affectation


```js
let truc = 5;
truc \*= 2; // 10
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 de multiplication
Expression function\*
=====================

Le mot-clé **`function*`** peut être utilisé pour définir une fonction génératrice à l'intérieur d'une expression.

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

Syntaxe
-------


```js
function\* [nom]([param1[, param2[, …, paramN]]]) {
  instructions
}
```

### Paramètres

`nom`

Le nom de la fonction. Ce paramètre est optionnel, auquel cas la fonction sera une fonction *anonyme*. Le nom sera local par rapport au corps de la fonction.

`paramN`

Le nom d'un argument à passer à la fonction. Une fonction peut avoir jusqu'à 255 arguments.

`instructions`

Les instructions qui forment le corps de la fonction.

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

Une expression `function*` est très semblable à une instruction `function*`, elle possède également une syntaxe similaire. La différence principale entre une expression `function*` et une instruction `function*` est le nom de la fonction. En effet, dans les expressions, le nom peut être omis pour créer une fonction génératrice *anonyme*. Voir également le chapitre sur les fonctions pour plus d'informations.

Exemples
--------

L'exemple qui suit illustre comment définir une génératrice anonyme et l'affecter à une variable `x`. Cette fonction génèrera le carré de son argument :


```js
var x = function\* (y) {
  yield y \* y;
};
```

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

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

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

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

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

* L'instruction `function*`
* L'objet `GeneratorFunction`
* Le protocole itérateur (en-US)
* `yield`
* `yield*`
* L'objet `Function`
* L'instruction `function`
* L'expression `function`
* Fonctions et portée des fonctions
Décalage binaire à droite (>>)
==============================

L'opérateur de **décalage binaire à droite (`>>`)** décale la séquence de bits représentée par le premier opérande d'autant de bits vers la droite que le nombre indiqué par le second opérande. Les bits en excès à droite sont écartés. Pour le remplissage des bits par la gauche, c'est le bit le plus à gauche initialement qui est recopié autant de fois que nécessaire. Aussi, le bit le plus à gauche dans le résultat sera le même que le bit le plus à gauche de l'opérande et les deux valeurs auront donc le même signe.

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

Syntaxe
-------


```js
a >> b;
```

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

Cet opérateur décale les bits de la valeur fournie par le premier opérande d'autant de fois qu'indiqué par le deuxième opérande. Les bits en excès à droite sont écartés et pour les bits les plus à gauche, c'est le bit initialement le plus à gauche qui est dupliqué. On garde ainsi le même signe entre la valeur du premier opérande et la valeur fournie par le résultat.

Ainsi, `9 >> 2` donnera `2` :


```js
       9 (base 10): 00000000000000000000000000001001 (base 2)
                    --------------------------------
  9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
```


De même, `-9 >> 2` donnera `-3`, car le signe est préservé :


```js
       -9 (base 10): 11111111111111111111111111110111 (base 2)
                     --------------------------------
  -9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
```

Exemples
--------

### Utiliser le décalage à droite


```js
9 >> 2; // 2
-9 >> 2; // -3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-signed-right-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 à droite et d'affectation
Exponentiation (\*\*)
=====================

L'opérateur d'exponentiation (`**`) fournit le résultat obtenu lorsqu'on élève le premier opérande à la puissance indiquée par le second. Il est équivalent `Math.pow` exception faite que cet opérateur permet également d'utiliser des valeurs BigInt comme opérandes.

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

Syntaxe
-------


```js
Opérateur: var1 \*\* var2;
```

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

L'opérateur d'exponentiation est associatif à droite : `a ** b ** c` est équivalent à `a ** (b ** c)`.

Pour la plupart des langages possédant un opérateur d'exponentiation (ex. PHP, Python, etc.), l'opérateur d'exponentiation possède une précédence plus élevée que les opérateurs unaires (comme l'addition unaire `+` ou la soustraction unaire `-`). Il existe toutefois quelques exceptions comme Bash, où `**` possède une précédence inférieure à celles des opérateurs unaires.

En JavaScript, il est impossible d'écrire une expression d'exponentiation ambigüe : on ne peut pas placer un opérateur unaire (`+/-/~/!/delete/void/typeof`) avant le nombre servant de base, cela provoquera une exception `SyntaxError`.


```js
-2 \*\* 2;
// 4 en Bash, -4 pour d'autres langages.
// Invalide en JavaScript car l'opération est ambigüe.

-(2 \*\* 2);
// -4 en JavaScript, les parenthèses évitent l'ambiguité.
```


Attnetion, certains langages de programmation utilisent l'accent circonflexe `^` pour exprimer l'exponentiaion mais JavaScript utilise ce symbole pour l'opérateur binaire OU exclusif (XOR) (en-US).

Exemples
--------

### Exponentiation simple


```js
2 \*\* 3; // 8
3 \*\* 2; // 9
3 \*\* 2.5; // 15.588457268119896
10 \*\* -1; // 0.1
NaN \*\* 2; // NaN
```

### Associativité


```js
2 \*\* 3 \*\* 2; // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### Avec les opérateurs unaires

Pour prendre l'opposé du résultat :


```js
-(2 \*\* 2); // -4
```


Pour forcer le signe de la base en négatif :


```js
(-2) \*\* 2; // 4
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-exp-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 multiplication
* Opérateur de division
* Opérateur de reste
* Opérateur d'incrémentation
* Opérateur de décrémentation
* Opérateur de négation unaire
* Opérateur plus unaire
Égalité stricte (===)
=====================

L'opérateur d'égalité stricte (`===`) vérifie si ses deux opérandes sont égaux et renvoie un booléen correspondant au résultat. À la différence de l'opérateur d'égalité, l'opérateur d'égalité stricte considère toujours des opérandes de types différents comme étant différents.

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

Syntaxe
-------


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

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

Les opérateurs d'égalité stricte (`===` et `!==`) utilisent l'algorithme de comparaison d'égalité stricte pour comparer deux opérandes.

* Si les opérandes sont de types différents, on renvoie `false`.
* Si les deux opérandes sont des objets, on renvoie `true` uniquement s'ils réfèrent au même objet.
* Si les deux opérandes valent `null` ou si les deux opérandes valent `undefined`, on renvoie `true`.
* Si au moins l'un des opérandes vaut `NaN`, on renvoie `false`.
* Sinon, on compare la valeur des deux opérandes :
    + Les nombres doivent avoir la même valeur. `+0` and `-0` sont considérés comme égaux.
    + Les chaînes de caractères doivent avoir les mêmes caractères, dans le même ordre.
    + Les booléens doivent avoir la même valeur (tous les deux `true` ou tous les deux `false`).

La différence fondamentale avec l'opérateur d'égalité (`==`) est que, lorsque les opérandes sont de types différents, `==` tentera une conversion vers un type commun avant la comparaison.

Exemples
--------

### Comparaison d'opérandes de même type


```js
console.log("hello" === "hello"); // true
console.log("hello" === "hola"); // false

console.log(3 === 3); // true
console.log(3 === 4); // false

console.log(true === true); // true
console.log(true === false); // false

console.log(null === null); // true
```

### Comparaison d'opérandes de types différents


```js
console.log("3" === 3); // false

console.log(true === 1); // false

console.log(null === undefined); // false
```

### Comparaison d'objets


```js
const objet1 = {
  name: "coucou",
};

const objet2 = {
  name: "coucou",
};

console.log(objet1 === objet2); // false
console.log(objet1 === objet1); // true
```

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'inégalité
* L'opérateur d'égalité
* L'opérateur d'inégalité stricte
Expression async function\*
===========================

Les mots-clés **`async function*`** peuvent être utilisés afin de créer une fonction génératrice asynchrone au sein d'une expression.

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

Syntaxe
-------


```js
async function\* (param0) {
  instructions
}
async function\* (param0, param1) {
  instructions
}
async function\* (param0, param1, /\* … ,\*/ paramN) {
  instructions
}

async function\* nom(param0) {
  instructions
}
async function\* nom(param0, param1) {
  instructions
}
async function\* nom(param0, param1, /\* … ,\*/ paramN) {
  instructions
}
```

### Paramètres

`nom` Facultatif

Le nom de la fonction. S'il est absent, la fonction est *anonyme*. Le nom est uniquement local au corps de la fonction.

`paramN` Facultatif

Le nom d'un argument à passer à la fonction. Une fonction peut avoir jusqu'à 255 arguments.

`instructions` Facultatif

Les instructions qui forment le corps de la fonction.

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

Une expression `async function*` est très proche et possède quasiment la même syntaxe qu'une instruction `async function*`. La différence principale entre une expression `async function*` et une instruction `async function*` est que *le nom de la fonction* peut être omis dans les expressions `async function*` afin de créer des fonctions génératrices asynchrones *anonymes*. Voir aussi le chapitre sur les fonctions en JavaScript pour plus d'informations.

Exemples
--------

### Utiliser async function\*

L'exemple qui suit définit une fonction génératrice asynchrone anonyme et l'affecte à `x`. Cette fonction génère le carré de son argument :


```js
const x = async function\* (y) {
  yield Promise.resolve(y \* y);
};
x(6)
  .next()
  .then((res) => console.log(res.value)); // affiche 36
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-generator-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'objet `AsyncGeneratorFunction` (en-US)
* Le protocole itérateur
* L'objet `GeneratorFunction`
* `yield`
* `yield*`
* L'objet `Function`
* Les fonctions en JavaScript
Affectation après OU logique (||=)
==================================

L'opérateur d'affectation après OU logique (`x ||= y`) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est équivalent à faux (*falsy*).

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

Syntaxe
-------


```js
expr1 ||= expr2;
```

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

### Évaluation en court-circuit

L'opérateur OU logique fonctionne ainsi :


```js
x || y;
// renvoie x lorsque x est équivalent à vrai
// renvoie y lorsque x n'est pas équivalent à vrai
```


L'opérateur OU logique peut utiliser un court-circuit : le second opérande est uniquement évalué si le premier opérande n'est pas équivalent à vrai.

L'opérateur d'affectation après OU logique observe les mêmes règles : l'affectation a uniquement lieu si l'opération logique a besoin d'évaluer l'opérande droit. Autrement dit, `x ||= y` est équivalent à :


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


En revanche, il n'est pas équivalent à l'expression suivante qui effectue, quoi qu'il arrive, une affectation :


```js
x = x || y;
```


On notera que ce comportement est différent entre les opérateurs binaires et les opérateurs logiques.

Exemples
--------

### Affecter une valeur par défaut

Dans l'exemple qui suit, si `paroles` est vide, on y place une valeur par défaut :


```js
document.getElementById("paroles").textContent ||= "Aucune parole.";
```


Ici, la notion de court-circuit est utile, car l'élément ne sera pas mis à jour si ce n'est pas nécessaire. Il n'y aura pas d'effet de bord indésiré comme une autre étape de rendu ou la perte du focus, etc.

Attention toutefois à la valeur qu'on teste. Si on souhaite affecter une valeur lorsqu'on rencontre une chaîne de caractère vide (équivalente à faux), on pourra utiliser `||=`. Sinon, si on souhaite uniquement distinguer `null` ou `undefined`, on utilisera l'opérateur `??=`.

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

* L'opérateur OU logique (||)
* L'opérateur de coalescence des nuls (`??`)
* L'opérateur d'affectation après OU binaire (`|=`)
* Le type `Boolean`
* *Truthy*
* *Falsy*
OU binaire (|)
==============

L'opérateur OU binaire (`|`) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un `1` pour chaque position où au moins un des bits des deux opérandes vaut `1`.

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

Syntaxe
-------


```js
a | b;
```

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

Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une séquence de bits. Les nombres sur plus de 32 bits ont leurs bits en excès écartés. Par exemple, l'entier suivant nécessite plus de 32 bits pour être représenté et il sera converti en un entier sur 32 bits :
```

Avant:  11100110111110100000000000000110000000000001
Après:              10100000000000000110000000000001
```


Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsqu'au moins un de ces bit vaut 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.

La table de vérité pour l'opérateur OU est :

| a | b | a OU b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
```

     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------

14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
```


Utiliser le OU binaire avec n'importe quel nombre `x` d'une part et `0` renverra toujours `x`.

Exemples
--------

### Utiliser l'opérateur OU binaire


```js
// 9 (00000000000000000000000000001001)
// 14 (00000000000000000000000000001110)

14 | 9;
// 15 (00000000000000000000000000001111)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseORExpression |

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 ET binaire et d'affectation
NON logique (!)
===============

L'opérateur logique NON (`!`) prend l'opposé logique de la valeur fournie par son opérande. Vrai devient faux et vice versa. Il est généralement utilisé avec les booléens. Lorsque cet opérateur est utilisé avec une valeur non-booléenne, il renvoie `false` si son opérande peut être converti en `true` et `true` sinon.

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

Syntaxe
-------


```js
!expr;
```

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

Cet opérateur renvoie `false` si son opérande peut être converti en `true` ; sinon il renvoie `true`.

Si une valeur peut être convertie en `true`, on dira en anglais qu'elle est *truthy*. À l'inverse, si elle peut être convertie en `false`, on dira en anglais qu'elle est *falsy*.

Voici des exemples d'expression qui peuvent être converties en `false` :

* `null` ;
* `NaN` ;
* `0` ;
* la chaîne vide (`""` ou `''` ou ````) ;
* `undefined`.

Bien que l'opérateur `!` puisse être utilisé avec des opérandes non booléens, sa valeur de retour sera toujours un booléen. Pour convertir une valeur (ou une expression) en sa valeur booléenne correspondante, on pourra utiliser un double NON ou le constructeur `Boolean`.

Exemples
--------

### Utiliser NON

Le code suivant illustre l'utilisation de l'opérateur `!` pour le NON logique.


```js
let n1 = !true; // !t renvoie false
let n2 = !false; // !f renvoie true
let n3 = !""; // !f renvoie true
let n4 = !"Cat"; // !t renvoie false
```

### Double NON (`!!`)

Il est possible d'utiliser deux opérateurs NON à la suite pour convertir n'importe quelle valeur en booléen selon qu'elle est *truthy* ou *falsy*.

Une conversion équivalente pourra être obtenue avec le constructeur `Boolean`.


```js
let n1 = !!true; // !!truthy renvoie true
let n2 = !!{}; // !!truthy renvoie true : tout objet est truthy
let n3 = !!new Boolean(false); // Attention, un objet Boolean est toujours truthy !
let n4 = !!false; // !!falsy renvoie false
let n5 = !!""; // !!falsy renvoie false
let n6 = !!Boolean(false); // !!falsy renvoie false
```

### Équivalence booléenne de la double négation

L'expression qui suit, utilisée avec des booléens :


```js
!!bCondition;
```


est toujours égale à :


```js
bCondition;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-logical-not-operator |

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

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

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

* `Boolean`
* Truthy
* Falsy
Inférieur ou égal (<=)
======================

L'opérateur inférieur ou égal (`<=`) renvoie `true` si l'opérande gauche est inférieur ou égal à 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); // false
console.log(3 <= 3); // true
console.log(3 <= 5); // true
```

### Comparaison entre un nombre et un BigInt


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

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


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

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


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

console.log("coucou" <= 5); // false
console.log(5 <= "coucou"); // false
```

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


```js
console.log(true <= false); // false
console.log(true <= true); // true
console.log(false <= true); // true

console.log(true <= 0); // false
console.log(true <= 1); // true

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

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 supérieur strict
* L'opérateur inférieur strict