From 9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 Mon Sep 17 00:00:00 2001 From: SphinxKnight Date: Sun, 27 Jun 2021 15:03:56 +0200 Subject: Fix #756 by updating the JS operators in fr (#1306) * Update Operators landing + revamp L10N for 4 operators * Added NOT / ! - * +multiplication * Addition, exponentiation and comparison * Operateurs de comparaison * Binary ops * Missing newline, thx GH UI * Logical AND / OR * Assignment ops * Conflicting clean-up * Missing EOF newline * Fix history and redirects * FIX: fix flaws * FIX: minox typo fix * FIX: link flaws * FIX: fix tags detection Co-authored-by: tristantheb --- .../reference/operators/addition/index.html | 72 ++-- .../operators/addition_assignment/index.html | 85 +++-- .../reference/operators/bitwise_and/index.html | 102 ++++++ .../operators/bitwise_and_assignment/index.html | 50 +++ .../reference/operators/bitwise_not/index.html | 90 +++++ .../reference/operators/bitwise_or/index.html | 104 ++++++ .../operators/bitwise_or_assignment/index.html | 53 +++ .../reference/operators/bitwise_xor/index.html | 104 ++++++ .../operators/bitwise_xor_assignment/index.html | 57 +++ .../reference/operators/decrement/index.html | 70 ++++ .../reference/operators/division/index.html | 63 ++++ .../operators/division_assignment/index.html | 51 +++ .../reference/operators/equality/index.html | 125 +++++++ .../reference/operators/exponentiation/index.html | 95 +++++ .../operators/exponentiation_assignment/index.html | 49 +++ .../reference/operators/greater_than/index.html | 100 ++++++ .../operators/greater_than_or_equal/index.html | 99 ++++++ .../reference/operators/increment/index.html | 70 ++++ .../web/javascript/reference/operators/index.html | 393 ++++++++++----------- .../reference/operators/inequality/index.html | 102 ++++++ .../reference/operators/left_shift/index.html | 62 ++++ .../operators/left_shift_assignment/index.html | 51 +++ .../reference/operators/less_than/index.html | 115 ++++++ .../operators/less_than_or_equal/index.html | 99 ++++++ .../reference/operators/logical_and/index.html | 157 ++++++++ .../operators/logical_and_assignment/index.html | 78 ++++ .../reference/operators/logical_not/index.html | 95 +++++ .../logical_nullish_assignment/index.html | 78 ++++ .../reference/operators/logical_or/index.html | 158 +++++++++ .../operators/logical_or_assignment/index.html | 84 +++++ .../reference/operators/multiplication/index.html | 65 ++++ .../operators/multiplication_assignment/index.html | 48 +++ .../reference/operators/remainder/index.html | 80 +++++ .../operators/remainder_assignment/index.html | 50 +++ .../reference/operators/right_shift/index.html | 67 ++++ .../operators/right_shift_assignment/index.html | 51 +++ .../reference/operators/strict_equality/index.html | 100 ++++++ .../operators/strict_inequality/index.html | 97 +++++ .../reference/operators/subtraction/index.html | 59 ++++ .../operators/subtraction_assignment/index.html | 49 +++ .../reference/operators/unary_negation/index.html | 65 ++++ .../reference/operators/unary_plus/index.html | 69 ++++ .../operators/unsigned_right_shift/index.html | 66 ++++ .../unsigned_right_shift_assignment/index.html | 51 +++ 44 files changed, 3543 insertions(+), 285 deletions(-) create mode 100644 files/fr/web/javascript/reference/operators/bitwise_and/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_not/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_or/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_xor/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/decrement/index.html create mode 100644 files/fr/web/javascript/reference/operators/division/index.html create mode 100644 files/fr/web/javascript/reference/operators/division_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/equality/index.html create mode 100644 files/fr/web/javascript/reference/operators/exponentiation/index.html create mode 100644 files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/greater_than/index.html create mode 100644 files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html create mode 100644 files/fr/web/javascript/reference/operators/increment/index.html create mode 100644 files/fr/web/javascript/reference/operators/inequality/index.html create mode 100644 files/fr/web/javascript/reference/operators/left_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/left_shift_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/less_than/index.html create mode 100644 files/fr/web/javascript/reference/operators/less_than_or_equal/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_and/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_and_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_not/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_or/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_or_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/multiplication/index.html create mode 100644 files/fr/web/javascript/reference/operators/multiplication_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/remainder/index.html create mode 100644 files/fr/web/javascript/reference/operators/remainder_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/right_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/right_shift_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/strict_equality/index.html create mode 100644 files/fr/web/javascript/reference/operators/strict_inequality/index.html create mode 100644 files/fr/web/javascript/reference/operators/subtraction/index.html create mode 100644 files/fr/web/javascript/reference/operators/subtraction_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/unary_negation/index.html create mode 100644 files/fr/web/javascript/reference/operators/unary_plus/index.html create mode 100644 files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html (limited to 'files/fr/web/javascript') diff --git a/files/fr/web/javascript/reference/operators/addition/index.html b/files/fr/web/javascript/reference/operators/addition/index.html index af5fb528e0..e67da71cd6 100644 --- a/files/fr/web/javascript/reference/operators/addition/index.html +++ b/files/fr/web/javascript/reference/operators/addition/index.html @@ -7,76 +7,64 @@ tags: - Reference translation_of: Web/JavaScript/Reference/Operators/Addition original_slug: Web/JavaScript/Reference/Opérateurs/Addition +browser-compat: javascript.operators.addition ---
{{jsSidebar("Operators")}}
-
L'opérateur d'addition (+) effectue la somme de deux opérandes numériques ou la concaténation de chaînes de caractères.
- - +

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.

{{EmbedInteractiveExample("pages/js/expressions-addition.html")}}
-
- - - -

Syntaxe

+

Syntaxe

-
Opérateur: x + y
+
+Opérateur : x + y
 

 
-
Exemples

+
Exemples

 
-
Addition numérique

+
Addition numérique

 
-
// Nombre + Nombre -> addition
+
+// Number + Number -> addition
 1 + 2 // 3
 
-// Booléen + Nombre -> addition
+// Boolean + Number -> addition
 true + 1 // 2
 
-// Booléen + Booléen -> addition
+// Boolean + Boolean -> addition
 false + false // 0
 

 
-
Concaténation de chaînes

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

 
-
// String + String -> concatenation
-'foo' + 'bar' // "foobar"
+
// String + String -> concatenation
+'toto' + 'truc' // "tototruc"
 
 // Number + String -> concatenation
-5 + 'foo' // "5foo"
+5 + 'toto' // "5toto"
 
 // String + Boolean -> concatenation
-'foo' + false // "foofalse"

+'toto' + false // "totofalse"

 
-
Spécifications

+
Spécifications

 
-
- 
-  
-   
-  
-  
-   
-  
- 
-
Spécification
{{SpecName('ESDraft', '#sec-addition-operator-plus', 'Addition operator')}}

+
{{Specifications}}

 
-
Compatibilité des navigateurs

+
Compatibilité des navigateurs

 
-
{{Compat("javascript.operators.addition")}}

+
{{Compat}}

 
-
Voir aussi

+
Voir aussi

 
 
diff --git a/files/fr/web/javascript/reference/operators/addition_assignment/index.html b/files/fr/web/javascript/reference/operators/addition_assignment/index.html
index 6648df2a7f..c0a2136c3d 100644
--- a/files/fr/web/javascript/reference/operators/addition_assignment/index.html
+++ b/files/fr/web/javascript/reference/operators/addition_assignment/index.html
@@ -1,59 +1,66 @@
 ---
-title: Addition avec assignement (+=)
+title: Affectation après addition (+=)
 slug: Web/JavaScript/Reference/Operators/Addition_assignment
 tags:
-  - Fonctionnalité du language
-  - JavaScript
-  - Opérateur
-  - Opérateur d'assignement
-  - Reference
-translation_of: Web/JavaScript/Reference/Operators/Addition_assignment
-original_slug: Web/JavaScript/Reference/Opérateurs/Addition_avec_assignement
+- Assignment operator
+- JavaScript
+- Language feature
+- Operator
+- Reference
+translation-of: Web/JavaScript/Reference/Operators/Addition_assignment
+browser-compat: javascript.operators.addition_assignment
 ---
-
{{jsSidebar("Operators")}}

+
{{jsSidebar("Operators")}}

 
-
L'opérateur d'addition avec assignement (+=) permet d'ajouter une valeur à une variable. Le type des deux valeurs permet de définir si l'utilisation de cet opérateur les concatènera ou les additionnera.

+
L'opérateur d'addition et d'affectation (+=) calcule la somme ou la concaténation de ses deux opérandes puis affecte le résultat à la variable représentée par l'opérande gauche. C'est le type des opérandes qui détermine s'il y a somme ou concaténation.

 
 
{{EmbedInteractiveExample("pages/js/expressions-addition-assignment.html")}}

 
-

+
Syntax

 
-
+
+Opérateur : x += y
+Signification :  x  = x + y
+

 
-
Syntaxe

+
Exemples

 
-
Opérateur : x += y
-Signifie :  x = x + y

+
Utiliser l'opérateur d'addition et d'affectation

 
-
Examples

+
+let toto = "toto";
+let truc = 5;
+let machin = true;
 
-
Utilisation de l'opérateur

+// nombre + nombre -> addition
+truc += 2; // 7
 
-
// On considère les variables suivantes :
-var chaine = "Hello";
-var nombre = 5;
-var booleen = true;
+// booléen + nombre -> addition
+machin += 1; // 2
 
-// Nombre + Nombre
-nombre += 2;
-// 7
+// booléen + booléen -> addition
+machin += false; // 1
 
-// Booléen + Nombre
-booleen += 1;
-// 2
+// nombre + chaîne de caractères -> concaténation
+truc += 'toto'; // "5toto"
 
-// Booléen + Booléen
-booleen += false;
-// 1
+// chaîne de caractères + booléen -> concaténation
+toto += false // "totofalse"
 
-// Nombre + Chaîne
-nombre += "World";
-// "5World"
+// chaîne de caractères + chaîne de caractères -> concaténation
+toto += 'truc' // "tototruc"

 
-// Chaîne + Booléen
-chaine += false;
-// "Hellofalse"
+
Spécifications

 
-// Chaîne + Chaîne
-chaine += "World"
-// "HelloWorld"

+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_and/index.html b/files/fr/web/javascript/reference/operators/bitwise_and/index.html
new file mode 100644
index 0000000000..b1a3ca024b
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_and/index.html
@@ -0,0 +1,102 @@
+---
+title: ET binaire (&)
+slug: Web/JavaScript/Reference/Operators/Bitwise_AND
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_and
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_AND
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-and.html")}}

+
+
Syntaxe

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

+
+
+  
+    
+      
+      
+      
+    
+  
+  
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+  
+
aba ET b
000
010
100
111

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

+
+
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+5 & 2; // 0
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html
new file mode 100644
index 0000000000..3300032225
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html
@@ -0,0 +1,50 @@
+---
+title: Affectation après ET binaire (&=)
+slug: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_and_assignment
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur d'affectation après ET binaire (&=) utilise la représentation binaire des deux opérandes, applique un ET logique entre chaque puis affecte le résultat de l'opération à la variable représentée par l'opérande gauche.

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-and-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x &= y
+Signification :  x  = x & y
+

+
+
Exemples

+
+
Utiliser l'affectation après ET binaire

+
+
+let a = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+a &= 2; // 0
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_not/index.html b/files/fr/web/javascript/reference/operators/bitwise_not/index.html
new file mode 100644
index 0000000000..f3e1856a90
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_not/index.html
@@ -0,0 +1,90 @@
+---
+title: NON binaire (~)
+slug: Web/JavaScript/Reference/Operators/Bitwise_NOT
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_not
+translation_of: Web/JavaScript/Reference/Operators/Bitwise_NOT
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur binaire NON (~) prend l'opposé de chaque bit de son opérande et fournit la valeur ainsi obtenue. À l'instar des autres opérateurs binaires, il convertit son opérande en un entier signé sur 32 bits.

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-not.html")}}

+
+
Syntaxe

+
+
+~a
+

+
+
Description

+
+
L'opérande est converti en un entier signé sur 32 bits. Les nombres avec plus de 32 bits voient leurs bits les plus significatifs être tronqués. Voici un exemple où l'entier qui suit est supérieur à une valeur pouvant être exprimée sur 32 bits : la conversion écrête la valeur pour obtenir un entier signé sur 32 bits :

+
+
+Avant : 11100110111110100000000000000110000000000001
+Après :             10100000000000000110000000000001
+

+
+
Pour former le résultat, chaque bit qui compose l'opérande est inversé.

+
+
La table de vérité pour l'opération NON est :

+
+
+  
+    
+      
+      
+    
+  
+  
+    
+      
+      
+    
+    
+      
+      
+    
+  
+
aNON a
01
10

+
+
+ 9 (base 10) = 00000000000000000000000000001001 (base 2)
+               --------------------------------
+~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
+

+
+
L'entier signé sur 32 bits est inversé selon le complément à deux. Autrement dit, la présence du bit le plus significatif est utilisée pour exprimer des entiers négatifs.

+
+
Appliquer un NON binaire sur n'importe quel nombre x fournira la valeur -(x + 1). Ainsi, ~-5 renverra 4.

+
+
Étant donné l'utilisation d'une représentation sur 32 bits, ~-1 et ~4294967295 (2^32 - 1) donneront tous les deux 0.

+
+
Exemples

+
+
Utiliser le NON binaire

+
+
~0;  // -1
+~-1; // 0
+~1;  // -2
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_or/index.html b/files/fr/web/javascript/reference/operators/bitwise_or/index.html
new file mode 100644
index 0000000000..72d4ed3043
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_or/index.html
@@ -0,0 +1,104 @@
+---
+title: OU binaire (|)
+slug: Web/JavaScript/Reference/Operators/Bitwise_OR
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_or
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_OR
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-or.html")}}

+
+
Syntaxe

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

+
+
+  
+    
+      
+      
+      
+    
+  
+  
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+  
+
aba OU b
000
011
101
111

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

+
+
+// 9  (00000000000000000000000000001001)
+// 14 (00000000000000000000000000001110)
+
+14 | 9;
+// 15 (00000000000000000000000000001111)
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html
new file mode 100644
index 0000000000..5c03784a45
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html
@@ -0,0 +1,53 @@
+---
+title: Affectation après OU binaire (|=)
+slug: Web/JavaScript/Reference/Operators/Bitwise_OR_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_or_assignment
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_OR_assignment
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur d'affectation après OU binaire (|=) utilise la représentation binaire des deux opérandes et effectue un OU logique entre chaque puis affecte le résultat à la variable représentée par l'opérande gauche.

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-or-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x |= y
+Signification :  x = x | y
+

+
+
Exemples

+
+
Utiliser l'affectation après OU binaire

+
+
+let a = 5;
+a |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_xor/index.html b/files/fr/web/javascript/reference/operators/bitwise_xor/index.html
new file mode 100644
index 0000000000..eff1d79f8f
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_xor/index.html
@@ -0,0 +1,104 @@
+---
+title: OU exclusif binaire (^)
+slug: Web/JavaScript/Reference/Operators/Bitwise_XOR
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_xor
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_XOR
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor.html")}}

+
+
Syntaxe

+
+
+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'exactement 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 exclusif (XOR) est :

+
+
+  
+    
+      
+      
+      
+    
+  
+  
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+  
+
aba XOR b
000
011
101
110

+
+
+.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+

+
+
Utiliser le OU exclusif binaire avec n'importe quel nombre x d'une part et 0 d'autre part renverra x.

+
+
Exemples

+
+
Utiliser le OU exclusif binaire

+
+
+// 9  (00000000000000000000000000001001)
+// 14 (00000000000000000000000000001110)
+
+14 ^ 9;
+// 7  (00000000000000000000000000000111)
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html
new file mode 100644
index 0000000000..15074eaf64
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html
@@ -0,0 +1,57 @@
+---
+title: Affectation après OU exclusif binaire (^=)
+slug: Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.bitwise_xor_assignment
+translation-of: Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x ^= y
+Signification :  x  = x ^ y
+

+
+
Exemples

+
+
Utiliser l'affectation après OU exclusif binaire

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/decrement/index.html b/files/fr/web/javascript/reference/operators/decrement/index.html
new file mode 100644
index 0000000000..291f46393f
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/decrement/index.html
@@ -0,0 +1,70 @@
+---
+title: Décrémentation (--)
+slug: Web/JavaScript/Reference/Operators/Decrement
+tags:
+  - Decrement
+  - JavaScript
+  - Language feature
+  - Operator
+browser-compat: javascript.operators.decrement
+translation_of: Web/JavaScript/Reference/Operators/Decrement
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-decrement.html")}}

+
+
Syntaxe

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

+
+
let x = 3;
+let y = x--;
+
+// y = 3
+// x = 2
+

+
+
Décrément en préfixe

+
+
let a = 2;
+let b = --a;
+
+// a = 1
+// b = 1
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/division/index.html b/files/fr/web/javascript/reference/operators/division/index.html
new file mode 100644
index 0000000000..25d572fce0
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/division/index.html
@@ -0,0 +1,63 @@
+---
+title: Division (/)
+slug: Web/JavaScript/Reference/Operators/Division
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.division
+translation-of: Web/JavaScript/Reference/Operators/Division
+---
+
{{jsSidebar("Operators")}}

+
+
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).

+
+
{{EmbedInteractiveExample("pages/js/expressions-division.html")}}

+
+
Syntaxe

+
+
+Opérateur : x / y
+

+
+
Exemples

+
+
Divisions simples

+
+
+1 / 2             // 0.5
+Math.floor(3 / 2) // 1
+1.0 / 2.0         // 0.5
+

+
+
Division par zéro

+
+
+2.0 / 0     // Infinity
+2.0 / 0.0   // Infinity, because 0.0 === 0
+2.0 / -0.0  // -Infinity
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/division_assignment/index.html b/files/fr/web/javascript/reference/operators/division_assignment/index.html
new file mode 100644
index 0000000000..cd72e5d239
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/division_assignment/index.html
@@ -0,0 +1,51 @@
+---
+title: Affectation après division (/=)
+slug: Web/JavaScript/Reference/Operators/Division_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.division_assignment
+translation-of: Web/JavaScript/Reference/Operators/Division_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-division-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x /= y
+Signification:  x  = x / y
+

+
+
Exemples

+
+
Utiliser l'opérateur de division et d'affectation

+
+
+let truc = 5;
+truc /= 2;      // 2.5
+truc /= 2;      // 1.25
+truc /= 0;      // Infinity
+truc /= 'toto'; // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/equality/index.html b/files/fr/web/javascript/reference/operators/equality/index.html
new file mode 100644
index 0000000000..0668aa74d4
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/equality/index.html
@@ -0,0 +1,125 @@
+---
+title: Égalité (==)
+slug: Web/JavaScript/Reference/Operators/Equality
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.equality
+translation-of: Web/JavaScript/Reference/Operators/Equality
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur d'égalité (==) vérifie si ses deux opérandes sont égaux et renvoie un booléen indiquant le résultat de la comparaison. À la différence de l'opérateur d'égalité stricte, l'opérateur d'égalité tente de convertir ses opérandes avant la comparaison si ceux-ci sont de types différents.

+
+
{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}

+
+
Syntaxe

+
+
+x == y
+

+
+
Description

+
+
Les opérateurs d'égalité (== et !=) utilisent l'algorithme de comparaison d'égalité abstraite pour comparer deux opérandes. On peut le résumer ainsi :

+
+
    
+  
  • Si les opérandes sont deux objets, on renvoie true uniquement si les deux opérandes référencent le même objet.
    • 
+  
  • Si un opérande vaut null et que l'autre vaut undefined, on renvoie true.
    • 
+  
  • Si les opérandes sont de types différents, on tente une conversion pour avoir le même type de part et d'autre avant la comparaison :
+    
      
+      
    • Si on compare un nombre à une chaîne de caractères, on tentera de convertir la chaîne en une valeur numérique.
      • 
+      
    • Si l'un des opérandes est un booléen, on le convertira en 1 s'il vaut true et en +0 s'il vaut false.
      • 
+      
    • Si l'un des opérandes est un objet et que l'autre est un nombre ou une chaîne de caractères, on tentera de convertir l'objet en une valeur primitive grâce aux méthodes valueOf() et toString() de l'objet.
      • 
+    
    
+  
    • 
+  
  • Si les opérandes sont du même types, on les compare comme suit :
+    
      
+      
    • String : on renvoie true uniquement si les deux opérandes ont les mêmes caractères dans le même ordre.
      • 
+      
    • Number : on renvoie true uniquement si les deux opérandes ont la même valeur. +0 et -0 sont considérés comme la même valeur. Si au moins un des opérandes vaut NaN, on renvoie false.
      • 
+      
    • Boolean : on renvoie true uniquement si les deux opérandes valent tous les deux true ou s'ils valent tous les deux false.
      • 
+    
    
+  
    • 
+

+
+
La différence fondamentale entre cet opérateur et l'opérateur d'égalité stricte (===) est que ce dernier n'opère pas de conversion de type. L'opérateur d'égalité stricte considère toujours que deux valeurs de types différents sont différentes.

+
+
Exemples

+
+
Comparaison sans conversion de types

+
+
+1 == 1;              // true
+"coucou" == "coucou";  // true
+

+
+
Comparaison avec conversion de types

+
+
+"1" ==  1;            // true
+1 == "1";             // true
+0 == false;           // true
+0 == null;            // false
+0 == undefined;       // false
+0 == !!null;          // true, voir la documentation pour !!
+0 == !!undefined;     // true, voir la documentation pour !!
+null == undefined;    // true
+
+const nombre1 = new Number(3);
+const nombre2 = new Number(3);
+nombre1 == 3;         // true
+nombre1 == nombre2;   // false
+

+
+
Comparaison d'objets

+
+
+const objet1 = {"clé": "valeur"}
+const objet2 = {"clé": "valeur"};
+
+objet1 == objet2 // false
+objet2 == objet2 // true
+

+
+
Comparaison entre des chaînes de caractères et des objets String

+
+
On notera que les chaînes de caractères construites avec new String() sont des objets. Si on compare une telle valeur avec une chaîne de caractères "primitives", l'objet String sera converti en une chaîne de caractères et les contenus de ces chaînes seront comparés. Toutefois, si les deux opérandes sont des objets String, ils seront comparés comme tels et devront référencer le même objet pour être considérés égaux :

+
+
+const string1 = "coucou";
+const string2 = String("coucou");
+const string3 = new String("coucou");
+const string4 = new String("coucou");
+
+console.log(string1 == string2); // true
+console.log(string1 == string3); // true
+console.log(string2 == string3); // true
+console.log(string3 == string4); // false
+console.log(string4 == string4); // true
+

+
+
Comparaison entre les dates et les chaînes de caractères

+
+
+const d = new Date('December 17, 1995 03:24:00');
+const s = d.toString(); // par exemple : "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
+console.log(d == s);    //true
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/exponentiation/index.html b/files/fr/web/javascript/reference/operators/exponentiation/index.html
new file mode 100644
index 0000000000..310a21c8fe
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/exponentiation/index.html
@@ -0,0 +1,95 @@
+---
+title: Exponentiation (**)
+slug: Web/JavaScript/Reference/Operators/Exponentiation
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.exponentiation
+translation-of: Web/JavaScript/Reference/Operators/Exponentiation
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-exponentiation.html")}}

+
+
Syntaxe

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

+
+
+-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).

+
+
Exemples

+
+
Exponentiation simple

+
+
+2 ** 3   // 8
+3 ** 2   // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+

+
+
Associativité

+
+
+2 ** 3 ** 2   // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64

+
+
Avec les opérateurs unaires

+
+
Pour prendre l'opposé du résultat :

+
+
+-(2 ** 2) // -4
+

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

+
+
(-2) ** 2 // 4
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html b/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html
new file mode 100644
index 0000000000..b83a331cf4
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html
@@ -0,0 +1,49 @@
+---
+title: Affectation après exponentiation (**=)
+slug: Web/JavaScript/Reference/Operators/Exponentiation_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.exponentiation_assignment
+translation-of: Web/JavaScript/Reference/Operators/Exponentiation_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-exponentiation-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x **= y
+Signification :  x  = x ** y
+

+
+
Exemples

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

+
+
+let truc = 5;
+truc **= 2;      // 25
+truc **= 'toto'; // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/greater_than/index.html b/files/fr/web/javascript/reference/operators/greater_than/index.html
new file mode 100644
index 0000000000..84d44509a0
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/greater_than/index.html
@@ -0,0 +1,100 @@
+---
+title: Supérieur strict (>)
+slug: Web/JavaScript/Reference/Operators/Greater_than
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.greater_than
+translation-of: Web/JavaScript/Reference/Operators/Greater_than
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-greater-than.html")}}

+
+
Syntaxe

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

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html b/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html
new file mode 100644
index 0000000000..4737d5161d
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html
@@ -0,0 +1,99 @@
+---
+title: Supérieur ou égal (>=)
+slug: Web/JavaScript/Reference/Operators/Greater_than_or_equal
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.greater_than_or_equal
+translation-of: Web/JavaScript/Reference/Operators/Greater_than_or_equal
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-greater-than-or-equal.html")}}

+
+
Syntaxe

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

+
+
+console.log(5 >= 3);         // true
+console.log(3 >= 3);         // true
+console.log(3 >= 5);         // false
+

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/increment/index.html b/files/fr/web/javascript/reference/operators/increment/index.html
new file mode 100644
index 0000000000..ab9d79b09f
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/increment/index.html
@@ -0,0 +1,70 @@
+---
+title: Incrémentation (++)
+slug: Web/JavaScript/Reference/Operators/Increment
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.increment
+translation_of: Web/JavaScript/Reference/Operators/Increment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-increment.html")}}

+
+
Syntaxe

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

+
+
let x = 3;
+let y = x++;
+
+// y = 3
+// x = 4
+

+
+
Incrément en préfixe

+
+
let a = 2;
+let b = ++a;
+
+// a = 3
+// b = 3
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/index.html b/files/fr/web/javascript/reference/operators/index.html
index ba82e8321e..83d4f9aa69 100644
--- a/files/fr/web/javascript/reference/operators/index.html
+++ b/files/fr/web/javascript/reference/operators/index.html
@@ -1,301 +1,286 @@
 ---
-title: Opérateurs
+title: Expressions et opérateurs
 slug: Web/JavaScript/Reference/Operators
 tags:
   - JavaScript
-  - Opérateurs
+  - Landing page
+  - Operators
+  - Overview
   - Reference
 translation_of: Web/JavaScript/Reference/Operators
 original_slug: Web/JavaScript/Reference/Opérateurs
+browser-compat: javascript.operators
 ---
 
{{jsSidebar("Operators")}}

 
-
Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés utilisés en JavaScript.

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

 
-
Expressions et opérateurs, par catégorie

+
Expressions et opérateurs par catégorie

 
-
Pour une liste alphabétique, voir le volet de navigation situé à gauche sur cette page.

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

 
-
Expressions primaires

+
Expressions primaires

 
-
Les mots-clés basiques et les expressions générales en JavaScript.

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

 
 

- 
{{jsxref("Opérateurs/L_opérateur_this", "this")}}

- 
Le mot-clé this fait référence à une propriété spéciale du contexte d'exécution de la fonction.

- 
{{jsxref("Opérateurs/L_opérateur_function", "function")}}

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

- 
{{jsxref("Opérateurs/class", "class")}}

+ 
class

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

- 
 {{jsxref("Opérateurs/function*", "function*")}}

- 
Le mot-clé function* définit une expression pour une fonction génératrice.

- 
{{jsxref("Opérateurs/yield", "yield")}}

- 
Cet opérateur permet de suspendre et de reprendre l'exécution d'une fonction génératrice.

- 
{{jsxref("Opérateurs/yield*", "yield*")}}

- 
Cet opérateur permet de déléguer l'exécution de la fonction à une autre fonction ou un autre objet itérable.

- 
{{experimental_inline}} {{jsxref("Opérateurs/async_function", "async function*")}}

- 
L'opérateur async function définit une expression de fonction asynchrone.

- 
{{experimental_inline}} {{jsxref("Opérateurs/await", "await")}}

- 
Cet opérateur permet de stopper et de reprendre l'exécution d'une fonction asynchrone et d'attendre pour la résolution ou le rejet d'une promesse.

- 
{{jsxref("Objets_globaux/Array", "[]")}}

- 
Littéral initialisateur de tableau.

- 
{{jsxref("Opérateurs/Initialisateur_objet", "{}")}}

- 
Littéral initialisateur d'objet.

- 
{{jsxref("Objets_globaux/RegExp", "/ab+c/i")}}

- 
Littéral d'expression rationnelle.

- 
{{jsxref("Opérateurs/Groupement", "( )")}}

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

 

 
-
Expressions « vers la gauche »

+
Expression « vers la gauche »

 
-
On affectera des valeurs aux variables à gauche de l'expression.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_de_membres", "Opérateurs de membres", "", 1)}}

- 
Les opérateurs de membres permettent d'accéder à une propriété ou une méthode d'un objet (objet.propriété et object["propriété"]).

- 
{{jsxref("Opérateurs/L_opérateur_new", "new")}}

- 
L'opérateur new permet de créer une instance d'un constructeur.

- 
new.target

- 
Dans les constructeurs, new.target fait référence au constructeur invoqué par {{jsxref("Opérateurs/new", "new")}}.

- 
{{jsxref("Opérateurs/super", "super")}}

- 
Le mot-clé super permet d'appeler le constructeur parent.

- 
{{jsxref("Opérateurs/Syntaxe_décomposition", "...obj")}}

- 
L'opérateur de décomposition permet de développer une expression là où on attend plusieurs arguments (pour des appels de fonctions) ou plusieurs éléments (pour les littéraux de tableaux).

+ 
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

+
Incrémentation et décrémentation

 
-
Les opérateurs d'incrémentation et de décrémentation, suffixe et préfixe :

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A++", "#Incr.C3.A9ment_(.2B.2B)")}}

- 
Opérateur d'incrémentation suffixe.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A--", "#D.C3.A9cr.C3.A9ment_(--)")}}

- 
Opérateur de décrémentation suffixe.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "++A", "#Incr.C3.A9ment_(.2B.2B)")}}

- 
Opérateur d'incrémentation préfixe.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "--A", "#D.C3.A9cr.C3.A9ment_(--)")}}

- 
Opérateur de décrémentation préfixe.

+ 
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

+
Opérateurs unaires

 
-
Une opération unaire est une opération qui ne possède qu'un opérande.

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

 
 

- 
{{jsxref("Opérateurs/L_opérateur_delete", "delete")}}

+ 
delete

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

- 
{{jsxref("Opérateurs/L_opérateur_void", "void")}}

- 
L'opérateur void écarte la valeur de retour d'une expression.

- 
{{jsxref("Opérateurs/L_opérateur_typeof", "typeof")}}

- 
L'opérateur typeof permet de déterminer le type d'un objet donné.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Plus_unaire_(.2B)")}}

- 
Le plus unaire permet de convertir son opérande en une valeur du type Number.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#N.C3.A9gation_unaire_(-)")}}

- 
La négation unaire permet de convertir son opérande en une valeur du type Number puis d'en prendre l'opposé.

- 
{{jsxref("Opérateurs/Opérateurs_binaires", "~", "#.7E_.28NON_binaire.29")}}

- 
L'opérateur binaire NON (NOT).

- 
{{jsxref("Opérateurs/Opérateurs_logiques", "!", "#NON_logique_.28.21.29")}}

- 
L'opérateur du NON logique.

+ 
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

+
Opérateurs arithmétiques

 
-
Les opérateurs arithmétiques utilisent des opérandes numériques et renvoie une valeur numérique.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Addition_(.2B)")}}

+ 
+

  
L'opérateur d'addition.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#Soustraction_(-)")}}

+ 
-

  
L'opérateur de soustraction.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "/", "#Division_(.2F)")}}

+ 
/

  
L'opérateur de division.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "*", "#Multiplication_(*)")}}

+ 
*

  
L'opérateur de multiplication.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques", "%", "#Reste_(.25)")}}

+ 
%

  
L'opérateur du reste.

- 
{{jsxref("Opérateurs/Opérateurs_arithmétiques","**","#Exponentiation")}}

- 
Opérateur de puissance (exponentiation).

+ 
**

+ 
L'opérateur d'exponentiation.

 

 
-
Opérateurs relationnels

+
Opérateurs relationnels

 
-
Un opérateur de comparaison permet de comparer deux opérandes et de renvoyer une valeur booléenne selon le résultat de cette comparaison.

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

 
 

- 
{{jsxref("Opérateurs/L_opérateur_in", "in")}}

- 
L'opérateur in permet de déterminer si un objet possède une propriété donnée.

- 
{{jsxref("Opérateurs/instanceof", "instanceof")}}

- 
L'opérateur instanceof permet de déterminer si un objet est une instance d'un autre objet.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "<", "#Op.C3.A9rateur_inf.C3.A9rieur_strict_(<)")}}

- 
Opérateur inférieur strict.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", ">", "#Op.C3.A9rateur_sup.C3.A9rieur_strict_(>)")}}

- 
Opérateur supérieur strict.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "<=", "#Op.C3.A9rateur_inf.C3.A9rieur_ou_.C3.A9gal_(<.3D)")}}

- 
Opérateur inférieur ou égal.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", ">=", "#Op.C3.A9rateur_sup.C3.A9rieur_ou_.C3.A9gal_(>.3D)")}}

- 
Opérateur supérieur ou égal.

+ 
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. Il s'agit de la notation utilisée pour les fonctions fléchées.

+

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

 

 
-
Opérateurs d'égalité

+
Opérateurs d'égalité

 
-
Un opérateur d'égalité considère deux opérandes et produit un résultat booléen basé sur le résultat de la comparaison.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#Egalit.C3.A9_(.3D.3D)")}}

- 
Opérateur d'égalité faible.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!=", "#Inequality_(!.3D)")}}

- 
Opérateur d'inégalité faible.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}}

- 
Opérateur d'égalité stricte.

- 
{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!==", "#Non-identity_.2F_strict_not_equal_(!.3D.3D)")}}

- 
Opérateur d'inégalité stricte.

+ 
==

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

+ 
!=

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

+ 
===

+ 
L'opérateur d'identité.

+ 
!==

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

 

 
-
Opérateurs de décalage binaires

+
Opérateurs de décalage binaires

 
-
Ces opérations permettent de décaler les bits contenus dans l'opérande.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_binaires", "<<", "#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29")}}

- 
Opérateur binaire de décalage à gauche.

- 
{{jsxref("Opérateurs/Opérateurs_binaires", ">>", "#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29")}}

- 
Opérateur binaire de décalage à droite.

- 
{{jsxref("Opérateurs/Opérateurs_binaires", ">>>", "#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29")}}

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

+ 
<<

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

+
Opérateurs binaires booléens

 
-
Les opérateurs binaires logiques traitent leurs opérandes comme des valeurs sur 32 bits et renvoient une valeur numérique JavaScript correspondant au résultat.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_binaires", "&", "#&_.28ET_binaire.29")}}

- 
ET binaire (AND).

- 
{{jsxref("Opérateurs/Opérateurs_binaires", "|", "#|_.28OU_binaire.29")}}

- 
OU binaire (OR).

- 
{{jsxref("Opérateurs/Opérateurs_binaires", "^", "#.5E_.28XOR_binaire.29")}}

- 
OU exclusif binaire (XOR).

+ 
&

+ 
Opérateur ET/AND binaire.

+ 
|

+ 
Opérateur OU/OR binaire.

+ 
^

+ 
Opérateur OU exclusif/XOR binaire.

 

 
-
Opérateurs logiques

+
Opérateurs logiques

 
-
Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes et renvoient une valeur booléenne, résultat de l'opération.

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

 
 

- 
{{jsxref("Opérateurs/Opérateurs_logiques", "&&", "#ET_logique_.28&&.29")}}

- 
ET logique (AND).

- 
{{jsxref("Opérateurs/Opérateurs_logiques", "||", "#OU_logique_.28||.29")}}

- 
OU logique (OR).

+ 
&&

+ 
Opérateur logique ET/AND.

+ 
||

+ 
Opérateur logique OU/OR.

+ 
??

+ 
Opérateur de coalescence des nuls.

 

 
-
Opérateur conditionnel ternaire

+
Opérateur conditionnel ternaire

 
 

- 
{{jsxref("Opérateurs/L_opérateur_conditionnel", "(condition ? siVrai : siFaux)")}}

+ 
(condition ? ifTrue : ifFalse)

  

- 
Cet opérateur renvoie une des deux valeurs fournie en fonction de la valeur logique de la condition.

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

  

 

 
-
Opérateurs d'affectation

-
-
Un opérateur d'affectation permet d'affecter une valeur à son opérande gauche en se basant sur la valeur de l'opérande droit.

+
Opérateur de chaînage optionnel

 
 

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "=", "#Assignment")}}

- 
Opérateur d'affectation.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "*=", "#Multiplication_assignment")}}

- 
Affectation après multiplication.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "/=", "#Division_assignment")}}

- 
Affectation après division.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "%=", "#Remainder_assignment")}}

- 
Affectation du reste.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "+=", "#Addition_assignment")}}

- 
Affectation après addition.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "-=", "#Subtraction_assignment")}}

- 
Affectation après soustraction.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "<<=", "#Left_shift_assignment")}}

- 
Affectation après décalage à gauche.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", ">>=", "#Right_shift_assignment")}}

- 
Affectation après décalage à droite.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", ">>>=", "#Unsigned_right_shift_assignment")}}

- 
Affectation après décalage à droite non-signé.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "&=", "#Bitwise_AND_assignment")}}

- 
Affectation après ET binaire.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "^=", "#Bitwise_AND_assignment")}}

- 
Affectation après OU exclusif binaire.

- 
{{jsxref("Opérateurs/Opérateurs_d_affectation", "|=","#Bitwise_OR_assignment")}}

- 
Affectation après OU binaire.

- 
{{jsxref("Opérateurs/Affecter_par_décomposition", "[a, b] = [1, 2]")}} {{jsxref("Opérateurs/Affecter_par_décomposition", "{a, b} = {a:1, b:2}")}}

+ 
?.

  

- 
L'affectation par décomposition permet de d'affecter des propriétés d'un objet ou des éléments d'un tableau à plusieurs variables. Cela permet d'utiliser une syntaxe semblable aux littéraux de tableaux/objets.

+ 
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érateur virgule

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

 
 

- 
{{jsxref("Opérateurs/L_opérateur_virgule", ",")}}

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

+ 
=

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

+ 

 

 
-
Fonctionnalités non-standards{{non-standard_inline}}

+
Opérateur virgule

 
 

- 
{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fermetures", "Expression de fermetures", "", 1)}}

- 
La syntaxe d'expression de fermeture est un raccourci pour écrire des fonctions simples.

- 
{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fonction_génératrice_historique", "", 1)}}

- 
Le mot-clé function peut être utilisé afin de définir une fonction génératrice historique. au sein d'une expression.

- 
{{non-standard_inline}} {{jsxref("Opérateurs/Compréhensions_de_tableau", "[for (x of y) x]")}}

- 
Compréhensions de tableau.

- 
{{non-standard_inline}}{{jsxref("Opérateurs/Compréhensions_de_générateur", "(for (x of y) y)")}}

- 
Compréhensions de générateurs.

+ 
,

+ 
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

-
-
- 
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
- 
-
SpécificationÉtatCommentaires
{{SpecName('ES1','#sec-11','Expressions')}}{{Spec2('ES1')}}Définition initiale.
{{SpecName('ES5.1', '#sec-11', 'Expressions')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ES6')}}Nouveaux éléments : opérateur de décomposition, affectation par décomposition, mot-clé super .
{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ESDraft')}} 

-
-
Compatibilité des navigateurs

-
-
{{Compat("javascript.operators")}}

-
-
Voir aussi

+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

 
 
diff --git a/files/fr/web/javascript/reference/operators/inequality/index.html b/files/fr/web/javascript/reference/operators/inequality/index.html
new file mode 100644
index 0000000000..d9465f8ba5
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/inequality/index.html
@@ -0,0 +1,102 @@
+---
+title: Inégalité (!=)
+slug: Web/JavaScript/Reference/Operators/Inequality
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.inequality
+translation-of: Web/JavaScript/Reference/Operators/Inequality
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-inequality.html")}}

+
+
Syntaxe

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

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

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

+
+
+3 !== "3"; // true
+

+
+
Exemples

+
+
Comparaison sans conversion de types

+
+
+1 != 2;              // true
+"hello" != "hola";   // true
+
+1 != 1;              // false
+"hello" != "hello";  // false
+

+
+
Comparaison avec conversion de types

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

+
+
+const objet1 = {"clé": "valeur"}
+const objet2 = {"clé": "valeur"};
+
+objet1 != objet2 // true
+objet2 != objet2 // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/left_shift/index.html b/files/fr/web/javascript/reference/operators/left_shift/index.html
new file mode 100644
index 0000000000..325adc9947
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/left_shift/index.html
@@ -0,0 +1,62 @@
+---
+title: Décalage binaire à gauche (<<)
+slug: Web/JavaScript/Reference/Operators/Left_shift
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.left_shift
+translation-of: Web/JavaScript/Reference/Operators/Left_shift
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-left-shift.html")}}

+
+
Syntaxe

+
+
+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) :

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

+
+
+9 << 3; // 72
+
+// 9 * (2 ** 3) = 9 * (8) = 72
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html
new file mode 100644
index 0000000000..85b349301b
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html
@@ -0,0 +1,51 @@
+---
+title: Affectation après décalage à gauche (<<=)
+slug: Web/JavaScript/Reference/Operators/Left_shift_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+translation-of: Web/JavaScript/Reference/Operators/Left_shift_assignment
+browser-compat: javascript.operators.left_shift_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-left-shift-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x <<= y
+Signification :  x   = x << y
+

+
+
Exemples

+
+
Utiliser l'opérateur de décalage à gauche et d'affectation

+
+
+let a = 5;
+// 00000000000000000000000000000101
+
+a <<= 2; // 20
+// 00000000000000000000000000010100
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/less_than/index.html b/files/fr/web/javascript/reference/operators/less_than/index.html
new file mode 100644
index 0000000000..5748798f15
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/less_than/index.html
@@ -0,0 +1,115 @@
+---
+title: Inférieur strict (<)
+slug: Web/JavaScript/Reference/Operators/Less_than
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+translation-of: Web/JavaScript/Reference/Operators/Less_than
+browser-compat: javascript.operators.less_than
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur inférieur strict (<) renvoie true si son opérande gauche est strictement inférieur à son opérande droit et false sinon.

+
+
{{EmbedInteractiveExample("pages/js/expressions-less-than.html")}}

+
+
Syntaxe

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

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html b/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html
new file mode 100644
index 0000000000..19d84e0f8c
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html
@@ -0,0 +1,99 @@
+---
+title: Inférieur ou égal (<=)
+slug: Web/JavaScript/Reference/Operators/Less_than_or_equal
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+translation-of: Web/JavaScript/Reference/Operators/Less_than_or_equal
+browser-compat: javascript.operators.less_than_or_equal
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-less-than-or-equal.html")}}

+
+
Syntaxe

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

+
+
+console.log(5 <= 3);         // false
+console.log(3 <= 3);         // true
+console.log(3 <= 5);         // true
+

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/logical_and/index.html b/files/fr/web/javascript/reference/operators/logical_and/index.html
new file mode 100644
index 0000000000..c40d0a1c2c
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_and/index.html
@@ -0,0 +1,157 @@
+---
+title: ET logique (&&)
+slug: Web/JavaScript/Reference/Operators/Logical_AND
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_and
+translation-of: Web/JavaScript/Reference/Operators/Logical_AND
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur ET logique (&&) (conjonction logique) renvoie vrai si et uniquement si ses deux opérandes sont true ou équivalents à true. Il est généralement utilisé avec des valeurs booléennes et, quand c'est le cas, il renvoie une valeur booléenne. Toutefois, l'opérateur && renvoie en fait la valeur d'un de ses opérandes et, si cet opérateur est utilisé avec des valeurs non-booléennes, il renverra une valeur non-booléenne.

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-and.html", "shorter")}}

+
+
Syntaxe

+
+
+expr1 && expr2
+

+
+
Description

+
+
Si expr1 peut être converti en true, le résultat sera expr2 ; sinon, ce sera expr1.
+

+
+
Si une valeur peut être convertie en true, elle peut être qualifiée de truthy. Si une valeur peut être convertie en false, on la qualifiera alors de falsy.

+
+
Parmi les expressions qui peuvent être converties en false, on a :

+
+
    
+  
  • null ;
    • 
+  
  • NaN ;
    • 
+  
  • 0 ;
    • 
+  
  • la chaîne de caractères vide ("" ou '' ou ``) ;
    • 
+  
  • undefined.
    • 
+

+
+
Bien que l'opérateur && puisse être utilisé avec des opérandes qui ne soient pas des valeurs booléennes, il reste un opérateur booléen, car sa valeur de retour peut toujours être convertie en une valeur primitive booléenne. Pour convertir explicitement la valeur de retour (ou tout expression de façon plus générale) dans sa valeur booléenne correspondante, on pourra utiliser un double opérateur NON (!) ou le constructeur Boolean().

+
+
Évaluation en court-circuit

+
+
L'expression utilisant un ET logique est évaluée de gauche à droite. Le moteur cherche s'il est possible d'utiliser un court-circuit de la façon suivante :

+
+
(une expression équivalente à faux) && expr sera court-circuité pour fournir directement le résultat de l'expression équivalente à faux.

+
+
Cette notion de court-circuit indique que la partie expr ci-avant n'est pas évaluée, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si expr est un appel de fonction, la fonction n'est pas appelée). Ce fonctionnement a lieu, car la valeur du résultat peut d'office être déterminée par l'évaluation du premier opérande. Par exemple :

+
+
+function A(){
+  console.log('A a été appelée');
+  return false;
+}
+
+function B(){
+  console.log('B a été appelée');
+  return true;
+}
+
+console.log( A() && B() );
+// affichera "A a été appelée" dans la console via l'appel de la fonction
+// puis affichera false (la valeur du résultat de l'expression avec l'opérateur)
+// on voit que la fonction B n'est pas du tout appelée
+

+
+
Précédence des opérateurs

+
+
Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur && est exécuté avant l'opérateur || (voir l'article sur la précédence des opérateurs).

+
+
+true || false && false      // renvoie true, car && est exécuté en premier
+(true || false) && false    // renvoie false, car la précédence par défaut ne s'applique pas
+                                    // avec les parenthèses
+

+
+
Exemples

+
+
Utiliser le ET logique

+
+
Le code suivant illustre quelques usages de l'opérateur ET logique &&.

+
+
+a1 = true   && true       // t && t renvoie true
+a2 = true   && false      // t && f renvoie false
+a3 = false  && true       // f && t renvoie false
+a4 = false  && (3 == 4)   // f && f renvoie false
+a5 = 'Chat' && 'Chien'    // t && t renvoie "Chien"
+a6 = false  && 'Chat'     // f && t renvoie false
+a7 = 'Chat' && false      // t && f renvoie false
+a8 = ''     && false      // f && f renvoie ""
+a9 = false  && ''         // f && f renvoie false
+

+
+
Règles de conversion booléennes

+
+
Convertir ET en OU

+
+
L'opération suivante, utilisant des booléens :

+
+
+bCondition1 && bCondition2
+

+
+
sera toujours équivalente à :

+
+
+!(!bCondition1 || !bCondition2)
+

+
+
Convertir OU en ET

+
+
L'opération suivante, utilisant des booléens :

+
+
+bCondition1 || bCondition2
+

+
+
sera toujours équivalente à :

+
+
+!(!bCondition1 && !bCondition2)
+

+
+
Retrait des parenthèses imbriquées

+
+
Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer les parenthèses d'une expression complexe en suivant quelques règles.

+
+
L'opération composite suivant, qui utilise des booléens :

+
+
+bCondition1 || (bCondition2 && bCondition3)
+

+
+
sera toujours égale à :

+
+
+bCondition1 || bCondition2 && bCondition3
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html
new file mode 100644
index 0000000000..e788d794d6
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html
@@ -0,0 +1,78 @@
+---
+title: Affectation après ET logique (&&=)
+slug: Web/JavaScript/Reference/Operators/Logical_AND_assignment
+tags:
+  - JavaScript
+  - Language feature
+  - Logical assignment
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_and_assignment
+translation-of: Web/JavaScript/Reference/Operators/Logical_AND_assignment
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur d'affectation après ET logique (x &&= y) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est équivalent à vrai (truthy).

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-and-assignment.html")}}

+
+
Syntaxe

+
+
+expr1 &&= expr2
+

+
+
Description

+
+
Évaluation en court-circuit

+
+
L'opérateur ET logique est évalué de gauche à droite et le moteur vérifie s'il peut utiliser un court-circuit avec la régle suivante :

+
+
(une expression équivalente à faux) && expr sera court-circuitée pour fournir directement l'expression équivalente à faux.

+
+
Ce « court-circuit » indique que expr n'est pas évaluée. Tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple si expr est un appel de fonction, la fonction n'est pas exécutée).

+
+
L'opérateur d'affectation après ET logique utilise également ce court-circuit et x &&= y est donc équivalent à :

+
+
+x && (x = y);
+

+
+
En revanche, il n'est pas équivalent à ce qui suit, et qui effectue quoi qu'il arrive une affectation :

+
+
+x = x && y;
+

+
+
Exemples

+
+
Utiliser l'affectation après ET logique

+
+
+let x = 0;
+let y = 1;
+
+x &&= 0; // 0
+x &&= 1; // 0
+y &&= 1; // 1
+y &&= 0; // 0
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/logical_not/index.html b/files/fr/web/javascript/reference/operators/logical_not/index.html
new file mode 100644
index 0000000000..da1f26ea14
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_not/index.html
@@ -0,0 +1,95 @@
+---
+title: NON logique (!)
+slug: Web/JavaScript/Reference/Operators/Logical_NOT
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_not
+translation-of: Web/JavaScript/Reference/Operators/Logical_NOT
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-not.html", "shorter")}}

+
+
Syntaxe

+
+
+!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.

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

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

+
+
!!bCondition

+
+
est toujours égale à :

+
+
bCondition

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
    
+  
  • {{jsxref("Boolean")}}
    • 
+  
  • {{Glossary("Truthy")}}
    • 
+  
  • {{Glossary("Falsy")}}
    • 
+

diff --git a/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html
new file mode 100644
index 0000000000..4860c3558b
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html
@@ -0,0 +1,78 @@
+---
+title: Affectation après coalescence des nuls (??=)
+slug: Web/JavaScript/Reference/Operators/Logical_nullish_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_nullish_assignment
+translation-of: Web/JavaScript/Reference/Operators/Logical_nullish_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-nullish-assignment.html")}}

+
+
Syntaxe

+
+
+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 à :

+
+
+x ?? (x = y);
+

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

+
+
+x = x ?? y;
+

+
+
Exemples

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/logical_or/index.html b/files/fr/web/javascript/reference/operators/logical_or/index.html
new file mode 100644
index 0000000000..b3c22c6874
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_or/index.html
@@ -0,0 +1,158 @@
+---
+title: OU logique (||)
+slug: Web/JavaScript/Reference/Operators/Logical_OR
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_or
+translation-of: Web/JavaScript/Reference/Operators/Logical_OR
+---
+
{{jsSidebar("Operators")}}

+
+
L'opérateur OU logique (||) (disjonction logique) renvoie vrai si et seulement si au moins un de ses opérandes est vrai. Cet opérateur est généralement utilisé avec des valeurs booléennes et, lorsque c'est le cas, il renvoie une valeur booléenne. Toutefois, || peut aussi être utilisé avec des valeurs non-booléennes et, dans ce cas, renverra une valeur non-booléenne.

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-or.html", "shorter")}}

+
+
Syntax

+
+
+expr1 || expr2
+

+
+
Description

+
+
Si expr1 peut être converti en true, c'est expr1 qui sera renvoyé, sinon ce sera expr2.

+
+
Si une valeur peut être convertie en true, elle peut être qualifiée de truthy. Si une valeur peut être convertie en false, on la qualifiera alors de falsy.

+
+
Parmi les expressions qui peuvent être converties en false, on a :

+
+
    
+  
  • null ;
    • 
+  
  • NaN ;
    • 
+  
  • 0 ;
    • 
+  
  • la chaîne de caractères vide ("" ou '' ou ``) ;
    • 
+  
  • undefined.
    • 
+

+
+
Bien que l'opérateur || puisse être utilisé avec des opérandes qui ne soient pas des valeurs booléennes, il reste un opérateur booléen, car sa valeur de retour peut toujours être convertie en une valeur primitive booléenne. Pour convertir explicitement la valeur de retour (ou tout expression de façon plus générale) dans sa valeur booléenne correspondante, on pourra utiliser un double opérateur NON (!) ou le constructeur Boolean().

+
+
Évaluation en court-circuit

+
+
L'expression utilisant un OU logique est évaluée de gauche à droite. Le moteur cherche s'il est possible d'utiliser un court-circuit de la façon suivante :

+
+
(une expression équivalente à vrai) && expr sera court-circuité pour fournir directement le résultat de l'expression équivalente à vrai.

+
+
Cette notion de court-circuit indique que la partie expr ci-avant n'est pas évaluée, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si expr est un appel de fonction, la fonction n'est pas appelée). Ce fonctionnement a lieu, car la valeur du résultat peut d'office être déterminée par l'évaluation du premier opérande. Par exemple :

+
+
+function A(){
+  console.log('A a été appelée');
+  return false;
+}
+
+function B(){
+  console.log('B a été appelée');
+  return true;
+}
+
+console.log( B() || A() );
+// affichera "B a été appelée" dans la console via l'appel de la fonction
+// puis affichera true (la valeur du résultat de l'expression avec l'opérateur)
+// on voit que la fonction A n'est pas du tout appelée
+

+
+
Précédence des opérateurs

+
+
Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur && est exécuté avant l'opérateur || (voir l'article sur la précédence des opérateurs).

+
+
+true || false && false      // renvoie true, car && est exécuté en premier
+(true || false) && false    // renvoie false, car la précédence par défaut ne s'applique pas
+                                    // avec les parenthèses
+

+
+
Exemples

+
+
Utiliser le OU logique

+
+
Le code suivant illustre quelques usages de l'opérateur OU logique ||.

+
+
+o1 = true   || true      // t || t renvoie true
+o2 = false  || true      // f || t renvoie true
+o3 = true   || false     // t || f renvoie true
+o4 = false  || (3 == 4)  // f || f renvoie false
+o5 = 'Chat' || 'Chien'   // t || t renvoie "Chat"
+o6 = false  || 'Chat'    // f || t renvoie "Chat"
+o7 = 'Chat' || false     // t || f renvoie "Chat"
+o8 = ''     || false     // f || f renvoie false
+o9 = false  || ''        // f || f renvoie ""
+o10 = false || varObject // f || object renvoie varObject
+

+
+

+  
Note : Si vous utilisez cet opérateur afin de fournir une valeur par défaut à une variable. Soyez conscient⋅e qu'une valeur équivalente à false ne pourra pas être utilisée ainsi. Si vous souhaitez uniquement écarter null ou undefined, privilégiez l'utilisation de l'opérateur de coalescence des nuls.

+

+
+
Règles de conversion booléennes

+
+
Convertir ET en OU

+
+
L'opération suivante, utilisant des booléens :

+
+
bCondition1 && bCondition2

+
+
sera toujours équivalente à :

+
+
+!(!bCondition1 || !bCondition2)
+

+
+
Convertir OU en ET

+
+
L'opération suivante, utilisant des booléens :

+
+
bCondition1 || bCondition2

+
+
sera toujours équivalente à :

+
+
+!(!bCondition1 && !bCondition2)
+

+
+
Retrait des parenthèses imbriquées

+
+
Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer les parenthèses d'une expression complexe en suivant quelques règles.

+
+
L'opération composite suivante, utilisant des booléens :

+
+
+bCondition1 && (bCondition2 || bCondition3)
+

+
+
sera toujours équivalente à :

+
+
+!(!bCondition1 || !bCondition2 && !bCondition3)
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html
new file mode 100644
index 0000000000..433c5f2109
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html
@@ -0,0 +1,84 @@
+---
+title: Affectation après OU logique (||=)
+slug: Web/JavaScript/Reference/Operators/Logical_OR_assignment
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_or_assignment
+translation-of: Web/JavaScript/Reference/Operators/Logical_OR_assignment
+---
+
{{jsSidebar("Operators")}}

+
+
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).

+
+
{{EmbedInteractiveExample("pages/js/expressions-logical-or-assignment.html")}}

+
+
Syntaxe

+
+
+expr1 ||= expr2
+

+
+
Description

+
+
Évaluation en court-circuit

+
+
L'opérateur OU logique fonctionne ainsi :

+
+
+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 à :

+
+
+x || (x = y);
+

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

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

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

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/multiplication/index.html b/files/fr/web/javascript/reference/operators/multiplication/index.html
new file mode 100644
index 0000000000..8729f46328
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/multiplication/index.html
@@ -0,0 +1,65 @@
+---
+title: Multiplication (*)
+slug: Web/JavaScript/Reference/Operators/Multiplication
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.multiplication
+translation-of: Web/JavaScript/Reference/Operators/Multiplication
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-multiplication.html")}}

+
+
Syntaxe

+
+
+Opérateur : x * y
+

+
+
Exemples

+
+
Avec des nombres

+
+
 2 * 2      // 4
+-2 * 2     // -4
+

+
+
Avec l'infini

+
+
+Infinity * 0         // NaN
+Infinity * Infinity  // Infinity
+

+
+
Avec des valeurs non-numériques

+
+
+'foo' * 2 // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html b/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html
new file mode 100644
index 0000000000..13d0a6d9e7
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html
@@ -0,0 +1,48 @@
+---
+title: Affectation après multiplication (*=)
+slug: Web/JavaScript/Reference/Operators/Multiplication_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.multiplication_assignment
+translation-of: Web/JavaScript/Reference/Operators/Multiplication_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-multiplication-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x *= y
+Signification :  x  = x * y
+

+
+
Exemples

+
+
Utiliser l'opérateur de multiplication et d'affectation

+
+
+let truc = 5;
+truc *= 2;      // 10
+truc *= 'toto'; // NaN

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/remainder/index.html b/files/fr/web/javascript/reference/operators/remainder/index.html
new file mode 100644
index 0000000000..c5df6dd43d
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/remainder/index.html
@@ -0,0 +1,80 @@
+---
+title: Reste (%)
+slug: Web/JavaScript/Reference/Operators/Remainder
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.remainder
+translation-of: Web/JavaScript/Reference/Operators/Remainder
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-remainder.html")}}

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

+
+
+Opérateur : var1 % var2
+

+
+
Exemples

+
+
Reste avec numérateur positif

+
+
+12 % 5  //  2
+ 1 % -2 //  1
+ 1 % 2  //  1
+ 2 % 3  //  2
+5.5 % 2 // 1.5
+

+
+
Reste avec numérateur négatif

+
+
+-12 % 5 // -2
+-1 % 2  // -1
+-4 % 2  // -0
+

+
+
Reste avec NaN

+
+
+NaN % 2 // NaN
+

+
+
Reste avec l'infini

+
+
+Infinity % 2 // NaN
+Infinity % 0 // NaN
+Infinity % Infinity // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/remainder_assignment/index.html b/files/fr/web/javascript/reference/operators/remainder_assignment/index.html
new file mode 100644
index 0000000000..87a47940d9
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/remainder_assignment/index.html
@@ -0,0 +1,50 @@
+---
+title: Affectation après reste (%=)
+slug: Web/JavaScript/Reference/Operators/Remainder_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.remainder_assignment
+translation-of: Web/JavaScript/Reference/Operators/Remainder_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-remainder-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x %= y
+Signification :  x  = x % y
+

+
+
Exemples

+
+
Utiliser l'opérateur de reste et d'affectation

+
+
+let truc = 5;
+truc %= 2;      // 1
+truc %= 'toto'; // NaN
+truc %= 0;      // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/right_shift/index.html b/files/fr/web/javascript/reference/operators/right_shift/index.html
new file mode 100644
index 0000000000..79c94864a3
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/right_shift/index.html
@@ -0,0 +1,67 @@
+---
+title: Décalage binaire à droite (>>)
+slug: Web/JavaScript/Reference/Operators/Right_shift
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.right_shift
+translation-of: Web/JavaScript/Reference/Operators/Right_shift
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-right-shift.html")}}

+
+
Syntaxe

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

+
+
+       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é :

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

+
+
Exemples

+
+
Utiliser le décalage à droite

+
+
+ 9 >> 2; //  2
+-9 >> 2; // -3
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html
new file mode 100644
index 0000000000..1674985313
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html
@@ -0,0 +1,51 @@
+---
+title: Affectation après décalage à droite (>>=)
+slug: Web/JavaScript/Reference/Operators/Right_shift_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.right_shift_assignment
+translation: Web/JavaScript/Reference/Operators/Right_shift_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-right-shift-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x >>= y
+Signification :  x   = x >> y
+

+
+
Exemples

+
+
Utiliser l'opérateur de décalage à droite et d'affectation

+
+
+let a = 5; //   (00000000000000000000000000000101)
+a >>= 2;   // 1 (00000000000000000000000000000001)
+
+let b = -5; //  (-00000000000000000000000000000101)
+b >>= 2;  // -2 (-00000000000000000000000000000010)
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/strict_equality/index.html b/files/fr/web/javascript/reference/operators/strict_equality/index.html
new file mode 100644
index 0000000000..ba45dffaae
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/strict_equality/index.html
@@ -0,0 +1,100 @@
+---
+title: Égalité stricte (===)
+slug: Web/JavaScript/Reference/Operators/Strict_equality
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.strict_equality
+translation-of: Web/JavaScript/Reference/Operators/Strict_equality
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-strict-equality.html")}}

+
+
Syntaxe

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

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

+
+
+console.log("3" === 3);           // false
+
+console.log(true === 1);          // false
+
+console.log(null === undefined);  // false
+

+
+
Comparaison d'objets

+
+
+const objet1 = {
+  name: "coucou"
+}
+
+const objet2 = {
+  name: "coucou"
+}
+
+console.log(objet1 === objet2);  // false
+console.log(objet1 === objet1);  // true
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/strict_inequality/index.html b/files/fr/web/javascript/reference/operators/strict_inequality/index.html
new file mode 100644
index 0000000000..d436d5af46
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/strict_inequality/index.html
@@ -0,0 +1,97 @@
+---
+title: Inégalité stricte (!==)
+slug: Web/JavaScript/Reference/Operators/Strict_inequality
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.strict_inequality
+translation-of: Web/JavaScript/Reference/Operators/Strict_inequality
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-strict-inequality.html")}}

+
+
Syntaxe

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

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

+
+
+3 !== "3"; // true
+

+
+
Exemples

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

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

+
+
+console.log("3" !== 3);           // true
+
+console.log(true !== 1);          // true
+
+console.log(null !== undefined);  // true
+

+
+
Comparaison d'objets

+
+
+const objet1 = {
+  name: "coucou"
+}
+
+const objet2 = {
+  name: "coucou"
+}
+
+console.log(objet1 !== objet2);  // true
+console.log(objet1 !== objet1);  // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/subtraction/index.html b/files/fr/web/javascript/reference/operators/subtraction/index.html
new file mode 100644
index 0000000000..cdada5f8cb
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/subtraction/index.html
@@ -0,0 +1,59 @@
+---
+title: Soustraction (-)
+slug: Web/JavaScript/Reference/Operators/Subtraction
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.subtraction
+translation-of: Web/JavaScript/Reference/Operators/Subtraction
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-subtraction.html")}}

+
+
Syntaxe

+
+
+Opérateur : x - y
+

+
+
Exemples

+
+
Avec des valeurs numériques

+
+
+5 - 3     // 2
+3 - 5     // -2
+

+
+
Avec des valeurs non-numériques

+
+
+'toto' - 3 // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html b/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html
new file mode 100644
index 0000000000..ad67f469d6
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html
@@ -0,0 +1,49 @@
+---
+title: Affectation après soustraction (-=)
+slug: Web/JavaScript/Reference/Operators/Subtraction_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.subtraction_assignment
+translation-of: Web/JavaScript/Reference/Operators/Subtraction_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-subtraction-assignment.html")}}

+
+
Syntaxe

+
+
+Opérateur : x -= y
+Signification :  x  = x - y
+

+
+
Exemples

+
+
Utiliser l'opérateur de soustraction et d'affectation

+
+
+let truc = 5;
+truc -= 2;      // 3
+truc -= 'toto'; // NaN
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/unary_negation/index.html b/files/fr/web/javascript/reference/operators/unary_negation/index.html
new file mode 100644
index 0000000000..bbe81aaeb6
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/unary_negation/index.html
@@ -0,0 +1,65 @@
+---
+title: Négation unaire (-)
+slug: Web/JavaScript/Reference/Operators/Unary_negation
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.unary_negation
+translation_of: Web/JavaScript/Reference/Operators/Unary_negation
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-unary-negation.html")}}

+
+
Syntaxe

+
+
+Opérateur : -x
+

+
+
Exemples

+
+
Avec des nombres

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

+
+
const x = "4";
+const y = -x;
+
+// y = -4
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/unary_plus/index.html b/files/fr/web/javascript/reference/operators/unary_plus/index.html
new file mode 100644
index 0000000000..37e7148369
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/unary_plus/index.html
@@ -0,0 +1,69 @@
+---
+title: Plus unaire (+)
+slug: Web/JavaScript/Reference/Operators/Unary_plus
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.unary_plus
+translation_of: Web/JavaScript/Reference/Operators/Unary_plus
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-unary-plus.html", "taller")}}

+
+
Syntaxe

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

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

+
+
Avec des valeurs non-numériques

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html b/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html
new file mode 100644
index 0000000000..e3255ae767
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html
@@ -0,0 +1,66 @@
+---
+title: Décalage binaire à droite non-signé (>>>)
+slug: Web/JavaScript/Reference/Operators/Unsigned_right_shift
+tags:
+  - Bitwise operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.unsigned_right_shift
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift.html")}}

+
+
Syntaxe

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

+
+
+        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) :

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

+
+
Exemples

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

+
+
+ 9 >>> 2; // 2
+-9 >>> 2; // 1073741821
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
diff --git a/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html
new file mode 100644
index 0000000000..1196307586
--- /dev/null
+++ b/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html
@@ -0,0 +1,51 @@
+---
+title: Affectation après décalage à droite non signé (>>>=)
+slug: Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment
+tags:
+  - Assignment operator
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+browser-compat: javascript.operators.unsigned_right_shift_assignment
+translation-of: Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment
+---
+
{{jsSidebar("Operators")}}

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

+
+
{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift-assignment.html")}}

+
+
Syntax

+
+
+Opérateur : x >>>= y
+Signification :  x    = x >>> y
+

+
+
Exemples

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

+
+
+let a = 5; //   (00000000000000000000000000000101)
+a >>>= 2;  // 1 (00000000000000000000000000000001)
+
+let b = -5; // (-00000000000000000000000000000101)
+b >>>= 2;   // 1073741822 (00111111111111111111111111111110)
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

+
+
-- 
cgit v1.2.3-54-g00ecf