Expressions et opérateurs
=========================

Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés pour le langage JavaScript.

Expressions et opérateurs par catégorie
---------------------------------------

Pour une liste triée par ordre alphabétique, voir sur la barre de navigation à gauche.

### Expressions primaires

Mots-clés de base et expressions générales en JavaScript.

`this`

Le mot-clé `this` fait référence à une propriété spéciale indiquant le contexte d'exécution.

`function`

Le mot-clé `function` définit une expression de fonction.

`class`

Le mot-clé `class` définit une expression de classe.

`function*`

Le mot-clé `function*` définit une expression de générateur.

`yield`

Ce mot-clé permet de suspendre ou de reprendre l'exécution d'une fonction génératrice.

`yield*`

Ce mot-clé délègue à une autre fonction génératrice ou à un objet itérable.

`async function`

Le couple de mots-clés `async function` définit une expression de fonction asynchrone.

`await`

Ce mot-clé permet de suspendre et de reprendre l'exécution d'une fonction asynchrone et d'attendre la résolution ou l'échec de la promesse.

`[]`

Syntaxe d'initialisation littérale pour les tableaux.

`{}`

Syntaxe d'initialisation littérale pour les objets.

`/ab+c/i`

Syntaxe pour les expressions littérales d'expressions rationnelles.

`( )`

Opérateur de groupement.

### Expression « vers la gauche »

Les valeurs situées à gauche sont la cible de l'affectation.

Accesseurs de propriété

 Les opérateurs d'accès aux membres permettent d'accéder à une propriété ou à une méthode d'un objet.
 (cela regroupe `objet.propriete` et `objet["propriete"]`).


`new`

L'opérateur `new` crée une instance grâce à un constructeur.

`new.target`

Pour les constructeurs, `new.target` fait référence au constructeur invoqué avec `new`.

`import.meta`

Un objet qui expose des métadonnées spécifiques au contexte pour un module JavaScript.

`super`

Le mot-clé `super` appelle le constructeur parent.

`...obj`

La syntaxe de décomposition permet de développer une expression là où plusieurs arguments (dans le cas des appels à une fonction) ou là où plusieurs éléments (dans le cas des tableaux) sont attendus.

### Incrémentation et décrémentation

Des opérateurs préfixes ou suffixes pour incrémenter/décrémenter.

`A++`

L'opérateur d'incrémentation suffixe.

`A--`

L'opérateur de décrémentation suffixe.

`++A`

L'opérateur d'incrémentation préfixe.

`--A`

L'opérateur de décrémentation préfixe.

### Opérateurs unaires

Une opération unaire est une opération qui ne manipule qu'un seul opérande.

`delete`

L'opérateur `delete` permet de supprimer une propriété d'un objet.

`void`

L'opérateur `void` permet d'ignorer la valeur de retour d'une expression.

`typeof`

L'opérateur `typeof` détermine le type d'un objet donné.

`+`

L'opérateur unaire `+` convertit son opérande en une valeur de type `number`.

`-`

L'opérateur unaire `-` convertit son opérande en nombre puis prend son opposé.

`~`

L'opérateur binaire NON.

`!`

L'opérateur logique NON.

### Opérateurs arithmétiques

Les opérateurs arithmétiques utilisent des valeurs numériques (littérales ou variables) pour leurs opérandes et renvoient une seule valeur numérique en résultat.

`+`

L'opérateur d'addition.

`-`

L'opérateur de soustraction.

`/`

L'opérateur de division.

`*`

L'opérateur de multiplication.

`%`

L'opérateur du reste.

`**`

L'opérateur d'exponentiation.

### Opérateurs relationnels

Un opérateur de comparaison compare ses opérandes et renvoie une valeur booléenne en fonction de la vérité de cette comparaison.

`in`

L'opérateur `in` détermine la présence d'une propriété donnée au sein d'un objet.

`instanceof`

L'opérateur `instanceof` détermine si un objet est une instance d'un autre objet.

`<`

L'opérateur d'infériorité strict.

`>`

L'opérateur de supériorité stricte.

`<=`

L'opérateur d'infériorité.

`>=`

L'opérateur de supériorité.


**Note :** `=>` n'est pas un opérateur mais la notation utilisée pour les fonctions fléchées.

### Opérateurs d'égalité

Le résultat de l'évaluation fournie par un opérateur d'égalité est toujours un booléen, fonction de la vérité de la comparaison effectuée.

`==`

L'opérateur d'égalité.

`!=`

L'opérateur d'inégalité.

`===`

L'opérateur d'égalité stricte.

`!==`

L'opérateur d'inégalité stricte.

### Opérateurs de décalage binaires

Ces opérations permettent de décaler les bits de la représentation binaire de l'opérande.

`<<`

Opérateur de décalage binaire à gauche.

`>>`

Opérateur de décalage binaire à droite.

`>>>`

Opérateur de décalage binaire à droite non signé.

### Opérateurs binaires booléens

Ces opérateurs manipulent leurs opérandes comme des ensembles de 32 bits et renvoient des valeurs numériques standard.

`&`

Opérateur ET/AND binaire.

`|`

Opérateur OU/OR binaire.

`^`

Opérateur OU exclusif/XOR binaire.

### Opérateurs logiques

Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes, quand c'est le cas, la valeur de retour de l'expression est une valeur booléenne.

`&&`

Opérateur logique ET/AND.

`||`

Opérateur logique OU/OR.

`??`

Opérateur de coalescence des nuls.

### Opérateur conditionnel ternaire

`(condition ? ifTrue : ifFalse)`

L'opérateur conditionnel renvoie une valeur parmi deux selon la valeur logique de la condition portée par le premier opérande.

### Opérateur de chaînage optionnel

`?.`

L'opérateur de chaînage optionnel renvoie `undefined` plutôt que de causer une erreur si une référence vaut `null` ou `undefined`.

### Opérateurs d'affectation

Un opérateur d'affectation permet d'affecter une valeur à son opérande gauche en fonction de la valeur de son opérande droit.

`=`

Opérateur d'affectation.

`*=`

Opérateur de multiplication et d'affectation.

`**=`

Opérateur d'exponentiation et d'affectation.

`/=`

Opérateur de division et d'affectation.

`%=`

Opérateur de reste et d'affectation.

`+=`

Opérateur d'addition et d'affectation.

`-=`

Opérateur de soustraction et d'affectation

`<<=`

Opérateur de décalage à gauche et d'affectation.

`>>=`

Opérateur de décalage à droite et d'affectation.

`>>>=`

Opérateur de décalage à droite non signé et d'affectation.

`&=`

Opérateur binaire ET et d'affectation.

`^=`

Opérateur binaire OU exclusif et d'affectation.

`|=`

Opérateur binaire OU et d'affectation.

`&&=`

Opérateur booléen ET et d'affectation.

`||=`

Opérateur booléen OU et d'affectation.

`??=`

Opérateur d'affectation et de logique nulle.

`[a, b] = [1, 2]`
`{a, b} = {a:1, b:2}`

L'affectation par décomposition permet d'affecter les propriétés d'un tableau ou d'un objet à des variables en utilisant une syntaxe similaire à celle des littéraux pour les tableaux et les objets.

### Opérateur virgule

`,`

L'opérateur virgule permet d'évaluer plusieurs expressions dans une seule instruction et renvoie le résultat de la dernière expression.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-addition-operator-plus |
| ECMAScript Language Specification # sec-assignment-operators |
| ECMAScript Language Specification # sec-async-function-definitions |
| ECMAScript Language Specification # sec-async-generator-function-definitions |
| ECMAScript Language Specification # prod-BitwiseANDExpression |
| ECMAScript Language Specification # sec-bitwise-not-operator |
| ECMAScript Language Specification # prod-BitwiseORExpression |
| ECMAScript Language Specification # prod-BitwiseXORExpression |
| ECMAScript Language Specification # sec-class-definitions |
| ECMAScript Language Specification # sec-comma-operator |
| ECMAScript Language Specification # sec-conditional-operator |
| ECMAScript Language Specification # sec-postfix-decrement-operator |
| ECMAScript Language Specification # sec-delete-operator |
| ECMAScript Language Specification # sec-destructuring-assignment |
| ECMAScript Language Specification # sec-destructuring-binding-patterns |
| ECMAScript Language Specification # sec-multiplicative-operators |
| ECMAScript Language Specification # sec-equality-operators |
| ECMAScript Language Specification # sec-exp-operator |
| ECMAScript Language Specification # sec-function-definitions |
| ECMAScript Language Specification # sec-generator-function-definitions |
| ECMAScript Language Specification # sec-relational-operators |
| ECMAScript Language Specification # sec-grouping-operator |
| ECMAScript Language Specification # sec-import-calls |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |
| ECMAScript Language Specification # sec-postfix-increment-operator |
| ECMAScript Language Specification # sec-left-shift-operator |
| ECMAScript Language Specification # prod-LogicalANDExpression |
| ECMAScript Language Specification # sec-logical-not-operator |
| ECMAScript Language Specification # prod-LogicalORExpression |
| ECMAScript Language Specification # sec-new-operator |
| ECMAScript Language Specification # sec-built-in-function-objects |
| ECMAScript Language Specification # sec-null-value |
| ECMAScript Language Specification # prod-CoalesceExpression |
| ECMAScript Language Specification # sec-object-initializer |
| ECMAScript Language Specification # prod-OptionalExpression |
| ECMAScript Language Specification # sec-property-accessors |
| ECMAScript Language Specification # sec-signed-right-shift-operator |
| ECMAScript Language Specification # prod-SpreadElement |
| ECMAScript Language Specification # prod-ArgumentList |
| ECMAScript Language Specification # prod-PropertyDefinition |
| ECMAScript Language Specification # sec-subtraction-operator-minus |
| ECMAScript Language Specification # sec-super-keyword |
| ECMAScript Language Specification # sec-this-keyword |
| ECMAScript Language Specification # sec-typeof-operator |
| ECMAScript Language Specification # sec-unary-minus-operator |
| ECMAScript Language Specification # sec-unary-plus-operator |
| ECMAScript Language Specification # sec-unsigned-right-shift-operator |
| ECMAScript Language Specification # sec-void-operator |
| ECMAScript Language Specification # prod-YieldExpression |
| ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation |

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

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

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

* Précédence des opérateurs en JavaScript