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 <tristantheb@gmail.com>
author: SphinxKnight <SphinxKnight@users.noreply.github.com> 2021-06-27 15:03:56 +0200
committer: GitHub <noreply@github.com> 2021-06-27 15:03:56 +0200
commit: 9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 (patch)
tree: e6aa6c44ea4c523dbf72464e77745bed1efc8c51 /files/fr/web/javascript/reference/operators
parent: dc9842009bd95e0db7e058a5ebb98f27d6a3f650 (diff)
download: translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.gz
translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.bz2
translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.zip
44 files changed, 3543 insertions, 285 deletions
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
 ---
 <div>{{jsSidebar("Operators")}}</div>
 
-<div>L'opérateur d'addition (<code>+</code>) effectue la somme de deux opérandes numériques ou la concaténation de chaînes de <span class="ver" title="">caractères</span>.</div>
-
-
+<p>L'opérateur d'addition (<code>+</code>) produit la somme de deux opérandes numériques ou la concaténation de deux chaînes de caractères.</p>
 
 <div>{{EmbedInteractiveExample("pages/js/expressions-addition.html")}}</div>
 
-<div></div>
-
-<p class="hidden">La source de cet exemple interactif est stockée dans un référentiel GitHub. Si vous souhaitez contribuer au projet d'exemples interactifs, veuillez cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et envoyez-nous une pull request.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
+<h2 id="syntaxe">Syntaxe</h2>
 
-<pre class="syntaxbox notranslate"><strong>Opérateur:</strong> <var>x</var> + <var>y</var>
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var> + <var>y</var>
 </pre>
 
-<h2 id="Exemples">Exemples</h2>
+<h2 id="examples">Exemples</h2>
 
-<h3 id="Addition_numérique">Addition numérique</h3>
+<h3 id="numeric_addition">Addition numérique</h3>
 
-<pre class="brush: js notranslate">// Nombre + Nombre -&gt; addition
+<pre class="brush: js">
+// Number + Number -&gt; addition
 1 + 2 // 3
 
-// Booléen + Nombre -&gt; addition
+// Boolean + Number -&gt; addition
 true + 1 // 2
 
-// Booléen + Booléen -&gt; addition
+// Boolean + Boolean -&gt; addition
 false + false // 0
 </pre>
 
-<h3 id="Concaténation_de_chaînes">Concaténation de chaînes</h3>
+<h3 id="string_concatenation">Concaténation de chaînes de caractères</h3>
 
-<pre class="brush: js notranslate">// String + String -&gt; concatenation
-'foo' + 'bar' // "foobar"
+<pre class="brush: js">// String + String -&gt; concatenation
+'toto' + 'truc' // "tototruc"
 
 // Number + String -&gt; concatenation
-5 + 'foo' // "5foo"
+5 + 'toto' // "5toto"
 
 // String + Boolean -&gt; concatenation
-'foo' + false // "foofalse"</pre>
+'toto' + false // "totofalse"</pre>
 
-<h2 id="Spécifications">Spécifications</h2>
+<h2 id="specifications">Spécifications</h2>
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-addition-operator-plus', 'Addition operator')}}</td>
-  </tr>
- </tbody>
-</table>
+<p>{{Specifications}}</p>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
 
-<p>{{Compat("javascript.operators.addition")}}</p>
+<p>{{Compat}}</p>
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+<h2 id="see_also">Voir aussi</h2>
 
 <ul>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur reste</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur unaire plus</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
 </ul>
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
 ---
-<p>{{jsSidebar("Operators")}}</p>
+<div>{{jsSidebar("Operators")}}</div>
 
-<p>L'opérateur d'addition avec assignement (<code>+=</code>) 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.</p>
+<p>L'opérateur d'addition et d'affectation (<code>+=</code>) 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.</p>
 
 <div>{{EmbedInteractiveExample("pages/js/expressions-addition-assignment.html")}}</div>
 
-<div></div>
+<h2 id="syntax">Syntax</h2>
 
-<p class="hidden">La source de cet exemple interactif est stocké sur GitHub. Si vous voulez contribuer au projet de l'exemple interactif, merci de cloner ceci : <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et nous envoyer une "pull-request".</p>
+<pre class="brush: js">
+<strong>Opérateur :</strong> x += y
+<strong>Signification :</strong>  x  = x + y
+</pre>
 
-<h2 id="Syntaxe">Syntaxe</h2>
+<h2 id="examples">Exemples</h2>
 
-<pre class="notranslate"><strong>Opérateur :</strong> x += y
-<strong>Signifie :</strong>  x = x + y</pre>
+<h3 id="using_addition_assignment">Utiliser l'opérateur d'addition et d'affectation</h3>
 
-<h2 id="Examples">Examples</h2>
+<pre class="brush: js">
+let toto = "toto";
+let truc = 5;
+let machin = true;
 
-<h3 id="Utilisation_de_lopérateur">Utilisation de l'opérateur</h3>
+// nombre + nombre -&gt; addition
+truc += 2; // 7
 
-<pre class="brush: js notranslate">// On considère les variables suivantes :
-var chaine = "Hello";
-var nombre = 5;
-var booleen = true;
+// booléen + nombre -&gt; addition
+machin += 1; // 2
 
-// Nombre + Nombre
-nombre += 2;
-// 7
+// booléen + booléen -&gt; addition
+machin += false; // 1
 
-// Booléen + Nombre
-booleen += 1;
-// 2
+// nombre + chaîne de caractères -&gt; concaténation
+truc += 'toto'; // "5toto"
 
-// Booléen + Booléen
-booleen += false;
-// 1
+// chaîne de caractères + booléen -&gt; concaténation
+toto += false // "totofalse"
 
-// Nombre + Chaîne
-nombre += "World";
-// "5World"
+// chaîne de caractères + chaîne de caractères -&gt; concaténation
+toto += 'truc' // "tototruc"</pre>
 
-// Chaîne + Booléen
-chaine += false;
-// "Hellofalse"
+<h2 id="specifications">Spécifications</h2>
 
-// Chaîne + Chaîne
-chaine += "World"
-// "HelloWorld"</pre>
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">L'opérateur d'addition/concaténation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur ET binaire (<code>&amp;</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où les bits des deux opérandes valent <code>1</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-and.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> &amp; <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 :</p>
+
+<pre class="brush: js">
+Avant:  11100110111110100000000000000110000000000001
+Après:              10100000000000000110000000000001
+</pre>
+
+<p>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.</p>
+
+<p>La table de vérité pour l'opérateur ET est :</p>
+
+<table class="standard-table">
+  <thead>
+    <tr>
+      <th class="header" scope="col">a</th>
+      <th class="header" scope="col">b</th>
+      <th class="header" scope="col">a ET b</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>0</td>
+      <td>0</td>
+      <td>0</td>
+    </tr>
+    <tr>
+      <td>0</td>
+      <td>1</td>
+      <td>0</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>0</td>
+      <td>0</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>1</td>
+      <td>1</td>
+    </tr>
+  </tbody>
+</table>
+
+<pre class="brush: js">
+     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 &amp; 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+</pre>
+
+<p>Utiliser un ET binaire sur n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> d'autre part renverra <code>0</code>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_and">Utiliser l'opérateur ET binaire</h3>
+
+<pre class="brush: js">
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+5 &amp; 2; // 0
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après ET binaire (<code>&amp;=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-and-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x &amp;= y
+<strong>Signification :</strong>  x  = x &amp; y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_and_assignment">Utiliser l'affectation après ET binaire</h3>
+
+<pre class="brush: js">
+let a = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+a &amp;= 2; // 0
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND">L'opérateur ET binaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur binaire NON (<code>~</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-not.html")}}</div>
+
+<h2 id="syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">
+~a
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 :</p>
+
+<pre class="brush: js">
+Avant : 11100110111110100000000000000110000000000001
+Après :             10100000000000000110000000000001
+</pre>
+
+<p>Pour former le résultat, chaque bit qui compose l'opérande est inversé.</p>
+
+<p>La table de vérité pour l'opération <code>NON</code> est :</p>
+
+<table class="standard-table">
+  <thead>
+    <tr>
+      <th class="header" scope="col">a</th>
+      <th class="header" scope="col">NON a</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>0</td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>0</td>
+    </tr>
+  </tbody>
+</table>
+
+<pre class="brush: js">
+ 9 (base 10) = 00000000000000000000000000001001 (base 2)
+               --------------------------------
+~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
+</pre>
+
+<p>L'entier signé sur 32 bits est inversé selon <a href="https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux">le complément à deux</a>. Autrement dit, la présence du bit le plus significatif est utilisée pour exprimer des entiers négatifs.</p>
+
+<p>Appliquer un NON binaire sur n'importe quel nombre <code>x</code> fournira la valeur <code>-(x + 1)</code>. Ainsi, <code>~-5</code> renverra <code>4</code>.</p>
+
+<p>Étant donné l'utilisation d'une représentation sur 32 bits, <code>~-1</code> et <code>~4294967295</code> (2^32 - 1) donneront tous les deux <code>0</code>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="Using_bitwise_NOT">Utiliser le NON binaire</h3>
+
+<pre class="brush: js">~0;  // -1
+~-1; // 0
+~1;  // -2
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur OU binaire (<code>|</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où au moins un des bits des deux opérandes vaut <code>1</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-or.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> | <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 :</p>
+
+<pre class="brush: js">
+Avant:  11100110111110100000000000000110000000000001
+Après:              10100000000000000110000000000001
+</pre>
+
+<p>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.</p>
+
+<p>La table de vérité pour l'opérateur OU est :</p>
+
+<table class="standard-table">
+  <thead>
+    <tr>
+      <th class="header" scope="col">a</th>
+      <th class="header" scope="col">b</th>
+      <th class="header" scope="col">a OU b</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>0</td>
+      <td>0</td>
+      <td>0</td>
+    </tr>
+    <tr>
+      <td>0</td>
+      <td>1</td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>0</td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>1</td>
+      <td>1</td>
+    </tr>
+  </tbody>
+</table>
+
+<pre class="brush: js">
+     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
+</pre>
+
+<p>Utiliser le OU binaire avec n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> renverra toujours <code><var>x</var></code>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_or">Utiliser l'opérateur OU binaire</h3>
+
+<pre class="brush: js">
+// 9  (00000000000000000000000000001001)
+// 14 (00000000000000000000000000001110)
+
+14 | 9;
+// 15 (00000000000000000000000000001111)
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après OU binaire (<code>|=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-or-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x |= y
+<strong>Signification :</strong>  x = x | y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_or_assignment">Utiliser l'affectation après OU binaire</h3>
+
+<pre class="brush: js">
+let a = 5;
+a |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR">L'opérateur OU binaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment">L'opérateur d'affectation après OU logique (<code>||=</code>)</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur binaire OU exclusif (XOR) (<code>^</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où exactement un des bits des deux opérandes vaut <code>1</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> ^ <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 :</p>
+
+<pre class="brush: js">
+Avant:  11100110111110100000000000000110000000000001
+Après:              10100000000000000110000000000001
+</pre>
+
+<p>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.</p>
+
+<p>La table de vérité pour l'opérateur OU exclusif (XOR) est :</p>
+
+<table class="standard-table">
+  <thead>
+    <tr>
+      <th class="header" scope="col">a</th>
+      <th class="header" scope="col">b</th>
+      <th class="header" scope="col">a XOR b</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>0</td>
+      <td>0</td>
+      <td>0</td>
+    </tr>
+    <tr>
+      <td>0</td>
+      <td>1</td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>0</td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td>1</td>
+      <td>1</td>
+      <td>0</td>
+    </tr>
+  </tbody>
+</table>
+
+<pre class="brush: js">
+.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+</pre>
+
+<p>Utiliser le OU exclusif binaire avec n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> d'autre part renverra <code><var>x</var></code>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_xor">Utiliser le OU exclusif binaire</h3>
+
+<pre class="brush: js">
+// 9  (00000000000000000000000000001001)
+// 14 (00000000000000000000000000001110)
+
+14 ^ 9;
+// 7  (00000000000000000000000000000111)
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide javascript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après OU exclusif (XOR) binaire (<code>^=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x ^= y
+<strong>Signification :</strong>  x  = x ^ y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_bitwise_xor_assignment">Utiliser l'affectation après OU exclusif binaire</h3>
+
+<pre class="brush: js">
+let a = 5;      // 00000000000000000000000000000101
+a ^= 3;         // 00000000000000000000000000000011
+
+console.log(a); // 00000000000000000000000000000110
+// 6
+
+let b = 5;      // 00000000000000000000000000000101
+b ^= 0;         // 00000000000000000000000000000000
+
+console.log(b); // 00000000000000000000000000000101
+// 5
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR">L'opérateur OU exclusif binaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de décrémentation (<code>--</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-decrement.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var>-- ou --<var>x</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans <code><var>x</var>--</code>, l'opérateur décrémentera la valeur et renverra la valeur avant l'incrément.</p>
+
+<p>Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans <code>--<var>x</var></code>, l'opérateur décrémentera la valeur et renverra la valeur après l'incrément.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="postfix_decrement">Décrément en suffixe</h3>
+
+<pre class="brush: js">let x = 3;
+let y = x--;
+
+// y = 3
+// x = 2
+</pre>
+
+<h3 id="prefix_decrement">Décrément en préfixe</h3>
+
+<pre class="brush: js">let a = 2;
+let b = --a;
+
+// a = 1
+// b = 1
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur de plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de division (<code>/</code>) fournit le quotient de l'opérande gauche (le numérateur) divisé par l'opérande droite (le dénominateur).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-division.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var> / <var>y</var>
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="basic_division">Divisions simples</h3>
+
+<pre class="brush: js">
+1 / 2             // 0.5
+Math.floor(3 / 2) // 1
+1.0 / 2.0         // 0.5
+</pre>
+
+<h3 id="division_by_zero">Division par zéro</h3>
+
+<pre class="brush: js">
+2.0 / 0     // Infinity
+2.0 / 0.0   // Infinity, because 0.0 === 0
+2.0 / -0.0  // -Infinity
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de division et d'affectation (<code>/=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-division-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x /= y
+<strong>Signification:</strong>  x  = x / y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_division_assignment">Utiliser l'opérateur de division et d'affectation</h3>
+
+<pre class="brush: js">
+let truc = 5;
+truc /= 2;      // 2.5
+truc /= 2;      // 1.25
+truc /= 0;      // Infinity
+truc /= 'toto'; // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">L'opérateur de division</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'égalité (<code>==</code>) 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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">d'égalité stricte</a>, l'opérateur d'égalité tente de convertir ses opérandes avant la comparaison si ceux-ci sont de types différents.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x == y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérateurs d'égalité (<code>==</code> et <code>!=</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">l'algorithme de comparaison d'égalité abstraite</a> pour comparer deux opérandes. On peut le résumer ainsi :</p>
+
+<ul>
+  <li>Si les opérandes sont deux objets, on renvoie <code>true</code> uniquement si les deux opérandes référencent le même objet.</li>
+  <li>Si un opérande vaut <code>null</code> et que l'autre vaut <code>undefined</code>, on renvoie <code>true</code>.</li>
+  <li>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 :
+    <ul>
+      <li>Si on compare un nombre à une chaîne de caractères, on tentera de convertir la chaîne en une valeur numérique.</li>
+      <li>Si l'un des opérandes est un booléen, on le convertira en 1 s'il vaut <code>true</code> et en +0 s'il vaut <code>false</code>.</li>
+      <li>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 <code>valueOf()</code> et <code>toString()</code> de l'objet.</li>
+    </ul>
+  </li>
+  <li>Si les opérandes sont du même types, on les compare comme suit :
+    <ul>
+      <li><code>String</code> : on renvoie <code>true</code> uniquement si les deux opérandes ont les mêmes caractères dans le même ordre.</li>
+      <li><code>Number</code> : on renvoie <code>true</code> uniquement si les deux opérandes ont la même valeur. <code>+0</code> et <code>-0</code> sont considérés comme la même valeur. Si au moins un des opérandes vaut <code>NaN</code>, on renvoie <code>false</code>.</li>
+      <li><code>Boolean</code> : on renvoie <code>true</code> uniquement si les deux opérandes valent tous les deux <code>true</code> ou s'ils valent tous les deux <code>false</code>.</li>
+    </ul>
+  </li>
+</ul>
+
+<p>La différence fondamentale entre cet opérateur et <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">l'opérateur d'égalité stricte</a> (<code>===</code>) 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.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="comparison_with_no_type_conversion">Comparaison sans conversion de types</h3>
+
+<pre class="brush: js">
+1 == 1;              // true
+"coucou" == "coucou";  // true
+</pre>
+
+<h3 id="comparison_with_type_conversion">Comparaison avec conversion de types</h3>
+
+<pre class="brush: js">
+"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
+</pre>
+
+<h3 id="comparison_of_objects">Comparaison d'objets</h3>
+
+<pre class="brush: js">
+const objet1 = {"clé": "valeur"}
+const objet2 = {"clé": "valeur"};
+
+objet1 == objet2 // false
+objet2 == objet2 // true
+</pre>
+
+<h3 id="comparing_strings_and_string_objects">Comparaison entre des chaînes de caractères et des objets String</h3>
+
+<p>On notera que les chaînes de caractères construites avec <code>new String()</code> sont des objets. Si on compare une telle valeur avec une chaîne de caractères "primitives", l'objet <code>String</code> 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 <code>String</code>, ils seront comparés comme tels et devront référencer le même objet pour être considérés égaux :</p>
+
+<pre class="brush: js">
+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
+</pre>
+
+<h3 id="comparing_dates_and_strings">Comparaison entre les dates et les chaînes de caractères</h3>
+
+<pre class="brush: js">
+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
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'exponentiation (<code>**</code>) fournit le résultat obtenu lorsqu'on élève le premier opérande à la puissance indiquée par le second. Il est équivalent <code>Math.pow</code> exception faite que cet opérateur permet également d'utiliser des valeurs BigInt comme opérandes.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-exponentiation.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>var1</var> ** <var>var2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>L'opérateur d'exponentiation est associatif à droite : <code><var>a</var> ** <var>b</var> ** <var>c</var></code> est équivalent à <code><var>a</var> ** (<var>b</var> ** <var>c</var>)</code>.</p>
+
+<p>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 <code>+</code> ou la soustraction unaire <code>-</code>). Il existe toutefois quelques exceptions comme Bash, où <code>**</code> possède une précédence inférieure à celles des opérateurs unaires.</p>
+
+<p>En JavaScript, il est impossible d'écrire une expression d'exponentiation ambigüe : on ne peut pas placer un opérateur unaire (<code>+/-/~/!/delete/void/typeof</code>) avant le nombre servant de base, cela provoquera une exception <code>SyntaxError</code>.</p>
+
+<pre class="brush: js">
+-2 ** 2;
+// 4 en Bash, -4 pour d'autres langages.
+// Invalide en JavaScript car l'opération est ambigüe.
+
+-(2 ** 2);
+// -4 en JavaScript, les parenthèses évitent l'ambiguité.
+</pre>
+
+<p>Attnetion, certains langages de programmation utilisent l'accent circonflexe <kbd>^</kbd> pour exprimer l'exponentiaion mais JavaScript utilise ce symbole pour <a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">l'opérateur binaire OU exclusif (XOR)</a>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="basic_exponentiation">Exponentiation simple</h3>
+
+<pre class="brush: js">
+2 ** 3   // 8
+3 ** 2   // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+</pre>
+
+<h3 id="associativity">Associativité</h3>
+
+<pre class="brush: js">
+2 ** 3 ** 2   // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64</pre>
+
+<h3 id="usage_with_unary_operators">Avec les opérateurs unaires</h3>
+
+<p>Pour prendre l'opposé du résultat :</p>
+
+<pre class="brush: js">
+-(2 ** 2) // -4
+</pre>
+
+<p>Pour forcer le signe de la base en négatif :</p>
+
+<pre class="brush: js">(-2) ** 2 // 4
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'exponentiation et d'affectation (<code>**=</code>) é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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-exponentiation-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x **= y
+<strong>Signification :</strong>  x  = x ** y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_exponentiation_assignment">Utiliser l'opérateur d'exponentiation et d'affectation</h3>
+
+<pre class="brush: js">
+let truc = 5;
+truc **= 2;      // 25
+truc **= 'toto'; // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">L'opérateur d'exponentiation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur supérieur strict (<code>&gt;</code>) renvoie <code>true</code> si l'opérande gauche est strictement supérieur à l'opérande droit et <code>false</code> sinon.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-greater-than.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x &gt; y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="number_to_number_comparison">Comparaison numérique</h3>
+
+<pre class="brush: js">
+console.log(5 &gt; 3);            // true
+console.log(3 &gt; 3);            // false
+console.log(3 &gt; 5);            // false
+</pre>
+
+<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3>
+
+<pre class="brush: js">
+console.log(5n &gt; 3);           // true
+console.log(3 &gt; 5n);           // false
+</pre>
+
+<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("a" &gt; "b");        // false
+console.log("a" &gt; "a");        // false
+console.log("a" &gt; "3");        // true
+</pre>
+
+<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("5" &gt; 3);          // true
+console.log("3" &gt; 3);          // false
+console.log("3" &gt; 5);          // false
+
+console.log("coucou" &gt; 5);      // false
+console.log(5 &gt; "coucou");      // false
+
+console.log("5" &gt; 3n);         // true
+console.log("3" &gt; 5n);         // false
+</pre>
+
+<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3>
+
+<pre class="brush: js">
+console.log(true &gt; false);     // true
+console.log(false &gt; true);     // false
+
+console.log(true &gt; 0);         // true
+console.log(true &gt; 1);         // false
+
+console.log(null &gt; 0);         // false
+console.log(1 &gt; null);         // true
+
+console.log(undefined &gt; 3);    // false
+console.log(3 &gt; undefined);    // false
+
+console.log(3 &gt; NaN);          // false
+console.log(NaN &gt; 3);          // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur supérieur ou égal (<code>&gt;=</code>) renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à l'opérande droit et <code>false</code> sinon.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-greater-than-or-equal.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x &gt;= y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="number_to_number_comparison">Comparaison numérique</h3>
+
+<pre class="brush: js">
+console.log(5 &gt;= 3);         // true
+console.log(3 &gt;= 3);         // true
+console.log(3 &gt;= 5);         // false
+</pre>
+
+<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3>
+
+<pre class="brush: js">
+console.log(5n &gt;= 3);        // true
+console.log(3 &gt;= 3n);        // true
+console.log(3 &gt;= 5n);        // false
+</pre>
+
+<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("a" &gt;= "b");     // false
+console.log("a" &gt;= "a");     // true
+console.log("a" &gt;= "3");     // true
+</pre>
+
+<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("5" &gt;= 3);       // true
+console.log("3" &gt;= 3);       // true
+console.log("3" &gt;= 5);       // false
+
+console.log("coucou" &gt;= 5);   // false
+console.log(5 &gt;= "coucou");   // false
+</pre>
+
+<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3>
+
+<pre class="brush: js">
+console.log(true &gt;= false);  // true
+console.log(true &gt;= true);   // true
+console.log(false &gt;= true);  // false
+
+console.log(true &gt;= 0);      // true
+console.log(true &gt;= 1);      // true
+
+console.log(null &gt;= 0);      // true
+console.log(1 &gt;= null);      // true
+
+console.log(undefined &gt;= 3); // false
+console.log(3 &gt;= undefined); // false
+
+console.log(3 &gt;= NaN);       // false
+console.log(NaN &gt;= 3);       // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'incrémentation (<code>++</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-increment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var>++ ou ++<var>x</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans <code><var>x</var>++</code>, l'opérateur incrémentera la valeur et renverra la valeur avant l'incrément.</p>
+
+<p>Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans <code>++<var>x</var></code>, l'opérateur incrémentera la valeur et renverra la valeur après l'incrément.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="postfix_increment">Incrément en suffixe</h3>
+
+<pre class="brush: js">let x = 3;
+let y = x++;
+
+// y = 3
+// x = 4
+</pre>
+
+<h3 id="prefix_increment">Incrément en préfixe</h3>
+
+<pre class="brush: js">let a = 2;
+let b = ++a;
+
+// a = 3
+// b = 3
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="See_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur de plus unaire</a></li>
+</ul>
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
 ---
 <div>{{jsSidebar("Operators")}}</div>
 
-<p>Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés utilisés en JavaScript.</p>
+<p class="summary">Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés pour le langage JavaScript.</p>
 
-<h2 id="Expressions_et_opérateurs_par_catégorie">Expressions et opérateurs, par catégorie</h2>
+<h2 id="expressions_and_operators_by_category">Expressions et opérateurs par catégorie</h2>
 
-<p>Pour une liste alphabétique, voir le volet de navigation situé à gauche sur cette page.</p>
+<p>Pour une liste triée par ordre alphabétique, voir sur la barre de navigation à gauche.</p>
 
-<h3 id="Expressions_primaires">Expressions primaires</h3>
+<h3 id="primary_expressions">Expressions primaires</h3>
 
-<p>Les mots-clés basiques et les expressions générales en JavaScript.</p>
+<p>Mots-clés de base et expressions générales en JavaScript.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/L_opérateur_this", "this")}}</dt>
- <dd>Le mot-clé <code>this</code> fait référence à une propriété spéciale du contexte d'exécution de la fonction.</dd>
- <dt>{{jsxref("Opérateurs/L_opérateur_function", "function")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/this"><code>this</code></a></dt>
+ <dd>Le mot-clé <code>this</code> fait référence à une propriété spéciale indiquant le contexte d'exécution.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/function"><code>function</code></a></dt>
  <dd>Le mot-clé <code>function</code> définit une expression de fonction.</dd>
- <dt>{{jsxref("Opérateurs/class", "class")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/class"><code>class</code></a></dt>
  <dd>Le mot-clé <code>class</code> définit une expression de classe.</dd>
- <dt> {{jsxref("Opérateurs/function*", "function*")}}</dt>
- <dd>Le mot-clé <code>function*</code> définit une expression pour une fonction génératrice.</dd>
- <dt>{{jsxref("Opérateurs/yield", "yield")}}</dt>
- <dd>Cet opérateur permet de suspendre et de reprendre l'exécution d'une fonction génératrice.</dd>
- <dt>{{jsxref("Opérateurs/yield*", "yield*")}}</dt>
- <dd>Cet opérateur permet de déléguer l'exécution de la fonction à une autre fonction ou un autre objet itérable.</dd>
- <dt>{{experimental_inline}} {{jsxref("Opérateurs/async_function", "async function*")}}</dt>
- <dd>L'opérateur <code>async function</code> définit une expression de fonction asynchrone.</dd>
- <dt>{{experimental_inline}} {{jsxref("Opérateurs/await", "await")}}</dt>
- <dd>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.</dd>
- <dt>{{jsxref("Objets_globaux/Array", "[]")}}</dt>
- <dd>Littéral initialisateur de tableau.</dd>
- <dt>{{jsxref("Opérateurs/Initialisateur_objet", "{}")}}</dt>
- <dd>Littéral initialisateur d'objet.</dd>
- <dt>{{jsxref("Objets_globaux/RegExp", "/ab+c/i")}}</dt>
- <dd>Littéral d'expression rationnelle.</dd>
- <dt>{{jsxref("Opérateurs/Groupement", "( )")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/function*"><code>function*</code></a></dt>
+ <dd>Le mot-clé <code>function*</code> définit une expression de générateur.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield"><code>yield</code></a></dt>
+ <dd>Ce mot-clé permet de suspendre ou de reprendre l'exécution d'une fonction génératrice.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield*"><code>yield*</code></a></dt>
+ <dd>Ce mot-clé délègue à une autre fonction génératrice ou à un objet itérable.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/async_function"><code>async function</code></a></dt>
+ <dd>Le couple de mots-clés <code>async function</code> définit une expression de fonction asynchrone.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/await"><code>await</code></a></dt>
+ <dd>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.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array"><code>[]</code></a></dt>
+ <dd>Syntaxe d'initialisation littérale pour les tableaux.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer"><code>{}</code></a></dt>
+ <dd>Syntaxe d'initialisation littérale pour les objets.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>/ab+c/i</code></a></dt>
+ <dd>Syntaxe pour les expressions littérales d'expressions rationnelles.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Grouping"><code>( )</code></a></dt>
  <dd>Opérateur de groupement.</dd>
 </dl>
 
-<h3 id="Expressions_«_vers_la_gauche_»">Expressions « vers la gauche »</h3>
+<h3 id="left-hand-side_expressions">Expression « vers la gauche »</h3>
 
-<p>On affectera des valeurs aux variables à gauche de l'expression.</p>
+<p>Les valeurs situées à gauche sont la cible de l'affectation.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_membres", "Opérateurs de membres", "", 1)}}</dt>
- <dd>Les opérateurs de membres permettent d'accéder à une propriété ou une méthode d'un objet (<code>objet.propriété</code> et <code>object["propriété"]</code>).</dd>
- <dt>{{jsxref("Opérateurs/L_opérateur_new", "new")}}</dt>
- <dd>L'opérateur <code>new</code> permet de créer une instance d'un constructeur.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></dt>
- <dd>Dans les constructeurs, <code>new.target</code> fait référence au constructeur invoqué par {{jsxref("Opérateurs/new", "new")}}.</dd>
- <dt>{{jsxref("Opérateurs/super", "super")}}</dt>
- <dd>Le mot-clé <code>super</code> permet d'appeler le constructeur parent.</dd>
- <dt>{{jsxref("Opérateurs/Syntaxe_décomposition", "...obj")}}</dt>
- <dd>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).</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Accesseurs de propriété</a></dt>
+ <dd>Les opérateurs d'accès aux membres permettent d'accéder à une propriété ou à une méthode d'un objet.<br>
+ (cela regroupe <code>objet.propriete</code> et <code>objet["propriete"]</code>).</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></dt>
+ <dd>L'opérateur <code>new</code> crée une instance grâce à un constructeur.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/new.target"><code>new.target</code></a></dt>
+ <dd>Pour les constructeurs, <code>new.target</code> fait référence au constructeur invoqué avec <a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a>.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Statements/import.meta"><code>import.meta</code></a></dt>
+ <dd>Un objet qui expose des métadonnées spécifiques au contexte pour un module JavaScript.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/super"><code>super</code></a></dt>
+ <dd>Le mot-clé <code>super</code> appelle le constructeur parent.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Spread_syntax"><code>...obj</code></a></dt>
+ <dd>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.</dd>
 </dl>
 
-<h3 id="Incrémentation_et_décrémentation">Incrémentation et décrémentation</h3>
+<h3 id="increment_and_decrement">Incrémentation et décrémentation</h3>
 
-<p>Les opérateurs d'incrémentation et de décrémentation, suffixe et préfixe :</p>
+<p>Des opérateurs préfixes ou suffixes pour incrémenter/décrémenter.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A++", "#Incr.C3.A9ment_(.2B.2B)")}}</dt>
- <dd>Opérateur d'incrémentation suffixe.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A--", "#D.C3.A9cr.C3.A9ment_(--)")}}</dt>
- <dd>Opérateur de décrémentation suffixe.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "++A", "#Incr.C3.A9ment_(.2B.2B)")}}</dt>
- <dd>Opérateur d'incrémentation préfixe.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "--A", "#D.C3.A9cr.C3.A9ment_(--)")}}</dt>
- <dd>Opérateur de décrémentation préfixe.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment"><code>A++</code></a></dt>
+ <dd>L'opérateur d'incrémentation suffixe.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement"><code>A--</code></a></dt>
+ <dd>L'opérateur de décrémentation suffixe.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment"><code>++A</code></a></dt>
+ <dd>L'opérateur d'incrémentation préfixe.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement"><code>--A</code></a></dt>
+ <dd>L'opérateur de décrémentation préfixe.</dd>
 </dl>
 
-<h3 id="Opérateurs_unaires">Opérateurs unaires</h3>
+<h3 id="unary_operators">Opérateurs unaires</h3>
 
-<p>Une opération unaire est une opération qui ne possède qu'un opérande.</p>
+<p>Une opération unaire est une opération qui ne manipule qu'un seul opérande.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/L_opérateur_delete", "delete")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/delete"><code>delete</code></a></dt>
  <dd>L'opérateur <code>delete</code> permet de supprimer une propriété d'un objet.</dd>
- <dt>{{jsxref("Opérateurs/L_opérateur_void", "void")}}</dt>
- <dd>L'opérateur <code>void</code> écarte la valeur de retour d'une expression.</dd>
- <dt>{{jsxref("Opérateurs/L_opérateur_typeof", "typeof")}}</dt>
- <dd>L'opérateur <code>typeof</code> permet de déterminer le type d'un objet donné.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Plus_unaire_(.2B)")}}</dt>
- <dd>Le plus unaire permet de convertir son opérande en une valeur du type <code>Number</code>.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#N.C3.A9gation_unaire_(-)")}}</dt>
- <dd>La négation unaire permet de convertir son opérande en une valeur du type <code>Number</code> puis d'en prendre l'opposé.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "~", "#.7E_.28NON_binaire.29")}}</dt>
- <dd>L'opérateur binaire NON (<em>NOT</em>).</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "!", "#NON_logique_.28.21.29")}}</dt>
- <dd>L'opérateur du NON logique.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/void"><code>void</code></a></dt>
+ <dd>L'opérateur <code>void</code> permet d'ignorer la valeur de retour d'une expression.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code></a></dt>
+ <dd>L'opérateur <code>typeof</code> détermine le type d'un objet donné.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus"><code>+</code></a></dt>
+ <dd>L'opérateur unaire <code>+</code> convertit son opérande en une valeur de type <code>number</code>.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation"><code>-</code></a></dt>
+ <dd>L'opérateur unaire <code>-</code> convertit son opérande en nombre puis prend son opposé.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT"><code>~</code></a></dt>
+ <dd>L'opérateur binaire NON.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT"><code>!</code></a></dt>
+ <dd>L'opérateur logique NON.</dd>
 </dl>
 
-<h3 id="Opérateurs_arithmétiques">Opérateurs arithmétiques</h3>
+<h3 id="arithmetic_operators">Opérateurs arithmétiques</h3>
 
-<p>Les opérateurs arithmétiques utilisent des opérandes numériques et renvoie une valeur numérique.</p>
+<p>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.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Addition_(.2B)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition"><code>+</code></a></dt>
  <dd>L'opérateur d'addition.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#Soustraction_(-)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction"><code>-</code></a></dt>
  <dd>L'opérateur de soustraction.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "/", "#Division_(.2F)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division"><code>/</code></a></dt>
  <dd>L'opérateur de division.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "*", "#Multiplication_(*)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication"><code>*</code></a></dt>
  <dd>L'opérateur de multiplication.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "%", "#Reste_(.25)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder"><code>%</code></a></dt>
  <dd>L'opérateur du reste.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques","**","#Exponentiation")}}</dt>
- <dd>Opérateur de puissance (exponentiation).</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation"><code>**</code></a></dt>
+ <dd>L'opérateur d'exponentiation.</dd>
 </dl>
 
-<h3 id="Opérateurs_relationnels">Opérateurs relationnels</h3>
+<h3 id="relational_operators">Opérateurs relationnels</h3>
 
-<p>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.</p>
+<p>Un opérateur de comparaison compare ses opérandes et renvoie une valeur booléenne en fonction de la vérité de cette comparaison.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/L_opérateur_in", "in")}}</dt>
- <dd>L'opérateur <code>in</code> permet de déterminer si un objet possède une propriété donnée.</dd>
- <dt>{{jsxref("Opérateurs/instanceof", "instanceof")}}</dt>
- <dd>L'opérateur <code>instanceof</code> permet de déterminer si un objet est une instance d'un autre objet.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "&lt;", "#Op.C3.A9rateur_inf.C3.A9rieur_strict_(&lt;)")}}</dt>
- <dd>Opérateur inférieur strict.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "&gt;", "#Op.C3.A9rateur_sup.C3.A9rieur_strict_(&gt;)")}}</dt>
- <dd>Opérateur supérieur strict.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "&lt;=", "#Op.C3.A9rateur_inf.C3.A9rieur_ou_.C3.A9gal_(&lt;.3D)")}}</dt>
- <dd>Opérateur inférieur ou égal.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "&gt;=", "#Op.C3.A9rateur_sup.C3.A9rieur_ou_.C3.A9gal_(&gt;.3D)")}}</dt>
- <dd>Opérateur supérieur ou égal.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/in"><code>in</code></a></dt>
+ <dd>L'opérateur <code>in</code> détermine la présence d'une propriété donnée au sein d'un objet.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code></a></dt>
+ <dd>L'opérateur <code>instanceof</code> détermine si un objet est une instance d'un autre objet.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than"><code>&lt;</code></a></dt>
+ <dd>L'opérateur d'infériorité strict.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than"><code>&gt;</code></a></dt>
+ <dd>L'opérateur de supériorité stricte.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal"><code>&lt;=</code></a></dt>
+ <dd>L'opérateur d'infériorité.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal"><code>&gt;=</code></a></dt>
+ <dd>L'opérateur de supériorité.</dd>
 </dl>
 
-<div class="note">
-<p><strong>Note :</strong> <code>=&gt;</code> n'est pas un opérateur. Il s'agit de la notation utilisée pour <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">les fonctions fléchées</a>.</p>
+<div class="notecard note">
+<p><strong>Note :</strong> <code>=&gt;</code> n'est pas un opérateur mais la notation utilisée pour <a href="/fr/docs/Web/JavaScript/Reference/Functions/Arrow_functions">les fonctions fléchées</a>.</p>
 </div>
 
-<h3 id="Opérateurs_d'égalité">Opérateurs d'égalité</h3>
+<h3 id="equality_operators">Opérateurs d'égalité</h3>
 
-<p>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.</p>
+<p>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.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#Egalit.C3.A9_(.3D.3D)")}}</dt>
- <dd>Opérateur d'égalité faible.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!=", "#Inequality_(!.3D)")}}</dt>
- <dd>Opérateur d'inégalité faible.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}}</dt>
- <dd>Opérateur d'égalité stricte.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!==", "#Non-identity_.2F_strict_not_equal_(!.3D.3D)")}}</dt>
- <dd>Opérateur d'inégalité stricte.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality"><code>==</code></a></dt>
+ <dd>L'opérateur d'égalité.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality"><code>!=</code></a></dt>
+ <dd>L'opérateur d'inégalité.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality"><code>===</code></a></dt>
+ <dd>L'opérateur d'identité.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality"><code>!==</code></a></dt>
+ <dd>L'opérateur d'inégalité stricte.</dd>
 </dl>
 
-<h3 id="Opérateurs_de_décalage_binaires">Opérateurs de décalage binaires</h3>
+<h3 id="bitwise_shift_operators">Opérateurs de décalage binaires</h3>
 
-<p>Ces opérations permettent de décaler les bits contenus dans l'opérande.</p>
+<p>Ces opérations permettent de décaler les bits de la représentation binaire de l'opérande.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "&lt;&lt;", "#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29")}}</dt>
- <dd>Opérateur binaire de décalage à gauche.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "&gt;&gt;", "#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29")}}</dt>
- <dd>Opérateur binaire de décalage à droite.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "&gt;&gt;&gt;", "#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29")}}</dt>
- <dd>Opérateur binaire de décalage à droite non-signé.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift"><code>&lt;&lt;</code></a></dt>
+ <dd>Opérateur de décalage binaire à gauche.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift"><code>&gt;&gt;</code></a></dt>
+ <dd>Opérateur de décalage binaire à droite.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift"><code>&gt;&gt;&gt;</code></a></dt>
+ <dd>Opérateur de décalage binaire à droite non signé.</dd>
 </dl>
 
-<h3 id="Opérateurs_binaires_logiques">Opérateurs binaires logiques</h3>
+<h3 id="Binary_bitwise_operators">Opérateurs binaires booléens</h3>
 
-<p>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.</p>
+<p>Ces opérateurs manipulent leurs opérandes comme des ensembles de 32 bits et renvoient des valeurs numériques standard.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "&amp;", "#&amp;_.28ET_binaire.29")}}</dt>
- <dd>ET binaire (<em>AND</em>).</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "|", "#|_.28OU_binaire.29")}}</dt>
- <dd>OU binaire (<em>OR</em>).</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "^", "#.5E_.28XOR_binaire.29")}}</dt>
- <dd>OU exclusif binaire (<em>XOR</em>).</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND"><code>&amp;</code></a></dt>
+ <dd>Opérateur ET/AND binaire.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR"><code>|</code></a></dt>
+ <dd>Opérateur OU/OR binaire.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR"><code>^</code></a></dt>
+ <dd>Opérateur OU exclusif/XOR binaire.</dd>
 </dl>
 
-<h3 id="Opérateurs_logiques">Opérateurs logiques</h3>
+<h3 id="binary_logical_operators">Opérateurs logiques</h3>
 
-<p>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.</p>
+<p>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.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "&amp;&amp;", "#ET_logique_.28&amp;&amp;.29")}}</dt>
- <dd>ET logique (<em>AND</em>).</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "||", "#OU_logique_.28||.29")}}</dt>
- <dd>OU logique (<em>OR</em>).</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND"><code>&amp;&amp;</code></a></dt>
+ <dd>Opérateur logique ET/AND.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR"><code>||</code></a></dt>
+ <dd>Opérateur logique OU/OR.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator"><code>??</code></a></dt>
+ <dd>Opérateur de coalescence des nuls.</dd>
 </dl>
 
-<h3 id="Opérateur_conditionnel_ternaire">Opérateur conditionnel ternaire</h3>
+<h3 id="conditional_ternary_operator">Opérateur conditionnel ternaire</h3>
 
 <dl>
- <dt>{{jsxref("Opérateurs/L_opérateur_conditionnel", "(condition ? siVrai : siFaux)")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator"><code>(condition ? ifTrue : ifFalse)</code></a></dt>
  <dd>
- <p>Cet opérateur renvoie une des deux valeurs fournie en fonction de la valeur logique de la condition.</p>
+ <p>L'opérateur conditionnel renvoie une valeur parmi deux selon la valeur logique de la condition portée par le premier opérande.</p>
  </dd>
 </dl>
 
-<h3 id="Opérateurs_d'affectation">Opérateurs d'affectation</h3>
-
-<p>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.</p>
+<h3 id="optional_chaining_operator">Opérateur de chaînage optionnel</h3>
 
 <dl>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "=", "#Assignment")}}</dt>
- <dd>Opérateur d'affectation.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "*=", "#Multiplication_assignment")}}</dt>
- <dd>Affectation après multiplication.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "/=", "#Division_assignment")}}</dt>
- <dd>Affectation après division.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "%=", "#Remainder_assignment")}}</dt>
- <dd>Affectation du reste.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "+=", "#Addition_assignment")}}</dt>
- <dd>Affectation après addition.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "-=", "#Subtraction_assignment")}}</dt>
- <dd>Affectation après soustraction.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "&lt;&lt;=", "#Left_shift_assignment")}}</dt>
- <dd>Affectation après décalage à gauche.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "&gt;&gt;=", "#Right_shift_assignment")}}</dt>
- <dd>Affectation après décalage à droite.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "&gt;&gt;&gt;=", "#Unsigned_right_shift_assignment")}}</dt>
- <dd>Affectation après décalage à droite non-signé.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "&amp;=", "#Bitwise_AND_assignment")}}</dt>
- <dd>Affectation après ET binaire.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "^=", "#Bitwise_AND_assignment")}}</dt>
- <dd>Affectation après OU exclusif binaire.</dd>
- <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "|=","#Bitwise_OR_assignment")}}</dt>
- <dd>Affectation après OU binaire.</dd>
- <dt>{{jsxref("Opérateurs/Affecter_par_décomposition", "[a, b] = [1, 2]")}} {{jsxref("Opérateurs/Affecter_par_décomposition", "{a, b} = {a:1, b:2}")}}</dt>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Optional_chaining"><code>?.</code></a></dt>
  <dd>
- <p>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.</p>
+ <p>L'opérateur de chaînage optionnel renvoie <code>undefined</code> plutôt que de causer une erreur si une référence vaut <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>.</p>
  </dd>
 </dl>
 
-<h3 id="Opérateur_virgule">Opérateur virgule</h3>
+<h3 id="assignment_operators">Opérateurs d'affectation</h3>
+
+<p>Un opérateur d'affectation permet d'affecter une valeur à son opérande gauche en fonction de la valeur de son opérande droit.</p>
 
 <dl>
- <dt>{{jsxref("Opérateurs/L_opérateur_virgule", ",")}}</dt>
- <dd>L'opérateur virgule permet d'évaluer plusieurs expressions en une seule instruction et de renvoyer le résultat de la dernière expression.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Assignment"><code>=</code></a></dt>
+ <dd>Opérateur d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication_assignment"><code>*=</code></a></dt>
+ <dd>Opérateur de multiplication et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation_assignment"><code>**=</code></a></dt>
+ <dd>Opérateur d'exponentiation et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division_assignment"><code>/=</code></a></dt>
+ <dd>Opérateur de division et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder_assignment"><code>%=</code></a></dt>
+ <dd>Opérateur de reste et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition_assignment"><code>+=</code></a></dt>
+ <dd>Opérateur d'addition et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction_assignment"><code>-=</code></a></dt>
+ <dd>Opérateur de soustraction et d'affectation</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift_assignment"><code>&lt;&lt;=</code></a></dt>
+ <dd>Opérateur de décalage à gauche et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift_assignment"><code>&gt;&gt;=</code></a></dt>
+ <dd>Opérateur de décalage à droite et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment"><code>&gt;&gt;&gt;=</code></a></dt>
+ <dd>Opérateur de décalage à droite non signé et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment"><code>&amp;=</code></a></dt>
+ <dd>Opérateur binaire ET et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment"><code>^=</code></a></dt>
+ <dd>Opérateur binaire OU exclusif et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR_assignment"><code>|=</code></a></dt>
+ <dd>Opérateur binaire OU et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND_assignment"><code>&amp;&amp;=</code></a></dt>
+ <dd>Opérateur booléen ET et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment"><code>||=</code></a></dt>
+ <dd>Opérateur booléen OU et d'affectation.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_nullish_assignment"><code>??=</code></a></dt>
+ <dd>Opérateur d'affectation et de logique nulle.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment"><code>[a, b] = [1, 2]</code></a><br>
+ <a href="/fr/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment"><code>{a, b} = {a:1, b:2}</code></a></dt>
+ <dd>
+ <p>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.</p>
+ </dd>
 </dl>
 
-<h3 id="Fonctionnalités_non-standardsnon-standard_inline">Fonctionnalités non-standards{{non-standard_inline}}</h3>
+<h3 id="comma_operator">Opérateur virgule</h3>
 
 <dl>
- <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fermetures", "Expression de fermetures", "", 1)}}</dt>
- <dd>La syntaxe d'expression de fermeture est un raccourci pour écrire des fonctions simples.</dd>
- <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fonction_génératrice_historique", "", 1)}}</dt>
- <dd>Le mot-clé <code>function</code> peut être utilisé afin de définir une fonction génératrice historique. au sein d'une expression.</dd>
- <dt>{{non-standard_inline}} {{jsxref("Opérateurs/Compréhensions_de_tableau", "[for (x of y) x]")}}</dt>
- <dd>Compréhensions de tableau.</dd>
- <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Compréhensions_de_générateur", "(for (x of y) y)")}}</dt>
- <dd>Compréhensions de générateurs.</dd>
+ <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Comma_Operator"><code>,</code></a></dt>
+ <dd>L'opérateur virgule permet d'évaluer plusieurs expressions dans une seule instruction et renvoie le résultat de la dernière expression.</dd>
 </dl>
 
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1','#sec-11','Expressions')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Nouveaux éléments : opérateur de décomposition, affectation par décomposition, mot-clé <code>super</code> .</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.operators")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
 
 <ul>
- <li><a href="/fr/docs/JavaScript/Reference/Operators/Pr%C3%A9c%C3%A9dence_des_op%C3%A9rateurs">La précédence des opérateurs</a> en JavaScript</li>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Précédence des opérateurs en JavaScript</a></li>
 </ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'inégalité (<code>!=</code>) 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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">d'inégalité stricte</a>, l'opérateur d'inégalité tente une conversion de ses opérandes avant la comparaison si ceux-ci sont de types différents.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-inequality.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x != y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a> et les deux lignes suivantes fourniront donc toujours le même résultat :</p>
+
+<pre class="brush: js">
+x != y
+!(x == y)
+</pre>
+
+<p>Pour plus de détails sur l'algorithme de comparaison utilisé, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">la page relative à l'opérateur d'égalité</a>.
+</p>
+
+<p>À 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 :</p>
+
+<pre class="brush: js">
+3 != "3"; // false
+</pre>
+
+<p>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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">l'opérateur d'inégalité stricte</a> à la place :</p>
+
+<pre class="brush: js">
+3 !== "3"; // true
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="comparison_with_no_type_conversion">Comparaison sans conversion de types</h3>
+
+<pre class="brush: js">
+1 != 2;              // true
+"hello" != "hola";   // true
+
+1 != 1;              // false
+"hello" != "hello";  // false
+</pre>
+
+<h3 id="comparison_with_type_conversion">Comparaison avec conversion de types</h3>
+
+<pre class="brush: js">
+"1" !=  1;            // false
+1 != "1";             // false
+0 != false;           // false
+0 != null;            // true
+0 != undefined;       // true
+0 != !!null;          // false, voir la documentation pour !!
+0 != !!undefined;     // false, voir la documentation pour !!
+null != undefined;    // false
+
+const number1 = new Number(3);
+const number2 = new Number(3);
+number1 != 3;         // false
+number1 != number2;   // true
+</pre>
+
+<h3 id="comparison_of_objects">Comparaison d'objets</h3>
+
+<pre class="brush: js">
+const objet1 = {"clé": "valeur"}
+const objet2 = {"clé": "valeur"};
+
+objet1 != objet2 // true
+objet2 != objet2 // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de <strong>décalage binaire à gauche (<code>&lt;&lt;</code>)</strong> 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-left-shift.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> &lt;&lt; <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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.</p>
+
+<p>Ainsi, <code>9 &lt;&lt; 2</code> donnera la valeur 36 (en base 10) :</p>
+
+<pre class="brush: js">
+       9 (base 10): 00000000000000000000000000001001 (base 2)
+                    --------------------------------
+  9 &lt;&lt; 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
+</pre>
+
+<p>Le décalage binaire de tout nombre <code>x</code> de <code>y</code> bits vers la gauche donnera comme résultat <code>x * 2 ** y</code>. Par exemple, <code>9 &lt;&lt; 3</code> pourra être reformulé en <code>9 * (2 ** 3) = 9 * (8) = 72</code>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_left_shift">Utiliser le décalage binaire à gauche</h3>
+
+<pre class="brush: js">
+9 &lt;&lt; 3; // 72
+
+// 9 * (2 ** 3) = 9 * (8) = 72
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift_assignment">L'opérateur de décalage binaire à gauche et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de décalage à gauche et d'affectation (<code>&lt;&lt;=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-left-shift-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x &lt;&lt;= y
+<strong>Signification :</strong>  x   = x &lt;&lt; y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_left_shift_assignment">Utiliser l'opérateur de décalage à gauche et d'affectation</h3>
+
+<pre class="brush: js">
+let a = 5;
+// 00000000000000000000000000000101
+
+a &lt;&lt;= 2; // 20
+// 00000000000000000000000000010100
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift">L'opérateur de décalage à gauche binaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur inférieur strict (<code>&lt;</code>) renvoie <code>true</code> si son opérande gauche est strictement inférieur à son opérande droit et <code>false</code> sinon.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-less-than.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x &lt; y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a> résumé comme suit :</p>
+
+<ul>
+ <li>Tout d'abord, les objets sont convertis en valeurs primitives avec <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive">Symbol.ToPrimitive</a></code> en utilisant le paramètre <code>hint</code> avec la valeur <code>'number'</code>.</li>
+ <li>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.</li>
+ <li>Sinon, le moteur JavaScript tente de convertir les valeurs primitives non-numériques en valeurs numériques :
+  <ul>
+   <li>Les valeurs booléennes <code>true</code> et <code>false</code> sont respectivement converties en 1 et 0.</li>
+   <li><code>null</code> est converti en 0.</li>
+   <li><code>undefined</code> est converti en <code>NaN</code>.</li>
+   <li>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 <code>NaN</code>.</li>
+  </ul>
+ </li>
+ <li>Si l'une des valeurs vaut <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a></code>, l'opérateur renverra <code>false</code>.</li>
+ <li>Sinon, les valeurs sont comparées numériquement.</li>
+</ul>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="number_to_number_comparison">Comparaison numérique</h3>
+
+<pre class="brush: js">
+console.log(5 &lt; 3);            // false
+console.log(3 &lt; 3);            // false
+console.log(3 &lt; 5);            // true
+</pre>
+
+<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3>
+
+<pre class="brush: js">
+console.log(5n &lt; 3);           // false
+console.log(3 &lt; 5n);           // true
+</pre>
+
+<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("a" &lt; "b");        // true
+console.log("a" &lt; "a");        // false
+console.log("a" &lt; "3");        // false
+</pre>
+
+<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("5" &lt; 3);          // false
+console.log("3" &lt; 3);          // false
+console.log("3" &lt; 5);          // true
+
+console.log("coucou" &lt; 5);      // false
+console.log(5 &lt; "coucou");      // false
+
+console.log("5" &lt; 3n);         // false
+console.log("3" &lt; 5n);         // true
+</pre>
+
+<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3>
+
+<pre class="brush: js">
+console.log(true &lt; false);     // false
+console.log(false &lt; true);     // true
+
+console.log(0 &lt; true);         // true
+console.log(true &lt; 1);         // false
+
+console.log(null &lt; 0);         // false
+console.log(null &lt; 1);         // true
+
+console.log(undefined &lt; 3);    // false
+console.log(3 &lt; undefined);    // false
+
+console.log(3 &lt; NaN);          // false
+console.log(NaN &lt; 3);          // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur inférieur ou égal (<code>&lt;=</code>) renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à l'opérande droit et <code>false</code> sinon.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-less-than-or-equal.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x &lt;= y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="number_to_number_comparison">Comparaison numérique</h3>
+
+<pre class="brush: js">
+console.log(5 &lt;= 3);         // false
+console.log(3 &lt;= 3);         // true
+console.log(3 &lt;= 5);         // true
+</pre>
+
+<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3>
+
+<pre class="brush: js">
+console.log(5n &lt;= 3);        // false
+console.log(3 &lt;= 3n);        // true
+console.log(3 &lt;= 5n);        // true
+</pre>
+
+<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("a" &lt;= "b");     // true
+console.log("a" &lt;= "a");     // true
+console.log("a" &lt;= "3");     // false
+</pre>
+
+<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3>
+
+<pre class="brush: js">
+console.log("5" &lt;= 3);       // false
+console.log("3" &lt;= 3);       // true
+console.log("3" &lt;= 5);       // true
+
+console.log("coucou" &lt;= 5);   // false
+console.log(5 &lt;= "coucou");   // false
+</pre>
+
+<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3>
+
+<pre class="brush: js">
+console.log(true &lt;= false);  // false
+console.log(true &lt;= true);   // true
+console.log(false &lt;= true);  // true
+
+console.log(true &lt;= 0);      // false
+console.log(true &lt;= 1);      // true
+
+console.log(null &lt;= 0);      // true
+console.log(1 &lt;= null);      // false
+
+console.log(undefined &lt;= 3); // false
+console.log(3 &lt;= undefined); // false
+
+console.log(3 &lt;= NaN);       // false
+console.log(NaN &lt;= 3);       // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur ET logique (<code>&amp;&amp;</code>) (conjonction logique) renvoie vrai si et uniquement si ses deux opérandes sont <code>true</code> ou équivalents à <code>true</code>. 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 <code>&amp;&amp;</code> 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-and.html", "shorter")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>expr1</var> &amp;&amp; <var>expr2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Si <code>expr1</code> peut être converti en <code>true</code>, le résultat sera <code>expr2</code> ; sinon, ce sera <code>expr1</code>.
+</p>
+
+<p>Si une valeur peut être convertie en <code>true</code>, elle peut être qualifiée de <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. Si une valeur peut être convertie en <code>false</code>, on la qualifiera alors de <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p>
+
+<p>Parmi les expressions qui peuvent être converties en <code>false</code>, on a :</p>
+
+<ul>
+  <li><code>null</code> ;</li>
+  <li><code>NaN</code> ;</li>
+  <li><code>0</code> ;</li>
+  <li>la chaîne de caractères vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li>
+  <li><code>undefined</code>.</li>
+</ul>
+
+<p>Bien que l'opérateur <code>&amp;&amp;</code> 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 <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">une valeur primitive booléenne</a>. 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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT">opérateur NON (<code>!</code>)</a> ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean"><code>Boolean()</code></a>.</p>
+
+<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3>
+
+<p>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 :</p>
+
+<p><code>(une expression équivalente à faux) &amp;&amp; <var>expr</var></code> sera court-circuité pour fournir directement le résultat de l'expression équivalente à faux.</p>
+
+<p>Cette notion de court-circuit indique que la partie <code><var>expr</var></code> ci-avant <strong>n'est pas évaluée</strong>, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si <code><var>expr</var></code> 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 :</p>
+
+<pre class="brush: js">
+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() &amp;&amp; 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
+</pre>
+
+<h3 id="operator_precedence">Précédence des opérateurs</h3>
+
+<p>Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur <code>&amp;&amp;</code> est exécuté avant l'opérateur <code>||</code> (voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">l'article sur la précédence des opérateurs</a>).</p>
+
+<pre class="brush: js">
+true || false &amp;&amp; false      // renvoie true, car &amp;&amp; est exécuté en premier
+(true || false) &amp;&amp; false    // renvoie false, car la précédence par défaut ne s'applique pas
+                                    // avec les parenthèses
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_AND">Utiliser le ET logique</h3>
+
+<p>Le code suivant illustre quelques usages de l'opérateur ET logique <code>&amp;&amp;</code>.</p>
+
+<pre class="brush: js">
+a1 = true   &amp;&amp; true       // t &amp;&amp; t renvoie true
+a2 = true   &amp;&amp; false      // t &amp;&amp; f renvoie false
+a3 = false  &amp;&amp; true       // f &amp;&amp; t renvoie false
+a4 = false  &amp;&amp; (3 == 4)   // f &amp;&amp; f renvoie false
+a5 = 'Chat' &amp;&amp; 'Chien'    // t &amp;&amp; t renvoie "Chien"
+a6 = false  &amp;&amp; 'Chat'     // f &amp;&amp; t renvoie false
+a7 = 'Chat' &amp;&amp; false      // t &amp;&amp; f renvoie false
+a8 = ''     &amp;&amp; false      // f &amp;&amp; f renvoie ""
+a9 = false  &amp;&amp; ''         // f &amp;&amp; f renvoie false
+</pre>
+
+<h3 id="conversion_rules_for_booleans">Règles de conversion booléennes</h3>
+
+<h4 id="converting_and_to_or">Convertir ET en OU</h4>
+
+<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">
+bCondition1 &amp;&amp; bCondition2
+</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre class="brush: js">
+!(!bCondition1 || !bCondition2)
+</pre>
+
+<h4 id="converting_or_to_and">Convertir OU en ET</h4>
+
+<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">
+bCondition1 || bCondition2
+</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre class="brush: js">
+!(!bCondition1 &amp;&amp; !bCondition2)
+</pre>
+
+<h3 id="removing_nested_parentheses">Retrait des parenthèses imbriquées</h3>
+
+<p>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.</p>
+
+<p>L'opération composite suivant, qui utilise des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">
+bCondition1 || (bCondition2 &amp;&amp; bCondition3)
+</pre>
+
+<p>sera toujours égale à :</p>
+
+<pre class="brush: js">
+bCondition1 || bCondition2 &amp;&amp; bCondition3
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li>
+  <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li>
+  <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après ET logique (<code>x &amp;&amp;= y</code>) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est <a href="/fr/docs/Glossary/Truthy">équivalent à vrai (<i>truthy</i>)</a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-and-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>expr1</var> &amp;&amp;= <var>expr2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3>
+
+<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND">ET logique</a> est évalué de gauche à droite et le moteur vérifie s'il peut utiliser un court-circuit avec la régle suivante :</p>
+
+<p><code>(une expression équivalente à faux) &amp;&amp; expr</code> sera court-circuitée pour fournir directement l'expression équivalente à faux.</p>
+
+<p>Ce « court-circuit » indique que <code><var>expr</var></code> <strong>n'est pas évaluée</strong>. Tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple si <code><var>expr</var></code> est un appel de fonction, la fonction n'est pas exécutée).</p>
+
+<p>L'opérateur d'affectation après ET logique utilise également ce court-circuit et <code>x &amp;&amp;= y</code> est donc équivalent à :</p>
+
+<pre class="brush: js">
+x &amp;&amp; (x = y);
+</pre>
+
+<p>En revanche, <strong>il n'est pas équivalent</strong> à ce qui suit, et qui effectue quoi qu'il arrive une affectation :</p>
+
+<pre class="brush: js example-bad">
+x = x &amp;&amp; y;
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_logical_and_assignment">Utiliser l'affectation après ET logique</h3>
+
+<pre class="brush: js">
+let x = 0;
+let y = 1;
+
+x &amp;&amp;= 0; // 0
+x &amp;&amp;= 1; // 0
+y &amp;&amp;= 1; // 1
+y &amp;&amp;= 0; // 0
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND">L'opérateur ET logique (&amp;&amp;)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur d'affectation après ET binaire (<code>&amp;=</code>)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Le type <code>Boolean</code></a>
+  <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li>
+  <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur logique NON (<code>!</code>) 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 <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">booléens</a>. Lorsque cet opérateur est utilisé avec une valeur non-booléenne, il renvoie <code>false</code> si son opérande peut être converti en <code>true</code> et <code>true</code> sinon.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-not.html", "shorter")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+!<var>expr</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Cet opérateur renvoie <code>false</code> si son opérande peut être converti en <code>true</code> ; sinon il renvoie <code>true</code>.</p>
+
+<p>Si une valeur peut être convertie en <code>true</code>, on dira en anglais qu'elle est <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. À l'inverse, si elle peut être convertie en <code>false</code>, on dira en anglais qu'elle est <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p>
+
+<p>Voici des exemples d'expression qui peuvent être converties en <code>false</code> :</p>
+
+<ul>
+  <li><code>null</code> ;</li>
+  <li><code>NaN</code> ;</li>
+  <li><code>0</code> ;</li>
+  <li>la chaîne vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li>
+  <li><code>undefined</code>.</li>
+</ul>
+
+<p>Bien que l'opérateur <code>!</code> puisse être utilisé avec des opérandes non booléens, sa valeur de retour sera toujours un <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">booléen</a>. Pour convertir une valeur (ou une expression) en sa valeur booléenne correspondante, on pourra utiliser un double NON ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_NOT">Utiliser NON</h3>
+
+<p>Le code suivant illustre l'utilisation de l'opérateur <code>!</code> pour le NON logique.</p>
+
+<pre class="brush: js">
+let n1 = !true     // !t renvoie false
+let n2 = !false    // !f renvoie true
+let n3 = !''       // !f renvoie true
+let n4 = !'Cat'    // !t renvoie false
+</pre>
+
+<h3 id="Double_NOT_!!">Double NON (<code>!!</code>)</h3>
+
+<p>Il est possible d'utiliser deux opérateurs NON à la suite pour convertir n'importe quelle valeur en booléen selon qu'elle est <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a> ou <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p>
+
+<p>Une conversion équivalente pourra être obtenue avec le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>.</p>
+
+<pre class="brush: js">
+let n1 = !!true                   // !!truthy renvoie true
+let n2 = !!{}                     // !!truthy renvoie true : <strong>tout</strong> 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
+</pre>
+
+<h3 id="Converting_between_NOTs">Équivalence booléenne de la double négation</h3>
+
+<p>L'expression qui suit, utilisée avec des booléens :</p>
+
+<pre class="brush: js">!!bCondition</pre>
+
+<p>est toujours égale à :</p>
+
+<pre class="brush: js">bCondition</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li>{{jsxref("Boolean")}}</li>
+  <li>{{Glossary("Truthy")}}</li>
+  <li>{{Glossary("Falsy")}}</li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après coalescence des nuls (<code>x ??= y</code>) effectue une affectation uniquement si l'opérande de gauche (<code>x</code>) vaut <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>undefined</code></a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-nullish-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>expr1</var> ??= <var>expr2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3>
+
+<p>L'opérateur de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">coalescence des nuls</a> est évalué de gauche à droite et le moteur teste s'il est possible d'utiliser un court-circuit grâce à la règle suivante :</p>
+
+<p><code>(une expression qui renvoie null ou undefined) ?? expr</code> sera court-circuité pour fournir l'opérande gauche si celle-ci ne vaut ni <code>null</code> ni <code>undefined</code>.</p>
+
+<p>Ce « court-circuit » implique que l'expression <code><var>expr</var></code> <strong>n'est pas évaluée</strong> si ce n'est pas nécessaire. Ainsi, tout effet de bord lié à celle-ci n'aura pas lieu (par exemple, si <code><var>expr</var></code> appelle une fonction, cette dernière n'est pas exécutée).</p>
+
+<p>L'opérateur d'affectation après coalescence des nuls obéit également à cette logique. Ainsi, <code>x ??= y</code> sera équivalent à :</p>
+
+<pre class="brush: js">
+x ?? (x = y);
+</pre>
+
+<p>En revanche, ce ne sera pas équivalent à l'expression suivante qui effectue une affectation quoi qu'il arrive :</p>
+
+<pre class="brush: js example-bad">
+x = x ?? y;
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_logical_nullish_assignment">Utiliser l'opérateur d'affectation après coalescence des nuls</h3>
+
+<pre class="brush: js">
+function config(options) {
+  options.duration ??= 100;
+  options.speed ??= 25;
+  return options;
+}
+
+config({ duration: 125 }); // { duration: 125, speed: 25 }
+config({}); // { duration: 100, speed: 25 }
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li>
+  <li><a href="/fr/docs/Glossary/Nullish"><i>Nullish</i></a></li>
+  <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li>
+  <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur OU logique (<code>||</code>) (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, <code>||</code> peut aussi être utilisé avec des valeurs non-booléennes et, dans ce cas, renverra une valeur non-booléenne.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-or.html", "shorter")}}</div>
+
+<h2 id="syntax">Syntax</h2>
+
+<pre class="brush: js">
+<var>expr1</var> || <var>expr2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Si <code>expr1</code> peut être converti en <code>true</code>, c'est <code>expr1</code> qui sera renvoyé, sinon ce sera <code>expr2</code>.</p>
+
+<p>Si une valeur peut être convertie en <code>true</code>, elle peut être qualifiée de <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. Si une valeur peut être convertie en <code>false</code>, on la qualifiera alors de <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p>
+
+<p>Parmi les expressions qui peuvent être converties en <code>false</code>, on a :</p>
+
+<ul>
+  <li><code>null</code> ;</li>
+  <li><code>NaN</code> ;</li>
+  <li><code>0</code> ;</li>
+  <li>la chaîne de caractères vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li>
+  <li><code>undefined</code>.</li>
+</ul>
+
+<p>Bien que l'opérateur <code>||</code> 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 <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">une valeur primitive booléenne</a>. 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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT">opérateur NON (<code>!</code>)</a> ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean"><code>Boolean()</code></a>.</p>
+
+<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3>
+
+<p>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 :</p>
+
+<p><code>(une expression équivalente à vrai) &amp;&amp; <var>expr</var></code> sera court-circuité pour fournir directement le résultat de l'expression équivalente à vrai.</p>
+
+<p>Cette notion de court-circuit indique que la partie <code><var>expr</var></code> ci-avant <strong>n'est pas évaluée</strong>, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si <code><var>expr</var></code> 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 :</p>
+
+<pre class="brush: js">
+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
+</pre>
+
+<h3 id="operator_precedence">Précédence des opérateurs</h3>
+
+<p>Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur <code>&amp;&amp;</code> est exécuté avant l'opérateur <code>||</code> (voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">l'article sur la précédence des opérateurs</a>).</p>
+
+<pre class="brush: js">
+true || false &amp;&amp; false      // renvoie true, car &amp;&amp; est exécuté en premier
+(true || false) &amp;&amp; false    // renvoie false, car la précédence par défaut ne s'applique pas
+                                    // avec les parenthèses
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_or">Utiliser le OU logique</h3>
+
+<p>Le code suivant illustre quelques usages de l'opérateur OU logique <code>||</code>.</p>
+
+<pre class="brush: js">
+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
+</pre>
+
+<div class="notecard note">
+  <p><strong>Note :</strong> Si vous utilisez cet opérateur afin de fournir une valeur par défaut à une variable. Soyez conscient⋅e qu'une valeur équivalente à <code>false</code> ne pourra pas être utilisée ainsi. Si vous souhaitez uniquement écarter <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>, privilégiez l'utilisation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">l'opérateur de coalescence des nuls</a>.</p>
+</div>
+
+<h3 id="conversion_rules_for_booleans">Règles de conversion booléennes</h3>
+
+<h4 id="converting_and_to_or">Convertir ET en OU</h4>
+
+<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre class="brush: js">
+!(!bCondition1 || !bCondition2)
+</pre>
+
+<h4 id="converting_or_to_and">Convertir OU en ET</h4>
+
+<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">bCondition1 || bCondition2</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre class="brush: js">
+!(!bCondition1 &amp;&amp; !bCondition2)
+</pre>
+
+<h3 id="removing_nested_parentheses">Retrait des parenthèses imbriquées</h3>
+
+<p>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.</p>
+
+<p>L'opération composite suivante, utilisant des <strong>booléens</strong> :</p>
+
+<pre class="brush: js">
+bCondition1 &amp;&amp; (bCondition2 || bCondition3)
+</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre class="brush: js">
+!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li>
+  <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li>
+  <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après OU logique (<code>x ||= y</code>) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est <a href="/fr/docs/Glossary/Falsy">équivalent à faux (<i>falsy</i>)</a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logical-or-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>expr1</var> ||= <var>expr2</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3>
+
+<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR">OU logique</a> fonctionne ainsi :</p>
+
+<pre class="brush: js">
+x || y;
+// renvoie x lorsque x est équivalent à vrai
+// renvoie y lorsque x n'est pas équivalent à vrai
+</pre>
+
+<p>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.</p>
+
+<p>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, <code>x ||= y</code> est équivalent à :</p>
+
+<pre class="brush: js">
+x || (x = y);
+</pre>
+
+<p>En revanche, il n'est pas équivalent à l'expression suivante qui effectue, quoi qu'il arrive, une affectation :</p>
+
+<pre class="brush: js example-bad">
+x = x || y;
+</pre>
+
+<p>On notera que ce comportement est différent entre les opérateurs binaires et les opérateurs logiques.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="setting_default_content">Affecter une valeur par défaut</h3>
+
+<p>Dans l'exemple qui suit, si <code>paroles</code> est vide, on y place une valeur par défaut :</p>
+
+<pre class="brush: js">
+document.getElementById('paroles').textContent ||= 'Aucune parole.'
+</pre>
+
+<p>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.</p>
+
+<p>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 <code>||=</code>. Sinon, si on souhaite uniquement distinguer <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>undefined</code></a>, on utilisera l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator"><code>??=</code></a>.</p>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR">L'opérateur OU logique (||)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR_assignment">L'opérateur d'affectation après OU binaire (<code>|=</code>)</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Le type <code>Boolean</code></a>
+  <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li>
+  <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de multiplication (<code>*</code>) fournit le produit de la multiplication des deux opérandes.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-multiplication.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var> * <var>y</var>
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="multiplication_using_numbers">Avec des nombres</h3>
+
+<pre class="brush: js"> 2 * 2      // 4
+-2 * 2     // -4
+</pre>
+
+<h3 id="multiplication_with_infinity">Avec l'infini</h3>
+
+<pre class="brush: js">
+Infinity * 0         // NaN
+Infinity * Infinity  // Infinity
+</pre>
+
+<h3 id="multiplication_with_non-numbers">Avec des valeurs non-numériques</h3>
+
+<pre class="brush: js">
+'foo' * 2 // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de multiplication et d'affectation (<code>*=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-multiplication-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x *= y
+<strong>Signification :</strong>  x  = x * y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_multiplication_assignment">Utiliser l'opérateur de multiplication et d'affectation</h3>
+
+<pre class="brush: js">
+let truc = 5;
+truc *= 2;      // 10
+truc *= 'toto'; // NaN</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">L'opérateur de multiplication</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur du reste (<code>%</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-remainder.html")}}</div>
+
+<p>Bien que dans la plupart des langages, <code>%</code> est un opérateur de reste, pour d'autres (par exemple <a href="https://en.wikipedia.org/wiki/Modulo_operation#In_programming_languages">Python, Perl</a>) 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 <code>((a % n ) + n ) % n</code>.</p>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>var1</var> % <var>var2</var>
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="remainder_with_positive_dividend">Reste avec numérateur positif</h3>
+
+<pre class="brush: js">
+12 % 5  //  2
+ 1 % -2 //  1
+ 1 % 2  //  1
+ 2 % 3  //  2
+5.5 % 2 // 1.5
+</pre>
+
+<h3 id="remainder_with_negative_dividend">Reste avec numérateur négatif</h3>
+
+<pre class="brush: js">
+-12 % 5 // -2
+-1 % 2  // -1
+-4 % 2  // -0
+</pre>
+
+<h3 id="remainder_with_nan">Reste avec NaN</h3>
+
+<pre class="brush: js">
+NaN % 2 // NaN
+</pre>
+
+<h3 id="remainder_with_infinity">Reste avec l'infini</h3>
+
+<pre class="brush: js">
+Infinity % 2 // NaN
+Infinity % 0 // NaN
+Infinity % Infinity // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de reste et d'affectation (<code>%=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-remainder-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x %= y
+<strong>Signification :</strong>  x  = x % y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_remainder_assignment">Utiliser l'opérateur de reste et d'affectation</h3>
+
+<pre class="brush: js">
+let truc = 5;
+truc %= 2;      // 1
+truc %= 'toto'; // NaN
+truc %= 0;      // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">L'opérateur de reste</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de <strong>décalage binaire à droite (<code>&gt;&gt;</code>)</strong> 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-right-shift.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> &gt;&gt; <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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.</p>
+
+<p>Ainsi, <code>9 &gt;&gt; 2</code> donnera <code>2</code> :</p>
+
+<pre class="brush: js">
+       9 (base 10): 00000000000000000000000000001001 (base 2)
+                    --------------------------------
+  9 &gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>De même, <code>-9 &gt;&gt; 2</code> donnera <code>-3</code>, car le signe est préservé :</p>
+
+<pre class="brush: js">
+       -9 (base 10): 11111111111111111111111111110111 (base 2)
+                     --------------------------------
+  -9 &gt;&gt; 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_right_shift">Utiliser le décalage à droite</h3>
+
+<pre class="brush: js">
+ 9 &gt;&gt; 2; //  2
+-9 &gt;&gt; 2; // -3
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift_assignment">L'opérateur de décalage binaire à droite et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de décalage à droite et d'affectation (<code>&gt;&gt;=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-right-shift-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x &gt;&gt;= y
+<strong>Signification :</strong>  x   = x &gt;&gt; y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_right_shift_assignment">Utiliser l'opérateur de décalage à droite et d'affectation</h3>
+
+<pre class="brush: js">
+let a = 5; //   (00000000000000000000000000000101)
+a &gt;&gt;= 2;   // 1 (00000000000000000000000000000001)
+
+let b = -5; //  (-00000000000000000000000000000101)
+b &gt;&gt;= 2;  // -2 (-00000000000000000000000000000010)
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift">L'opérateur de décalage à droite</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'égalité stricte (<code>===</code>) vérifie si ses deux opérandes sont égaux et renvoie un booléen correspondant au résultat. À la différence de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a>, l'opérateur d'égalité stricte considère toujours des opérandes de types différents comme étant différents.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-strict-equality.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x === y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Les opérateurs d'égalité stricte (<code>===</code> et <code>!==</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">l'algorithme de comparaison d'égalité stricte</a> pour comparer deux opérandes.</p>
+
+<ul>
+  <li>Si les opérandes sont de types différents, on renvoie <code>false</code>.</li>
+  <li>Si les deux opérandes sont des objets, on renvoie <code>true</code> uniquement s'ils réfèrent au même objet.</li>
+  <li>Si les deux opérandes valent <code>null</code> ou si les deux opérandes valent <code>undefined</code>, on renvoie <code>true</code>.</li>
+  <li>Si au moins l'un des opérandes vaut <code>NaN</code>, on renvoie <code>false</code>.</li>
+  <li>Sinon, on compare la valeur des deux opérandes :
+    <ul>
+      <li>Les nombres doivent avoir la même valeur. <code>+0</code> and <code>-0</code> sont considérés comme égaux.</li>
+      <li>Les chaînes de caractères doivent avoir les mêmes caractères, dans le même ordre.</li>
+      <li>Les booléens doivent avoir la même valeur (tous les deux <code>true</code> ou tous les deux <code>false</code>).</li>
+    </ul>
+  </li>
+</ul>
+
+<p>La différence fondamentale avec <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a> (<code>==</code>) est que, lorsque les opérandes sont de types différents, <code>==</code> tentera une conversion vers un type commun avant la comparaison.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="comparing_operands_of_the_same_type">Comparaison d'opérandes de même type</h3>
+
+<pre class="brush: js">
+console.log("hello" === "hello");   // true
+console.log("hello" === "hola");    // false
+
+console.log(3 === 3);               // true
+console.log(3 === 4);               // false
+
+console.log(true === true);         // true
+console.log(true === false);        // false
+
+console.log(null === null);         // true
+</pre>
+
+<h3 id="comparing_operands_of_different_types">Comparaison d'opérandes de types différents</h3>
+
+<pre class="brush: js">
+console.log("3" === 3);           // false
+
+console.log(true === 1);          // false
+
+console.log(null === undefined);  // false
+</pre>
+
+<h3 id="comparing_objects">Comparaison d'objets</h3>
+
+<pre class="brush: js">
+const objet1 = {
+  name: "coucou"
+}
+
+const objet2 = {
+  name: "coucou"
+}
+
+console.log(objet1 === objet2);  // false
+console.log(objet1 === objet1);  // true
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'inégalité stricte (<code>!==</code>) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">l'opérateur d'inégalité</a>, l'opérateur d'inégalité stricte considère toujours des opérandes de types différents comme étant différents.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-strict-inequality.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+x !== y
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">l'opérateur d'égalité stricte</a>. Les deux expressions suivantes fourniront toujours le même résultat :</p>
+
+<pre class="brush: js">
+x !== y
+!(x === y)
+</pre>
+
+<p>Pour plus de détails sur l'algorithme de comparaison utilisé, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">la page sur l'opérateur d'égalité stricte</a>.</p>
+
+<p>À 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 :</p>
+
+<pre class="brush: js">
+3 !== "3"; // true
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="comparing_operands_of_the_same_type">Comparaison d'opérandes de même type</h3>
+
+<pre class="brush: js">
+console.log("hello" !== "hello");   // false
+console.log("hello" !== "hola");    // true
+
+console.log(3 !== 3);               // false
+console.log(3 !== 4);               // true
+
+console.log(true !== true);         // false
+console.log(true !== false);        // true
+
+console.log(null !== null);         // false
+</pre>
+
+<h3 id="comparing_operands_of_different_types">Comparaison d'opérandes de types différents</h3>
+
+<pre class="brush: js">
+console.log("3" !== 3);           // true
+
+console.log(true !== 1);          // true
+
+console.log(null !== undefined);  // true
+</pre>
+
+<h3 id="comparing_objects">Comparaison d'objets</h3>
+
+<pre class="brush: js">
+const objet1 = {
+  name: "coucou"
+}
+
+const objet2 = {
+  name: "coucou"
+}
+
+console.log(objet1 !== objet2);  // true
+console.log(objet1 !== objet1);  // false
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de soustraction (<code>-</code>) effectue la soustraction entre les deux opérandes et fournit la différence obtenue.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-subtraction.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> <var>x</var> - <var>y</var>
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="subtraction_with_numbers">Avec des valeurs numériques</h3>
+
+<pre class="brush: js">
+5 - 3     // 2
+3 - 5     // -2
+</pre>
+
+<h3 id="subtraction_with_non-numbers">Avec des valeurs non-numériques</h3>
+
+<pre class="brush: js">
+'toto' - 3 // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur d'affectation après soustraction (<code>-=</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-subtraction-assignment.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x -= y
+<strong>Signification :</strong>  x  = x - y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_subtraction_assignment">Utiliser l'opérateur de soustraction et d'affectation</h3>
+
+<pre class="brush: js">
+let truc = 5;
+truc -= 2;      // 3
+truc -= 'toto'; // NaN
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">L'opérateur de soustraction</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de négation unaire (<code>-</code>) se place devant son opérande et le transforme en son opposé.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-unary-negation.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> -<var>x</var>
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="negating_numbers">Avec des nombres</h3>
+
+<pre class="brush: js">const x = 3;
+const y = -x;
+
+// y = -3
+// x = 3
+</pre>
+
+<h3 id="negating_non-numbers">Avec des valeurs non-numériques</h3>
+
+<p>L'opérateur de négation unaire peut être utilisé pour convertir une valeur non-numérique en nombre.</p>
+
+<pre class="brush: js">const x = "4";
+const y = -x;
+
+// y = -4
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de plus unaire (<code>+</code>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-unary-plus.html", "taller")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> +<var>x</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>Bien que la négation unaire (<code>-</code>) 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 <code>true</code>, <code>false</code>, et <code>null</code>. 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 <code>BigInt</code> déclenchera une exception <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError"><code>TypeError</code></a>. Si l'analyse de valeur ne permet pas de déduire une valeur numérique, le résultat sera <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a>.</p>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="usage_with_numbers">Avec des nombres</h3>
+
+<pre class="brush: js">const x = 1;
+const y = -1;
+
+console.log(+x);
+// 1
+console.log(+y);
+// -1</pre>
+
+<h3 id="usage_with_non-numbers">Avec des valeurs non-numériques</h3>
+
+<pre class="brush: js">+true  // 1
++false // 0
++null  // 0
++function(val){ return val } // NaN
++1n    // throws TypeError: Cannot convert BigInt value to number
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de <strong>décalage binaire à droite non-signé (<code>&gt;&gt;&gt;</code>)</strong> 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 <code>0</code> 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift.html")}}</div>
+
+<h2 id="syntax">Syntaxe</h2>
+
+<pre class="brush: js">
+<var>a</var> &gt;&gt;&gt; <var>b</var>
+</pre>
+
+<h2 id="description">Description</h2>
+
+<p>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 <code>0</code> 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.</p>
+
+<p>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, <code>9 &gt;&gt;&gt; 2</code> renvoie 2, également renvoyé par <code>9 &gt;&gt; 2</code>:</p>
+
+<pre class="brush: js">
+        9 (base 10): 00000000000000000000000000001001 (base 2)
+                     --------------------------------
+  9 &gt;&gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>Toutefois, ce n'est pas le cas pour les nombres négatifs : <code>-9 &gt;&gt;&gt; 2</code> renverra 1073741821, qui est différent de  <code>-9 &gt;&gt; 2</code> (qui renvoie <code>-3</code>) :</p>
+
+<pre class="brush: js">
+        -9 (base 10): 11111111111111111111111111110111 (base 2)
+                      --------------------------------
+  -9 &gt;&gt;&gt; 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_unsigned_right_shift">Utiliser le décalage à droite non-signé</h3>
+
+<pre class="brush: js">
+ 9 &gt;&gt;&gt; 2; // 2
+-9 &gt;&gt;&gt; 2; // 1073741821
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment">L'opérateur de décalage binaire à droite non-signé et d'affectation</a></li>
+</ul>
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
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>L'opérateur de décalage à droite non signé et d'affectation (<em><code>&gt;&gt;&gt;=</code></em>) 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.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift-assignment.html")}}</div>
+
+<h2 id="syntax">Syntax</h2>
+
+<pre class="brush: js">
+<strong>Opérateur :</strong> x &gt;&gt;&gt;= y
+<strong>Signification :</strong>  x    = x &gt;&gt;&gt; y
+</pre>
+
+<h2 id="examples">Exemples</h2>
+
+<h3 id="using_unsigned_right_shift_assignment">Utiliser l'opérateur de décalage à droite non signé et d'affectation</h3>
+
+<pre class="brush: js">
+let a = 5; //   (00000000000000000000000000000101)
+a &gt;&gt;&gt;= 2;  // 1 (00000000000000000000000000000001)
+
+let b = -5; // (-00000000000000000000000000000101)
+b &gt;&gt;&gt;= 2;   // 1073741822 (00111111111111111111111111111110)
+</pre>
+
+<h2 id="specifications">Spécifications</h2>
+
+<p>{{Specifications}}</p>
+
+<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+
+<p>{{Compat}}</p>
+
+<h2 id="see_also">Voir aussi</h2>
+
+<ul>
+  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li>
+  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift">L'opérateur de décalage à droite</a></li>
+</ul>
author	SphinxKnight <SphinxKnight@users.noreply.github.com>	2021-06-27 15:03:56 +0200
committer	GitHub <noreply@github.com>	2021-06-27 15:03:56 +0200
commit	9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 (patch)
tree	e6aa6c44ea4c523dbf72464e77745bed1efc8c51 /files/fr/web/javascript/reference/operators
parent	dc9842009bd95e0db7e058a5ebb98f27d6a3f650 (diff)
download	translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.gz translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.bz2 translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.zip