recursal/MDN huggingface dataset:
import.meta
===========

L'objet **`import.meta`** est une méta-propriété qui expose des métadonnées d'un module JavaScript spécifiques au contexte. Cet objet contient des informations à propos du module, telles que l'URL du module.

Syntaxe
-------


```js
import.meta;
```

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

L'objet `import.meta` se compose d'un mot-clé `"import`", suivi d'un point, puis du nom de propriété `"meta"`. En temps normal, "`import."` serait utilisé comme contexte pour un accès à une propriété mais, dans ce cas, `"import."` n'est pas, à proprement parler, un objet.

L'objet `import.meta` est créé par l'implémentation ECMAScript avec un prototype qui vaut `null`. Cet objet est extensible et ses propriétés sont accessibles en écriture, configurables et énumérables.

Exemples
--------

Soit un module `mon-module.js`


```html
<script type="module" src="mon-module.js"></script>
```


Il est possible d'accéder aux métadonnées du module grâce à l'objet `import.meta`.


```js
console.log(import.meta); // { url: "file:///home/user/mon-module.js" }
```


Cet objet contient une propriété `url` qui indique l'URL de base du module. Dans le cas des scripts externes, celle-ci sera l'URL à partir de laquelle le script a été obtenu. Pour les scripts écrits dans le document, ce sera l'URL de base du document englobant.

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |

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

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

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

* `import`
* `export`
Supérieur ou égal (>=)
======================

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

### Comparaison entre un nombre et un BigInt


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

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


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

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


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

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

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


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

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

console.log(null >= 0); // true
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 strict
* L'opérateur inférieur strict
* L'opérateur inférieur ou égal
Affectation après coalescence des nuls (??=)
============================================

L'opérateur d'affectation après coalescence des nuls (`x ??= y`) effectue une affectation uniquement si l'opérande de gauche (`x`) vaut `null` ou `undefined`.

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

Syntaxe
-------


```js
expr1 ??= expr2;
```

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

### Évaluation en court-circuit

L'opérateur de coalescence des nuls est évalué de gauche à droite et le moteur teste s'il est possible d'utiliser un court-circuit grâce à la règle suivante :

`(une expression qui renvoie null ou undefined) ?? expr` sera court-circuité pour fournir l'opérande gauche si celle-ci ne vaut ni `null` ni `undefined`.

Ce « court-circuit » implique que l'expression `expr` **n'est pas évaluée** si ce n'est pas nécessaire. Ainsi, tout effet de bord lié à celle-ci n'aura pas lieu (par exemple, si `expr` appelle une fonction, cette dernière n'est pas exécutée).

L'opérateur d'affectation après coalescence des nuls obéit également à cette logique. Ainsi, `x ??= y` sera équivalent à :


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


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


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

Exemples
--------

### Utiliser l'opérateur d'affectation après coalescence des nuls


```js
function config(options) {
  options.duration ??= 100;
  options.speed ??= 25;
  return options;
}

config({ duration: 125 }); // { duration: 125, speed: 25 }
config({}); // { duration: 100, speed: 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
----------

* L'opérateur de coalescence des nuls (`??`)
* *Nullish* (en-US)
* *Truthy*
* *Falsy*
ET binaire (&)
==============

L'opérateur ET 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ù les bits des deux opérandes valent `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. Lorsque les deux valent 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 ET est :

| a | b | a ET b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |


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

14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
```


Utiliser un ET binaire sur n'importe quel nombre `x` d'une part et `0` d'autre part renverra `0`.

Exemples
--------

### Utiliser l'opérateur ET binaire


```js
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
5 & 2; // 0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseANDExpression |

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
Décalage binaire à droite non-signé (>>>)
=========================================

L'opérateur de **décalage binaire à droite non-signé (`>>>`)** décale la séquence de bits formée par le premier opérande d'autant de bits vers la droite que la valeur indiquée par le second opérande. Les bits en excès à droite sont écartés et ce sont des zéros qui sont ajoutés à gauches. Le bit de signe devient alors nécessairement `0` et le résultat est donc positif. À la différence des autres opérateurs binaires, cet opérateur renvoie un entier non-signé sur 32 bits.

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

Syntaxe
-------


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

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

Ce opérateur décale les bits du premier opérande vers la droite, selon la valeur du deuxième opérande. Les bits dépassant à droite sont éliminés tandis que des zéros sont ajoutés à gauche. Le bit de signe vaut alors `0` et en conséquence le résultat est positif. La valeur fournie par cet opérateur, à la différence des autres opérateurs binaires, est une valeur entière sur 32 bits non-signée.

Pour les nombres positifts, le décalage binaire à droite et le décalage binaire à droite non-signés renverront le même résultat. Par exemple, `9 >>> 2` renvoie 2, également renvoyé par `9 >> 2`:


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


Toutefois, ce n'est pas le cas pour les nombres négatifs : `-9 >>> 2` renverra 1073741821, qui est différent de `-9 >> 2` (qui renvoie `-3`) :


```js
        -9 (base 10): 11111111111111111111111111110111 (base 2)
                      --------------------------------
  -9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
```

Exemples
--------

### Utiliser le décalage à droite non-signé


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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-unsigned-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 non-signé et d'affectation
Affectation après soustraction (-=)
===================================

L'opérateur d'affectation après soustraction (`-=`) calcule la soustraction de l'opérande gauche par l'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 de soustraction et d'affectation


```js
let truc = 5;
truc -= 2; // 3
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 soustraction
Reste (%)
=========

L'opérateur du reste (`%`) renvoie le reste de la division de l'opérande gauche par l'opérande droit. Le résultat a toujours le signe du numérateur.

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

Bien que dans la plupart des langages, `%` est un opérateur de reste, pour d'autres (par exemple Python, Perl) c'est un opérateur de modulo. Lorsqu'on utilise des valeurs positives, les deux opérateurs sont équivalents mais lorsque le numérateur et de dénominateur ont des signes différents, le reste et le modulo fourniront des signes différents. Pour obtenir une opération équivalente au modulo en JavaScript, on pourra utiliser `((a % n ) + n ) % n`.

Syntaxe
-------


```js
Opérateur: var1 % var2;
```

Exemples
--------

### Reste avec numérateur positif


```js
12 % 5; // 2
1 % -2; // 1
1 % 2; // 1
2 % 3; // 2
5.5 % 2; // 1.5
```

### Reste avec numérateur négatif


```js
-12 % 5; // -2
-1 % 2; // -1
-4 % 2; // -0
```

### Reste avec NaN


```js
NaN % 2; // NaN
```

### Reste avec l'infini


```js
Infinity % 2; // NaN
Infinity % 0; // NaN
Infinity % Infinity; // NaN
```

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 multiplication
* Opérateur de division
* 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 reste (%=)
============================

L'opérateur de reste et d'affectation (`%=`) calcule le reste de la division de l'opérande gauche par l'opérande droit et affecte ce 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 de reste et d'affectation


```js
let truc = 5;
truc %= 2; // 1
truc %= "toto"; // NaN
truc %= 0; // 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 reste
Affectation après décalage à droite (>>=)
=========================================

L'opérateur de décalage à droite et d'affectation (`>>=`) décale la séquence de bits indiquée par l'opérande gauche d'autant de bits qu'indiqués par l'opérande droit puis affecte le résultat obtenu à 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 décalage à droite et d'affectation


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

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

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
Affectation après OU exclusif binaire (^=)
==========================================

L'opérateur d'affectation après OU exclusif (XOR) binaire (`^=`) utilise la représentation binaire des deux opérandes, effectue un OU exclusif entre chaque puis affecte le résultat obtenu à 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'affectation après OU exclusif binaire


```js
let a = 5; // 00000000000000000000000000000101
a ^= 3; // 00000000000000000000000000000011

console.log(a); // 00000000000000000000000000000110
// 6

let b = 5; // 00000000000000000000000000000101
b ^= 0; // 00000000000000000000000000000000

console.log(b); // 00000000000000000000000000000101
// 5
```

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 OU exclusif binaire
Affectation après décalage à gauche (<<=)
=========================================

L'opérateur de décalage à gauche et d'affectation (`<<=`) décale la séquence de bits représentée par l'opérande gauche d'autant de bits qu'indiqué par l'opérande droit puis affecte le résultat obtenu à 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 décalage à gauche et d'affectation


```js
let a = 5;
// 00000000000000000000000000000101

a <<= 2; // 20
// 00000000000000000000000000010100
```

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 à gauche binaire
class
=====

Une **expression de classe** est un moyen de définir une classe avec ECMASCript 2015 (ES6). Semblable aux expressions de fonctions, les expressions de classes peuvent être nommées ou anonymes. Si l'expression est nommée, le nom de la classe ne sera local que pour le corps de la fonction. Cette syntaxe n'est qu'un « sucre syntaxique » pour faciliter l'écriture du code, elle ne modifie en aucun cas le modèle d'héritage utilisé par JavaScript qui est un modèle à base de prototypes.

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

Syntaxe
-------


```js
const MaClasse = class [nomClasse] [extends autreNomClasse] {
  // corps de la classe
};
```

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

Une expression de classe utilise une syntaxe similaire à celle d'une instruction de classe. En revanche, avec les expressions de classes, il est possible de ne pas nommer la classe, ce qu'il est impossible de faire avec les instructions de classes. De plus, en utilisant les expressions de classe, on peut redéfinir/redéclarer les classes si nécessaire. Le type d'une classe sera toujours `"function"`.

Le corps d'une classe sera exécuté en mode strict (pour les instructions et les expressions de classe).

Exemples
--------

### Une expression simple

Ici, on utilise une expression de classe anonyme qu'on lie à la variable `Toto`.


```js
var Toto = class {
  constructor() {}
  truc() {
    return "Coucou monde !";
  }
};

var instance = new Toto();
instance.truc(); // "Coucou monde !"
Toto.name; // "Toto"
```

### Des expressions nommées

Si on souhaite faire référence à la classe, au sein du corps de la classe, on pourra utiliser une expression nommée. Le nom utilisé ne sera visible que depuis l'intérieur de la portée de l'expression de classe.


```js
// TBD
var Toto = class TotoNommé {
  constructor() {}
  quiEstLa() {
    return TotoNommé.name;
  }
};

var truc = new Toto();
truc.quiEstLa(); // "TotoNommmé"
TotoNommé.name; // ReferenceError
Toto.name; // "TotoNommé"
```

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 expressions `function`
* Les déclaration `class`
* Les classes
Inégalité stricte (!==)
=======================

L'opérateur d'inégalité stricte (`!==`) 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é, l'opérateur d'inégalité stricte considère toujours des opérandes de types différents comme étant différents.

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

Syntaxe
-------


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

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

L'opérateur d'inégalité stricte vérifie que ses deux opérandes ne sont pas égaux. Il s'agit de la négation de l'opérateur d'égalité stricte. Les deux expressions suivantes fourniront 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 sur l'opérateur d'égalité stricte.

À l'instar de l'opérateur d'égalité stricte, l'opérateur d'inégalité stricte considèrera toujours des opérandes de types différents comme étant différents :


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

Exemples
--------

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


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

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

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

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

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


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

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

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

### Comparaison d'objets


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

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

console.log(objet1 !== objet2); // true
console.log(objet1 !== objet1); // 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'inégalité
* L'opérateur d'égalité
* L'opérateur d'égalité stricte
Affectation après division (/=)
===============================

L'opérateur de division et d'affectation (`/=`) divise la variable fournie par l'opérande gauche par la valeur indiquée par l'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 de division et d'affectation


```js
let truc = 5;
truc /= 2; // 2.5
truc /= 2; // 1.25
truc /= 0; // Infinity
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 division
Multiplication (\*)
===================

L'opérateur de multiplication (`*`) fournit le produit de la multiplication des deux opérandes.

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

Syntaxe
-------


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

Exemples
--------

### Avec des nombres


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

### Avec l'infini


```js
Infinity \* 0; // NaN
Infinity \* Infinity; // Infinity
```

### Avec des valeurs non-numériques


```js
"foo" \* 2; // NaN
```

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