From 9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 Mon Sep 17 00:00:00 2001 From: SphinxKnight Date: Sun, 27 Jun 2021 15:03:56 +0200 Subject: Fix #756 by updating the JS operators in fr (#1306) * Update Operators landing + revamp L10N for 4 operators * Added NOT / ! - * +multiplication * Addition, exponentiation and comparison * Operateurs de comparaison * Binary ops * Missing newline, thx GH UI * Logical AND / OR * Assignment ops * Conflicting clean-up * Missing EOF newline * Fix history and redirects * FIX: fix flaws * FIX: minox typo fix * FIX: link flaws * FIX: fix tags detection Co-authored-by: tristantheb --- files/fr/_redirects.txt | 48 +- files/fr/_wikihistory.json | 77 --- .../web/javascript/reference/operators/index.html | 297 ----------- .../index.html | 259 ---------- .../index.html | 30 -- .../index.html | 416 --------------- .../index.html | 556 --------------------- .../index.html | 258 ---------- .../reference/operators/addition/index.html | 72 ++- .../operators/addition_assignment/index.html | 85 ++-- .../reference/operators/bitwise_and/index.html | 102 ++++ .../operators/bitwise_and_assignment/index.html | 50 ++ .../reference/operators/bitwise_not/index.html | 90 ++++ .../reference/operators/bitwise_or/index.html | 104 ++++ .../operators/bitwise_or_assignment/index.html | 53 ++ .../reference/operators/bitwise_xor/index.html | 104 ++++ .../operators/bitwise_xor_assignment/index.html | 57 +++ .../reference/operators/decrement/index.html | 70 +++ .../reference/operators/division/index.html | 63 +++ .../operators/division_assignment/index.html | 51 ++ .../reference/operators/equality/index.html | 125 +++++ .../reference/operators/exponentiation/index.html | 95 ++++ .../operators/exponentiation_assignment/index.html | 49 ++ .../reference/operators/greater_than/index.html | 100 ++++ .../operators/greater_than_or_equal/index.html | 99 ++++ .../reference/operators/increment/index.html | 70 +++ .../web/javascript/reference/operators/index.html | 393 +++++++-------- .../reference/operators/inequality/index.html | 102 ++++ .../reference/operators/left_shift/index.html | 62 +++ .../operators/left_shift_assignment/index.html | 51 ++ .../reference/operators/less_than/index.html | 115 +++++ .../operators/less_than_or_equal/index.html | 99 ++++ .../reference/operators/logical_and/index.html | 157 ++++++ .../operators/logical_and_assignment/index.html | 78 +++ .../reference/operators/logical_not/index.html | 95 ++++ .../logical_nullish_assignment/index.html | 78 +++ .../reference/operators/logical_or/index.html | 158 ++++++ .../operators/logical_or_assignment/index.html | 84 ++++ .../reference/operators/multiplication/index.html | 65 +++ .../operators/multiplication_assignment/index.html | 48 ++ .../reference/operators/remainder/index.html | 80 +++ .../operators/remainder_assignment/index.html | 50 ++ .../reference/operators/right_shift/index.html | 67 +++ .../operators/right_shift_assignment/index.html | 51 ++ .../reference/operators/strict_equality/index.html | 100 ++++ .../operators/strict_inequality/index.html | 97 ++++ .../reference/operators/subtraction/index.html | 59 +++ .../operators/subtraction_assignment/index.html | 49 ++ .../reference/operators/unary_negation/index.html | 65 +++ .../reference/operators/unary_plus/index.html | 69 +++ .../operators/unsigned_right_shift/index.html | 66 +++ .../unsigned_right_shift_assignment/index.html | 51 ++ 52 files changed, 3567 insertions(+), 2202 deletions(-) delete mode 100644 files/fr/conflicting/web/javascript/reference/operators/index.html delete mode 100644 files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html delete mode 100644 files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html delete mode 100644 files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html delete mode 100644 files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html delete mode 100644 files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_and/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_not/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_or/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_xor/index.html create mode 100644 files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/decrement/index.html create mode 100644 files/fr/web/javascript/reference/operators/division/index.html create mode 100644 files/fr/web/javascript/reference/operators/division_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/equality/index.html create mode 100644 files/fr/web/javascript/reference/operators/exponentiation/index.html create mode 100644 files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/greater_than/index.html create mode 100644 files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html create mode 100644 files/fr/web/javascript/reference/operators/increment/index.html create mode 100644 files/fr/web/javascript/reference/operators/inequality/index.html create mode 100644 files/fr/web/javascript/reference/operators/left_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/left_shift_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/less_than/index.html create mode 100644 files/fr/web/javascript/reference/operators/less_than_or_equal/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_and/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_and_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_not/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_or/index.html create mode 100644 files/fr/web/javascript/reference/operators/logical_or_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/multiplication/index.html create mode 100644 files/fr/web/javascript/reference/operators/multiplication_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/remainder/index.html create mode 100644 files/fr/web/javascript/reference/operators/remainder_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/right_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/right_shift_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/strict_equality/index.html create mode 100644 files/fr/web/javascript/reference/operators/strict_inequality/index.html create mode 100644 files/fr/web/javascript/reference/operators/subtraction/index.html create mode 100644 files/fr/web/javascript/reference/operators/subtraction_assignment/index.html create mode 100644 files/fr/web/javascript/reference/operators/unary_negation/index.html create mode 100644 files/fr/web/javascript/reference/operators/unary_plus/index.html create mode 100644 files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html create mode 100644 files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html (limited to 'files') diff --git a/files/fr/_redirects.txt b/files/fr/_redirects.txt index 331ff1948f..f35a7dffaf 100644 --- a/files/fr/_redirects.txt +++ b/files/fr/_redirects.txt @@ -2541,13 +2541,13 @@ /fr/docs/JavaScript/Reference/Opérateurs/L_opérateur_typeof /fr/docs/Web/JavaScript/Reference/Operators/typeof /fr/docs/JavaScript/Reference/Opérateurs/L_opérateur_virgule /fr/docs/Web/JavaScript/Reference/Operators/Comma_Operator /fr/docs/JavaScript/Reference/Opérateurs/L_opérateur_void /fr/docs/Web/JavaScript/Reference/Operators/void -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_binaires /fr/docs/conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3 -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation /fr/docs/conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes /fr/docs/conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9 -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison /fr/docs/conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55 +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_binaires /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_de_membres /fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors -/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_logiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f +/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_logiques /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_spéciaux/L'opérateur_conditionnel /fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator /fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_spéciaux/L'opérateur_delete /fr/docs/Web/JavaScript/Reference/Operators/delete /fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_spéciaux/L'opérateur_function /fr/docs/Web/JavaScript/Reference/Operators/function @@ -2716,13 +2716,13 @@ /fr/docs/JavaScript/Reference/Référence_JavaScript/Objets_globaux/encodeURIComponent /fr/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent /fr/docs/JavaScript/Reference/Référence_JavaScript/Objets_globaux/eval /fr/docs/Web/JavaScript/Reference/Global_Objects/eval /fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs /fr/docs/Web/JavaScript/Reference/Operators -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_arithmétiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_binaires /fr/docs/conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3 -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_d'affectation /fr/docs/conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_de_chaînes /fr/docs/conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9 -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_de_comparaison /fr/docs/conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55 +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_arithmétiques /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_binaires /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_d'affectation /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_de_chaînes /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_de_comparaison /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_de_membres /fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors -/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_logiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f +/fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_logiques /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_conditionnel /fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator /fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_delete /fr/docs/Web/JavaScript/Reference/Operators/delete /fr/docs/JavaScript/Reference/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_function /fr/docs/Web/JavaScript/Reference/Operators/function @@ -2945,13 +2945,13 @@ /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Objets_globaux/encodeURIComponent /fr/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Objets_globaux/eval /fr/docs/Web/JavaScript/Reference/Global_Objects/eval /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs /fr/docs/Web/JavaScript/Reference/Operators -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_arithmétiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_binaires /fr/docs/conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3 -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_d'affectation /fr/docs/conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_de_chaînes /fr/docs/conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9 -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_de_comparaison /fr/docs/conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55 +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_arithmétiques /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_binaires /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_d'affectation /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_de_chaînes /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_de_comparaison /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_de_membres /fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors -/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_logiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f +/fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_logiques /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_conditionnel /fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_delete /fr/docs/Web/JavaScript/Reference/Operators/delete /fr/docs/JavaScript/Référence_JavaScript/Référence_JavaScript/Opérateurs/Opérateurs_spéciaux/L'opérateur_function /fr/docs/Web/JavaScript/Reference/Operators/function @@ -5585,13 +5585,13 @@ /fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_void /fr/docs/Web/JavaScript/Reference/Operators/void /fr/docs/Web/JavaScript/Reference/Opérateurs/Nullish_coalescing_operator /fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator /fr/docs/Web/JavaScript/Reference/Opérateurs/Optional_chaining /fr/docs/Web/JavaScript/Reference/Operators/Optional_chaining -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires /fr/docs/conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3 -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation /fr/docs/conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes /fr/docs/conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9 -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison /fr/docs/conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55 +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes /fr/docs/Web/JavaScript/Reference/Operators +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres /fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors -/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques /fr/docs/conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f +/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques /fr/docs/Web/JavaScript/Reference/Operators /fr/docs/Web/JavaScript/Reference/Opérateurs/Précédence_des_opérateurs /fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence /fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition /fr/docs/Web/JavaScript/Reference/Operators/Spread_syntax /fr/docs/Web/JavaScript/Reference/Opérateurs/Tube /fr/docs/orphaned/Web/JavaScript/Reference/Operators/Pipeline_operator diff --git a/files/fr/_wikihistory.json b/files/fr/_wikihistory.json index 7a7d37641d..4c0fb9e0bd 100644 --- a/files/fr/_wikihistory.json +++ b/files/fr/_wikihistory.json @@ -44471,83 +44471,6 @@ "matteodelabre" ] }, - "conflicting/Web/JavaScript/Reference/Operators": { - "modified": "2020-10-15T21:17:24.593Z", - "contributors": [ - "Valentin", - "SphinxKnight", - "PhilippePerret", - "alexisdelee", - "teoli", - "Jeremie", - "Mgjbot", - "BenoitL" - ] - }, - "conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55": { - "modified": "2020-10-15T21:18:03.910Z", - "contributors": [ - "Watilin", - "SphinxKnight", - "pierreferry", - "lionel-kahan", - "teoli", - "Jeremie", - "Kyodev", - "BenoitL" - ] - }, - "conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9": { - "modified": "2019-03-23T23:48:45.315Z", - "contributors": [ - "teoli", - "Jeremie", - "Mgjbot", - "BenoitL" - ] - }, - "conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b": { - "modified": "2020-10-15T21:18:11.144Z", - "contributors": [ - "SphinxKnight", - "wbamberg", - "Anquez", - "Behrouze", - "Goofy", - "teoli", - "Jeremie", - "BenoitL" - ] - }, - "conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3": { - "modified": "2020-10-15T21:18:05.662Z", - "contributors": [ - "SphinxKnight", - "pastr", - "mizhac", - "id-ismail", - "Sroucheray", - "bsitruk", - "thePivottt", - "titouandk", - "teoli", - "Jeremie", - "Kyodev", - "BenoitL" - ] - }, - "conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f": { - "modified": "2020-10-15T21:17:22.011Z", - "contributors": [ - "SphinxKnight", - "Darkilen", - "teoli", - "Jeremie", - "Mgjbot", - "Kyodev", - "BenoitL" - ] - }, "conflicting/Web/JavaScript/Reference/Statements/switch": { "modified": "2020-10-15T21:39:25.638Z", "contributors": [ diff --git a/files/fr/conflicting/web/javascript/reference/operators/index.html b/files/fr/conflicting/web/javascript/reference/operators/index.html deleted file mode 100644 index 6ceb1e781b..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators/index.html +++ /dev/null @@ -1,297 +0,0 @@ ---- -title: Opérateurs arithmétiques -slug: conflicting/Web/JavaScript/Reference/Operators -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques ---- -
{{jsSidebar("Operators")}}
- -

Les opérateurs arithmétiques utilisent des valeurs numériques (variables ou littéraux) comme opérandes et renvoient une valeur numérique. Les opérateurs arithmétiques standard sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).

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

Addition (+)

- -

L'opérateur d'addition permet d'obtenir la somme des opérandes numériques ou bien la concaténation de chaînes de caractères.

- -

Syntaxe

- -
Opérateur : x + y
- -

Exemples

- -
// nombre + nombre -> addition
-1 + 2 // 3
-
-// booléen + nombre -> addition
-true + 1 // 2
-
-// booléen + booléen -> addition
-false + false // 0
-
-// nombre + chaîne de caractères -> concaténation
-5 + "
-
- concaténation
-"toto" + false // "totofalse"
-
-// chaîne de caractères + chaîne de caractères -> concaténation
-"toto" + "truc" // "tototruc"
-
- -

Soustraction (-)

- -

L'opérateur de soustraction soustrait les deux opérandes pour obtenir leur différence.

- -

Syntaxe

- -
Opérateur : x - y
- -

Exemples

- -
5 - 3 // 2
-3 - 5 // -2
-"toto" - 3 // NaN
-
- -

Division (/)

- -

L'opérateur de division produit le quotient de ces opérandes avec l'opérande gauche comme numérateur et l'opérande droit comme dénominateur.

- -

Syntaxe

- -
Opérateur : x / y
- -

Exemples

- -
1 / 2      // renvoie 0.5 en JavaScript
-1 / 2      // renvoie 0 en Java
-// (aucun des deux opérandes n'est un nombre flottant de façon explicite)
-
-1.0 / 2.0  // renvoie 0.5 en JavaScript et Java
-
-2.0 / 0    // renvoie Infinity (pour l'infini) en JavaScript
-2.0 / 0.0  // renvoie Infinity également
-2.0 / -0.0 // renvoie -Infinity en JavaScript
- -

Multiplication (*)

- -

L'opérateur de multiplication permet d'obtenir le produit des opérandes.

- -

Syntaxe

- -
Opérateur : x * y
- -

Exemples

- -
2 * 2 // 4
--2 * 2 // -4
-Infinity * 0 // NaN
-Infinity * Infinity // Infinity
-"toto" * 2 // NaN
-
- -

Reste (%)

- -

L'opérateur « reste » renvoie le reste de la division du premier opérande par le second. Le résultat obtenu a toujours le signe du numérateur (la quantité divisée).

- -

Syntaxe

- -
Opérateur : var1 % var2
- -

Exemples

- -
12 % 5  // 2
--1 % 2  // -1
-1 % -2  // 1
-NaN % 2 // NaN
-1 % 2   // 1
-2 % 3   // 2
--4 % 2  // -0
-5.5 % 2 // 1.5
- -

Exponentiation (**)

- -

L'opérateur d'exponentiation (aussi appelé opérateur de puissance) renvoie le résultat de l'élévation d'un nombre (premier opérande) à une puissance donnée (deuxième opérande). Par exemple : var1 ** var2 sera équivalent à var1var2 en notation mathématique. Cet opérateur est associatif à droite, autrement dit a ** b ** c est égal à a ** (b ** c).

- -

Syntaxe

- -
Opérateur : var1 ** var2
- -

Notes

- -

Dans la plupart des langages (par exemple PHP, Python, etc.), l'opérateur d'exponentiation est défini avec une précédence supérieure à celle des opérateurs unaires tels que le plus unaire et le moins unaire. Des exceptions existent comme Bash où l'opérateur ** a une précédence inférieure à celle des opérateurs unaires. En JavaScript, il est impossible d'écrire une expression ambigüe avec l'exponentiation : il est impossible de placer un opérateur unaire juste avant le nombre.

- -
-2 ** 2;
-// vaut 4 en Bash ou -4 avec d'autres langages
-// C'est invalide en JavaScript car il y
-// une ambiguïté liée à l'expression
-
-- (2 ** 2);
-// -4 en JavaScript car les parenthèses lèvent
-// l'ambiguïté
-
- -

Exemples

- -
2 ** 3 // 8
-3 ** 2 // 9
-3 ** 2.5 // 15.588457268119896
-10 ** -1 // 0.1
-NaN ** 2 // NaN
-
-2 ** 3 ** 2 // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
- -
-

Note : JavaScript possède également un opérateur binaire ^ (XOR logique). ** et ^ sont deux opérateurs bien différents. Par exemple 2 ** 3 === 8 et 2 ^ 3 === 1.

-
- -

Incrément (++)

- -

L'opérateur d'incrément ajoute une unité à son opérande et renvoie une valeur.

- - - -

Syntaxe

- -
Opérateur : x++ ou ++x
- -

Exemples

- -
// Suffixe
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Préfixe
-var a = 2;
-b = ++a; // a = 3, b = 3
-
- -

Décrément (--)

- -

L'opérateur de décrément soustrait une unité à son opérande et renvoie une valeur.

- - - -

Syntaxe

- -
Opérateur : x-- ou --x
- -

Exemples

- -
// Suffixe
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Préfixe
-var a = 2;
-b = --a; // a = 1, b = 1
-
- -

Négation unaire (-)

- -

L'opérateur de négation unaire précède son opérande et prend l'opposé de celui-ci (après l'avoir converti en nombre si besoin).

- -

Syntaxe

- -
Opérateur : -x
- -

Exemples

- -
var x = 3;
-y = -x; // y = -3, x = 3
-
-// La négation unaire permet de convertir
-// un opérande en nombre
-var y = "4";
-var z = -y; // z = -4
-
- -

Plus unaire (+)

- -

L'opérateur unaire plus (+) précède son opérande, l'évaluation correspond à son opérande, converti en nombre si possible et si ce n'est pas déjà un nombre. Bien que l'opérateur de négation unaire (-) puisse également convertir les expressions qui ne sont pas des nombres, le plus unaire est la méthode la plus efficace et celle la plus utilisée pour convertir quelque chose en un nombre car la conversion est la seule opération effectuée. Cet opérateur permet de convertir les chaînes de caractères représentant des nombres entiers, des nombres flottants ainsi que les valeurs true, false, et null. Les entiers, représentés sous forme décimale ou hexadécimale (préfixés par "0x"), sont supportés. Les nombres négatifs sont également supportés (mais pas au format hexadécimal). Si l'opérateur ne peut pas analyser l'opérande fourni, il sera évalué à NaN.

- -

Syntaxe

- -
Opérator : +x
- -

Exemples

- -
+3     // 3
-+"3"   // 3
-+true  // 1
-+false // 0
-+null  // 0
-+function(val){ return val; } // NaN
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ESDraft', '#sec-additive-operators')}}{{Spec2('ESDraft')}}
{{SpecName('ES2017', '#sec-postfix-expressions')}}{{Spec2('ES2017')}}
{{SpecName('ES2016', '#sec-postfix-expressions')}}{{Spec2('ES2016')}}Ajout de l'opérateur d'exponentiation.
{{SpecName('ES2015', '#sec-postfix-expressions')}}{{Spec2('ES2015')}}Définis au sein de plusieurs sections de cette spécification : Opérateurs additifs, opérateurs multiplicatifs, expressions postfixes, opérateurs unaires.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Définis au sein de plusieurs sections de cette spécification : Opérateurs additifs, opérateurs multiplicatifs, expressions postfixes, opérateurs unaires.
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale
- -

Compatibilité des navigateurs

- - - -

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

- -

Voir aussi

- - diff --git a/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html b/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html deleted file mode 100644 index 1e02f37846..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html +++ /dev/null @@ -1,259 +0,0 @@ ---- -title: Opérateurs de comparaison -slug: >- - conflicting/Web/JavaScript/Reference/Operators_03cb648b1d07bbaa8b57526b509d6d55 -tags: - - JavaScript - - Opérateur - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison ---- -
{{jsSidebar("Operators")}}
- -

JavaScript possède des opérateurs de comparaisons stricts et des opérateurs de comparaisons qui effectuent des conversions. Une comparaison strict (ex. : ===) ne sera vraie que si les deux opérandes sont du même type. La comparaison d'égalité faible (==) convertira les deux opérandes en un même type avant d'effectuer la comparaison. Pour les comparaisons relationnelles (ex. : <=), les opérandes sont tout d'abord converties en valeurs, puis en valeurs du même type, enfin la comparaison est effectuée.

- -

Les chaînes de caractères sont comparées en fonction de l'ordre lexicographique, avec des valeurs Unicode.

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

Les règles de comparaisons pour les types primitifs sont les suivantes :

- - - -

Les opérateurs d'égalité

- -

Égalité simple (==)

- -

L'opérateur d'égalité simple convertit les deux opérandes s'ils ne sont pas du même type, ensuite la comparaison stricte est appliquée. Si les deux opérandes sont des objets, le moteur JavaScript comparera les références internes pour voir si elles réfèrent au même objet en mémoire.

- -

Syntaxe

- -
x == y
-
- -

Exemples

- -
 1   ==  1;        // true
-"1"  ==  1;        // true
- 1   == '1';       // true
- 0   == false;     // true
- 0   == null;      // false
- 0   == undefined  // false
-null == undefined  // true
-
-var obj1 = { "clé": "valeur"};
-var obj2 = { "clé": "valeur"};
-obj1 == obj2       // false
-
- -

Inégalité simple (!=)

- -

L'opérateur d'inégalité simple renvoie true si les deux opérandes ne sont pas égaux. Si les deux opérandes ne sont pas du même type, une conversion sera effectuée vers un type adéquat. Si les deux opérandes sont des objets, le moteur JavaScript comparera les références internes pour voir si elles réfèrent à des objets différents en mémoire.

- -

Syntaxe

- -
x != y
- -

Exemples

- -
1 !=   2;     // true
-1 !=  "1";    // false
-1 !=  '1';    // false
-1 !=  true;   // false
-0 !=  false;  // false
-
- -

Égalité stricte (===)

- -

L'opérateur d'égalité stricte renvoie true si les opérandes sont strictement égaux (voir ci-avant), aucune conversion de type n'est effectuée.

- -

Syntaxe

- -
x === y
- -

Exemples

- -
3 === 3   // true
-3 === '3' // false
-
-var objet1 = {'clé': 'valeur'};
-var objet2 = {'clé': 'valeur'};
-objet1 === objet2; // false
-
- -

Inégalité stricte (!==)

- -

L'opérateur d'inégalité stricte renvoie true si les opérandes sont de types différents ou ne sont pas égaux.

- -

Syntaxe

- -
x !== y
- -

Exemples

- -
3 !== '3' // true
-4 !== 3   // true
-
- -

Opérateurs relationnels

- -
-

Note : Chacun de ces opérateurs invoquera la fonction valueOf() des opérandes qui sont des objets avant d'effectuer la comparaison.

-
- -

Supérieur strict (>)

- -

Cet opérateur renvoie true si l'opérande gauche est strictement supérieur à l'opérande droit.

- -

Syntaxe

- -
x > y
- -

Exemples

- -
4 > 3; // true
-
- -

Supérieur ou égal (>=)

- -

Cet opérateur renvoie true si l'opérande gauche est supérieur ou égal à l'opérande droit

- -

Syntaxe

- -
 x >= y
- -

Exemples

- -
4 >= 3; // true
-3 >= 3; // true
-
- -

Inférieur strict (<)

- -

Cet opérateur renvoie true si l'opérande gauche est strictement inférieur à l'opérande droit

- -

Syntaxe

- -
 x < y
- -

Exemples

- -
3 < 4; // true
-
- -

Inférieur ou égal (<=)

- -

Cet opérateur renvoie true si l'opérande gauche est inférieur ou égal à l'opérande droit

- -

Syntaxe

- -
 x <= y
- -

Exemples

- -
3 <= 4; // true
-
- -

Utiliser les opérateurs d'égalité

- -

Les opérateurs d'égalité/inégalité faible (== et !=) utilisent l'algorithme de comparaison d'égalité abstraite afin de comparer les deux opérandes. Si les opérandes sont de types primitifs différents, le moteur tentera de les convertir en un même type avant d'effectuer la comparaison. Ainsi, dans l'expression 5 == '5', la chaîne de droite est convertie en un nombre avant que la comparaison soit faite.

- -

Les opérateurs d'égalité/inégalité stricte (=== et !==) utilisent l'algorithme de comparaison d'égalité stricte. Si les opérandes sont de types différents, le résultat sera toujours false, on aura donc 5 !== '5'.

- -

Selon qu'on souhaite comparer des opérandes qui sont censés avoir le même type ou non, on utilisera l'un ou l'autre type d'opérateur.

- -

Si un opérande doit être comparé à un autre type, le moteur effectuera une conversion de la façon suivante :

- - - -
-

Note : Voir également la page sur les différents tests d'égalité et quand les utiliser.

-
- -
Note : Les objets String sont du type objet et ne sont pas de simples chaînes de caractères ! Cela peut parfois avoir des conséquences surprenantes :
- -
// true car les deux opérandes sont du type primitif chaîne de caractères
-'toto' === 'toto'
-
-var a = new String('toto');
-var b = new String('toto');
-
-// false car a et b sont du type objet mais font référence à deux objets distincts
-a == b
-
-// false car a et b sont du type objet mais font référence à deux objets distincts
-a === b
-
-// true car a et 'toto' sont de type différents et lorsque a est
-// converti, la fonction de conversion renvoie bien la chaîne 'toto'
-a == 'toto'
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}}Ajoute les opérateurs === et !==. Implémentés avec JavaScript 1.3
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}}Définis dans plusieurs sections de la spécification : opérateurs relationnels, opérateurs d'égalité
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}}Définis dans plusieurs sections de la spécification : opérateurs relationnels, opérateurs d'égalité
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}}Définis dans plusieurs sections de la spécification : opérateurs relationnels, opérateurs d'égalité
- -

Compatibilité des navigateurs

- - - -

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

- -

Voir aussi

- - diff --git a/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html b/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html deleted file mode 100644 index 2eaf8d2284..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html +++ /dev/null @@ -1,30 +0,0 @@ ---- -title: Opérateurs de chaînes -slug: >- - conflicting/Web/JavaScript/Reference/Operators_201bc9aef1615ff38f215c35d4cde8c9 -translation_of: Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition -translation_of_original: Web/JavaScript/Reference/Operators/String_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes ---- -

 

-

Résumé

-

En complément des opérateurs de comparaison, qui peuvent être utilisés sur des valeurs chaînes de caractères, l'opérateur de concaténation (+) permet d'assembler deux chaînes, en renvoyant une nouvelle chaîne étant l'union des deux opérandes chaînes. Par exemple, "ma " + "chaîne" renvoie la chaîne "ma chaîne".

-

L'opérateur raccourci d'assignation += peut également être utilisé pour concaténer des chaînes. Par exemple, si la variable ma_chaine a la valeur "alpha", l'expression ma_chaine += "bet" sera évaluée à "alphabet" et assignera cette valeur à la variable ma_chaine.

- - - - - - - - - - - - - - -
Opérateur
Implémentation :JavaScript 1.0
Version ECMA :ECMA-262
-
-  
-

{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Operators/String_Operators", "es": "es/Referencia_de_JavaScript_1.5/Operadores/String", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/Operatory/Operatory_dzia\u0142aj\u0105ce_na_ci\u0105gach_znak\u00f3w" } ) }}

diff --git a/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html b/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html deleted file mode 100644 index 4fbcf69ed6..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html +++ /dev/null @@ -1,416 +0,0 @@ ---- -title: Opérateurs d'affectation -slug: >- - conflicting/Web/JavaScript/Reference/Operators_2be16fc74d75a7c9dca0abca1dc5883b -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators#Assignment_operators -translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation ---- -
{{jsSidebar("Operators")}}
- -

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

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

Description

- -

L'opérateur utilisé pour l'affectation est le symbole égal (=), il permet d'affecter la valeur de l'opérande droit à son opérande gauche. Ainsi, quand on écrit x = y, on affecte la valeur de y à x. Les autres opérateurs d'affectation sont généralement des raccourcis pour des opérations standards. Ils sont décrits ci-après avec définitions et exemples.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NomOpérateur (raccourci)Signification
Affectationx = yx = y
Affectation après additionx += yx = x + y
Affectation après soustractionx -= yx = x - y
Affectation après multiplicationx *= yx = x * y
Affectation après divisionx /= yx = x / y
Affectation du restex %= yx = x % y
Affectation après exponentiationx **= yx = x ** y
Affectation après décalage à gauchex <<= yx = x << y
Affectation après décalage à droitex >>= yx = x >> y
Affectation après décalage à droite non-signéx >>>= yx = x >>> y
Affectation après ET binairex &= yx = x & y
Affectation après OU exclusif binairex ^= yx = x ^ y
Affectation après OU binairex |= yx = x | y
- -

Affectation

- -

L'opérateur d'affectation simple permet d'assigner une valeur à une variable. Le résultat de l'affectation est la valeur affectée. Il est possible de chaîner plusieurs opérateurs d'affectation afin d'assigner une même valeur à plusieurs variables. Voir l'exemple ci-après.

- -

Syntaxe

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

Exemples

- -
// Si on dispose des variables suivantes :
-//  x = 5;
-//  y = 10;
-//  z = 25;
-
-x = y;     // x vaudra désormais 10
-x = y = z; // x, y et z valent désormais tous 25
-
- -

Affectation après addition

- -

Cet opérateur permet d'ajouter la valeur de l'opérande droit à une variable, le résultat de l'addition étant affecté à cette variable. Les types des deux opérandes déterminent le comportement de l'opérateur. Selon le type, on pourra en effet avoir une addition ou une concaténation. Voir la page sur l'opérateur d'{{jsxref("Opérateurs/Opérateurs_arithmétiques", "addition", "#Addition_(.2B)", 1)}} pour plus d'informations.

- -

Syntaxe

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

Exemples

- -
// Si on dispose des variables suivantes :
-//  toto = "toto";
-//  truc = 5;
-//  machin = true;
-
-
-// Nombre + Nombre -> addition
-truc += 2; // 7
-
-// Booléen + Booléen -> addition
-machin += 1; // 2
-
-// Booléen + Booléen -> addition
-machin += false; // 1
-
-// Nombre + String -> concaténation
-truc += "toto"; // "5toto"
-
-// String + Booléen -> concaténation
-toto += false; // "totofalse"
-
-// String + String -> concaténation
-toto += "truc"; // "tototruc"
-
- -

Affectation après soustraction

- -

Cet opérateur soustrait la valeur de l'opérande droit à la variable puis affecte le résultat de cette soustraction à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "soustraction", "#Soustraction_(-)", 1)}} pour plus d'information.

- -

Syntaxe

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

Exemples

- -
// Si on a la variable suivante :
-//  truc = 5;
-
-truc -= 2;     // 3
-truc -= "toto"; // NaN
-
- -

Affectation après multiplication

- -

Cet opérateur permet de multiplier une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "multiplication", "#Multiplication_(*)", 1)}} pour plus d'informations.

- -

Syntaxe

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

Exemples

- -
// Si on a la variable suivante :
-//  truc = 5;
-
-truc *= 2;     // 10
-truc *= "toto"; // NaN
-
- -

Affectation après division

- -

Cet opérateur permet de diviser une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "division", "#Division_(.2F)", 1)}} pour plus d'informations.

- -

Syntaxe

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

Exemples

- -
// Si on a la variable suivante :
-//  truc = 5;
-
-truc /= 2;     // 2.5
-truc /= "toto"; // NaN
-truc /= 0;     // Infinity
-
- -

Affectation du reste

- -

Cet opérateur permet de divisier une variable par la valeur de l'opérande droit et d'affecter le reste de cette division à la variable. Pour plus d'informations, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_arithmétiques", "reste", "#Reste_(.25)", 1)}}.

- -

Syntaxe

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

Exemples

- -
// Si on a la variable suivante :
-//  truc = 5;
-
-truc %= 2;      // 1
-truc %= "toto"; // NaN
-truc %= 0;      // NaN
-
- -

Affectation après exponentiation

- -

L'opérateur d'affectation après exponentiation renvoie le résultat de l'élévation du premier opérande à la puissance donnée par le second opérande. Pour plus de détails, voir la page sur {{jsxref("Opérateurs/Opérateurs_arithmétiques", "l'opérateur d'exponentiation", "#Exponentiation_(**)", 1)}} for more details.

- -

Syntaxe

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

Exemples

- -
// Si on a la variable :
-//  toto = 5
-
-toto **= 2      // 25
-toto **= "truc" // NaN
- -

Affectation après décalage à gauche

- -

Cet opérateur permet de décaler un nombre donné de bits vers la gauche, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à gauche", "#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29", 1)}} pour plus d'informations.

- -

Syntaxe

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

Exemples

- -
var toto = 5; //  (00000000000000000000000000000101)
-toto <<= 2;   // 20 (00000000000000000000000000010100)
-
- -

Affectation après décalage à droite

- -

Cet opérateur permet de décaler un nombre donné de bits vers la droite, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à droite", "##.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29", 1)}} pour plus d'informations.

- -

Syntaxe

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

Exemples

- -
var toto = 5; //   (00000000000000000000000000000101)
-toto >>= 2;   // 1 (00000000000000000000000000000001)
-
-var toto -5; //    (-00000000000000000000000000000101)
-toto >>= 2;  // -2 (-00000000000000000000000000000010)
-
- -

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

- -

Cet opérateur permet de décaler le contenu de la variable d'un nombre de bits donné pour ensuite affecter le résultat à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à droite non-signé", "#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29", 1)}} pour plus de détails.

- -

Syntaxe

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

Exemples

- -
var toto = 5; //   (00000000000000000000000000000101)
-toto >>>= 2;  // 1 (00000000000000000000000000000001)
-
-var toto = -5; // (-00000000000000000000000000000101)
-toto >>>= 2; // 1073741822 (00111111111111111111111111111110)
- -

Affectation après ET binaire

- -

Cet opérateur effectue une opération ET binaire sur les deux opérandes et affecte le résultat de l'opération à la variable (l'opérande gauche). Pour plus d'informations sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "binaire ET", "#&_.28ET_binaire.29", 1)}}.

- -

Syntaxe

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

Exemple

- -
var truc = 5;
-// 5:     00000000000000000000000000000101
-// 2:     00000000000000000000000000000010
-truc &= 2; // 0
-
- -

Affectation après OU exclusif (XOR) binaire

- -

Cet opérateur utilise une représentation binaire des deux opérandes, effectue une opération binaire avec un OU exclusif et affecte le résultat à la variable. Pour plus d'informations sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "binaire OU exclusif", "#.5E_.28XOR_binaire.29", 1)}}.

- -

Syntaxe

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

Exemple

- -
var toto = 5;
-toto ^= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-
- -

Affectation après OU binaire

- -

Cet opérateur utilise une représentation binaire des deux opérandes, effectue un OU logique binaire entre ces deux variables et affecte le résultat de l'opération à la variable. Pour plus de détails sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "OU binaire", "#|_.28OU_binaire.29", 1)}}.

- -

Syntaxe

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

Exemple

- -
var toto = 5;
-toto |= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-
- -

Exemples

- -

Opérande gauche utilisé avec un autre opérateur d'affectation

- -

Dans certains cas, l'opérateur d'affectation (par exemple x += y) n'est pas identique à l'expression développée correspondante (respectivement x = x + y). Lorsque l'opérande gauche contient lui-même un opérateur d'affectation, l'opérande gauche n'est évalué qu'une fois. Ainsi :

- -
a[i++] += 5         // i est évalué une fois
-a[i++] = a[i++] + 5 // i est évalué deux fois
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ESDraft')}}
{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ES2015')}}
{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES5.1')}}
{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES1')}}Définition initiale
- -

Compatibilité des navigateurs

- - - -

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

- -

Voir aussi

- - diff --git a/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html b/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html deleted file mode 100644 index 1a57197b9c..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html +++ /dev/null @@ -1,556 +0,0 @@ ---- -title: Opérateurs binaires -slug: >- - conflicting/Web/JavaScript/Reference/Operators_688eef608213025193cd6b8e1e75b5c3 -tags: - - JavaScript - - Operator - - Opérateur - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires ---- -
{{jsSidebar("Operators")}}
- -

Les opérateurs binaires traitent leurs opérandes comme des séquences de 32 bits (des zéros et des uns), plutôt que comme des nombres décimaux, hexadécimaux ou octaux. Par exemple, le nombre décimal neuf a une représentation binaire de 1001. Les opérateurs binaires traitent de telles représentations binaires, mais renvoient des valeurs numériques JavaScript standards.

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

Le tableau qui suit résume les opérateurs binaires de JavaScript :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OpérateurUtilisationDescription
ET binairea & b -

Renvoie un 1 pour chaque position de bit pour laquelle les bits correspondants des deux opérandes sont des 1.

-
OU binairea | bRenvoie un 1 pour chaque position de bit pour laquelle le bit correspondant d'au moins un des deux opérandes est un 1 .
OU exclusif binaire (XOR)a ^ bRenvoie un 1 pour chaque position de bit pour laquelle le bit correspondant d'un seul des deux opérandes est un 1.
NON binaire~ aInverse les bits de son opérande.
Décalage à gauchea << bDécale a en représentation binaire de b bits vers la gauche, en introduisant des zéros par la droite.
Décalage à droite avec propagation du signea >> bDécale a en représentation binaire de b bits vers la droite, en rejetant les bits à droite.
Décalage à droite avec introduction de zérosa >>> bDécale a en représentation binaire de b bits vers la droite, en rejetant les bits à droite et en introduisant des zéros par la gauche.
- -

Entiers sur 32 bits signés

- -

Les opérandes de tous les opérateurs binaires sont convertis en entiers signés sur 32 bits en ordre big-endian et en format de complément à deux (à l'exception de l'opération de décalage à droite avec remplissage des zéros qui renvoie un non-signé). L'ordre big-endian signifie que le bit le plus significatif (la position du bit qui a la plus grande valeur) est le bit le plus à gauche si les 32 bits sont disposés sur une ligne horizontale. Le format de complément à deux signifie que la contrepartie négative d'un nombre (par exemple 5 pour -5) est l'inversion de tous les bits du nombre (NON binaire du nombre, c'est-à-dire son complément à un) plus un. Par exemple, la représentation suivante encode l'entier 314 (base 10) :

- -
00000000000000000000000100111010
-
- -

La représentation suivante encode ~314, c'est-à-dire le complément à un de 314 :

- -
11111111111111111111111011000101
-
- -

Finalement, la représentation suivante encode -314, c'est-à-dire le complément à deux de 314 :

- -
11111111111111111111111011000110
-
- -

Le complément à deux garantit que le bit le plus à gauche soit 0 lorsque le nombre est positif, et 1 lorsque le nombre est négatif. C'est pourquoi on l'appelle le bit de signe .

- -

Le nombre 0 est l'entier constitué intégralement de bits à 0 .

- -
0 (base 10) = 00000000000000000000000000000000 (base 2)
- -

Le nombre -1 est l'entier constitué intégralement de bits à 1 .

- -
-1 (base 10) = 11111111111111111111111111111111 (base 2)
- -

Le nombre -2147483648 (qui correspond à -0x80000000 en notation hexadécimale) est l'entier uniquement composé de 0, à l'exception du premier bit (le plus à gauche) qui vaut 1.

- -
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
- -

Le nombre 2147483647 (qui correspond à 0x7fffffff en notation hexadécimale) est l'entier uniquement composé de 1, à l'exception du premier bit (le plus à gauche) qui vaut 0.

- -
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
- -

Les nombres -2147483648 et 2147483647 sont respectivement le nombre le plus petit et le plus grand qu'on peut représenter sur 32 bits (signés).

- -

Opérateurs logiques binaires

- -

Conceptuellement, les opérateurs logiques binaires fonctionnent de la manière suivante :

- - - -

& (ET binaire)

- -

Effectue l'opération ET (AND) sur chaque paire de bits. a ET b donne 1 uniquement si à la fois a et b sont 1 . La table de vérité pour l'opération ET est :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba ET b
000
010
100
111
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
-
- -

Utiliser le ET binaire avec n'importe quel nombre x et zéro donne zéro. Utiliser le ET binaire avec n'importe quel nombre x et -1 donne x.

- -

| (OU binaire)

- -

Effectue l'opération OU (OR) sur chaque paire de bits. a OU b donne 1 si a ou b vaut 1. La table de vérité pour l'opération OU est :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba OU b
000
011
101
111
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
-
- -

Utiliser le OU binaire avec n'importe quel nombre x et 0 donne x. Utiliser le OU binaire avec n'importe quel nombre x et -1 donne -1.

- -

^ (XOR binaire)

- -

Effectue l'opération XOR (OU exclusif) sur chaque paire de bits. a XOR b donne 1 si a et b sont différents. La table de vérité pour l'opération XOR est :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba XOR b
000
011
101
110
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
-
- -

Utiliser le XOR binaire avec n'importe quel nombre x et 0 donne x. Utiliser le XOR binaire avec n'importe quel nombre x et -1 donne ~x.

- -

~ (NON binaire)

- -

Effectue l'opération NON (NOT) sur chaque bit. NON a donne la valeur inversée (c'est-à-dire le complément à un) de a. La table de vérité de l'opération NON est :

- - - - - - - - - - - - - - - - -
aNON a
01
10
- -
 9 (base 10) = 00000000000000000000000000001001 (base 2)
-               --------------------------------
-~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
-
- -

Utiliser le NON binaire avec n'importe quel nombre x donne -(x + 1). Par exemple, ~-5 donne 4.

- -

Étant donnée la représentation sur 32 bits des nombres en JavaScript, on a ~-1 et ~4294967295 (232-1) qui valent tous les deux 0.

- -

Opérateurs de décalage binaire

- -

Les opérateurs de décalage binaire (shift) prennent deux opérandes : le premier est une valeur à décaler et le second spécifie le nombre de positions de bits duquel le premier opérande doit glisser. La direction de l'opération de décalage est contrôlée par l'opérateur utilisé.

- -

Les opérateurs de décalage convertissent leurs opérandes en entiers 32 bits en ordre big-endian et renvoient un résultat du même type que l'opérande de gauche. L'opérande droit doit être inférieur à 32, sinon les cinq bits les plus faibles seront utilisés.

- -

<< (décalage à gauche)

- -

Cet opérateur décale le premier opérande du nombre de bits spécifié vers la gauche. Les bits surnuméraires éjectés à gauche sont perdus. Des bits à zéro sont insérés par la droite.

- -

Par exemple, 9 << 2 donne 36 :

- -
     9 (base 10) : 00000000000000000000000000001001 (base 2)
-                   --------------------------------
-9 << 2 (base 10) : 00000000000000000000000000100100 (base 2) = 36 (base 10)
-
- -

Décaler un nombre x de y bits vers la gauche renverra x*2yx*2^y. Par exemple,  9 << 3 correspondra à 9 * (2 ** 3) = 9 * 8 = 72.

- -

>> (décalage à droite avec propagation du signe)

- -

Cet opérateur décale le premier opérande du nombre de bits spécifié vers la droite. Les bits surnuméraires éjectés à droite sont perdus. Des copies du bit le plus à gauche sont insérés par la gauche. Comme le bit le plus a gauche a la même valeur qu'avant l'opération, le bit de signe (celui qui est le plus à gauche) ne change pas. D'où ce qu'on appelle la « propagation du signe ».

- -

Par exemple, 9 >> 2 donne 2 :

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

De même, -9 >> 2 donne -3, parce que le signe est préservé :

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

>>> (décalage à droite avec insertion de zéros)

- -

Cet opérateur décale le premier opérande du nombre de bits spécifié vers la droite. Les bits surnuméraires éjectés à droite sont perdus. Des bits à zéro sont insérés par la gauche. Le bit de signe devient 0, donc le résultat est toujours positif. À la différence des autres opérateurs binaires, cette opération renvoie un entier non-signé sur 32 bits.

- -

Pour les nombres non négatifs, le décalage à droite avec insertion de zéros et le décalage à droite avec propagation du signe donnent le même résultat. Par exemple, 9 >>> 2 donne 2, tout comme 9 >> 2 :

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

Cependant, ce n'est pas le cas des nombres négatifs. Par exemple, -9 >>> 2 donne 1073741821, ce qui est différent de -9 >> 2 (qui donne -3) :

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

Exemples

- -

Exemple : flags et bitmasks

- -

Les opérateurs logiques binaires sont souvent utilisés pour créer, manipuler et lire des séquences deflags , qui sont comme des variables binaires. On pourrait très bien utiliser des variables à la place de ces séquences binaires, mais des flags binaires prennent nettement moins de mémoire (par un facteur de 32).

- -

Supposons que l'on ait 4 flags :

- - - -

Ces flags sont représentés par une séquence de bits : DCBA. Lorsqu'un flag est positionné, il a une valeur de 1. Sinon, il a une valeur de 0. Supposons qu'une variable flags a la valeur binaire de 0101 :

- -
var flags = 0x5;   // 0101 en binaire
-
- -

Cette valeur indique :

- - - -

Comme les opérateurs binaires sont sur 32 bits, 0101 est en fait 00000000000000000000000000000101, mais les zéros qui précèdent peuvent être négligés étant donné qu'ils ne contiennent aucune information significative.

- -

Un bitmask est une séquence de bits qui peuvent manipuler et/ou lire des flags. Typiquement, un masque « primitif » pour chaque flag est défini :

- -
var FLAG_A = 0x1; // 0001
-var FLAG_B = 0x2; // 0010
-var FLAG_C = 0x4; // 0100
-var FLAG_D = 0x8; // 1000
-
- -

De nouveaux masques peuvent être créés à l'aide des opérateurs logiques binaires sur ces masques primitifs. Par exemple, le masque 1011 peut être créé avec une opération OU sur FLAG_A, FLAG_B et FLAG_D :

- -
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
-
- -

Des valeurs de flag particulières peuvent être extraites à l'aide d'une opération ET avec un bitmask, où chaque bit avec la valeur 1 va « extraire » le flag qui correspond. Le bitmask masque les flags dont on n'a pas besoin en effectuant l'opération ET avec des zéros (d'où le terme « bitmask »). Par exemple, le masque 0100 peut être utilisé pour voir si le flag C est positionné :

- -
// si l'on a un chat
-if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
-   // faire quelque chose
-}
-
- -

Un masque avec plusieurs flags positionnés agit comme un « et/ou ». Par exemple, les deux instructions suivantes sont équivalentes :

- -
// si on a une belette ou si on a un chat
-if ((flags & FLAG_B) || (flags & FLAG_C)) { // (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
-   // faire quelque chose
-}
-
- -
// si on a une belette ou si on a un chat
-var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
-if (flags & mask) { // 0101 & 0110 => 0100 => true
-   // faire quelque chose
-}
-
- -

Les flags peuvent être positionnés en utilisant l'opération OU avec un masque, où chaque bit de la valeur 1 définira le flag correspondant, si celui-ci n'est pas déjà positionné. Par exemple, le masque 1100 peut être utilisé pour positionner les flags C et D :

- -
// oui, on a un chat et un dinosaure
-var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
-flags |= mask;   // 0101 | 1100 => 1101
-
- -

Les flags peuvent être remis à zéro en utilisant l'opération ET avec un masque, où chaque bit avec la valeur 0 remettra à zéro le flag correspondant s'il ne l'est pas déjà. Ce masque peut être créé avec l'opération NOT sur les masques primitifs. Par exemple, le masque 1010 peut être utilisé pour remettre à zéro les flags A et C :

- -
// non, nous n'avons pas d'araignée ou de chat
-var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
-flags &= mask;   // 1101 & 1010 => 1000
-
- -

Le masque aurait également pu être créé avec ~FLAG_A & ~FLAG_C (Loi de De Morgan) :

- -
// non, nous n'avons pas d'araignée ou de chat
-var mask = ~FLAG_A & ~FLAG_C;
-flags &= mask;   // 1101 & 1010 => 1000
-
- -

Les flags peuvent être inversés en utilisant l'opération XOR avec un masque, où chaque bit avec la valeur 1 inversera le flag correspondant. Par exemple, le masque 0110 peut être utilisé pour inverser les flags B et C :

- -
// si on n'avait pas de belette, on en a maintenant une.
-// si on en avait une, on ne l'a plus. Même chose pour les chats.
-var mask = FLAG_B | FLAG_C;
-flags = flags ^ mask;   // 1100 ^ 0110 => 1010
-
- -

Finalement, les flags peuvent être tous inversés avec l'opérateur NON :

- -
// entrée dans un univers parallèle...
-flags = ~flags;    // ~1010 => 0101
-
- -

Codes de conversion

- -

Pour convertir une String binaire en un Number (en base 10):

- -
var chaîneBinaire = "1011";
-var monNombre = parseInt(chaîneBinaire, 2);
-console.log(monNombre); // affiche 11 (1011 en base 2)
-
- -

Pour convertir un Number (en base 10) en une String binaire :

- -
var monNombre = 11;
-var chaîneBinaire = monNombre.toString(2);
-console.log(chaîneBinaire); // affiche 1011 (11 en base 10)
-
- -

Automatiser la création d'un masque

- -

Si vous devez créer plusieurs masques à partir de booléens, il est possible d'automatiser ce processus :

- -
function créerMasque () {
-  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
-  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
-  return nMask;
-}
-var masque1 = créerMasque(true, true, false, true); // 11, i.e.: 1011
-var masque2 = créerMasque(false, false, true); // 4, i.e.: 0100
-var masque3 = créerMasque(true); // 1, i.e.: 0001
-// etc.
-
-console.log(masque1); // affiche 11, i.e.: 1011
-
- -

Algorithme réciproque : obtenir un tableau de booléen à partir d'un masque

- -

Si on souhaite créer un tableau de booléens à partir d'un masque, on pourra utiliser le code suivant :

- -
function tableauMasque (nMask) {
-  // nMask doit être compris entre -2147483648 et 2147483647
-  if (nMask > 0x7fffffff || nMask < -0x80000000) {
-    throw new TypeError("tableauMasque - intervalle de valeur dépassé");
-  }
-  for (var nShifted = nMask, aFromMask = []; nShifted;
-       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
-  return aFromMask;
-}
-
-var tableau1 = tableauMasque(11);
-var tableau2 = tableauMasque(4);
-var tableau3 = tableauMasque(1);
-
-console.log("[" + tableau1.join(", ") + "]");
-// affiche "[true, true, false, true]", i.e.: 11, i.e.: 1011
-
- -

On peut ainsi utiliser les deux algorithmes :

- -
var test = 19; // un masque quelconque
-var résultat = créerMasque.apply(this, tableauMasque(test));
-
-console.log(résultat); // 19
-
- -

Pour l'exemple (car il existe la méthode Number.toString(2)), on peut également modifier l'algorithme précédent pour créer une chaîne à partir de la représentation binaire d'un nombre :

- -
function créerChaîneBinaire(nMask) {
-  // nMask doit être compris entre -2147483648 et 2147483647
-  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
-       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
-  return sMask;
-}
-
-var string1 = créerChaîneBinaire(11);
-var string2 = créerChaîneBinaire(4);
-var string3 = créerChaîneBinaire(1);
-
-console.log(string1);
-// affiche 00000000000000000000000000001011, i.e. 11
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale.
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Définis au sein de plusieurs sections de la spécification : Opérateur NON binaire, Opérateurs binaires de décalage, Opérateurs binaires
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Définis au sein de plusieurs sections de la spécification : Opérateur NON binaire, Opérateurs binaires de décalage, Opérateurs binaires
{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}{{Spec2('ESDraft')}}Defined in several sections of the specification: opérateur NON binaire, opérateurs binaires de décalage, opérateurs binaires
- -

Compatibilité des navigateurs

- - - -

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

- -

Voir aussi

- - diff --git a/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html b/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html deleted file mode 100644 index 3751e727d9..0000000000 --- a/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html +++ /dev/null @@ -1,258 +0,0 @@ ---- -title: Opérateurs logiques -slug: >- - conflicting/Web/JavaScript/Reference/Operators_d0fb75b0fac950a91a017a1f497c6a1f -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators -original_slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques ---- -
{{jsSidebar("Operators")}}
- -

Les opérateurs logiques sont typiquement utilisés avec des valeurs booléennes (logiques) ; lorsque c'est le cas, ils renvoient une valeur booléenne également. Cependant, les opérateurs && et || renvoient en réalité la valeur d'un des opérandes spécifiés. Si ces opérateurs sont utilisés avec des valeurs non booléennes, ils peuvent donc également renvoyer une valeur non booléenne.

- -

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

- - - -

Description

- -

Les opérateurs logiques sont décrits dans le tableau suivant (les expressions indiquées comme opérandes peuvent être de n'importe quel type et pas nécessairement être booléennes au sens strict) :

- - - - - - - - - - - - - - - - - - - - - - - - -
OpérateurUsageDescription
ET logique (&&)expr1 &&expr2 Renvoie expr1 si cette expression peut être convertie en false, sinon renvoie expr2.
OU logique (||)expr1 ||expr2 Renvoie expr1 si cette expression peut être convertie en true, sinon renvoie expr2.
NON logique (!)!expr Renvoie false si son opérande unique peut être converti en true, sinon il renvoie true.
- -

Si une valeur peut être convertie en true, on dit en anglais qu'elle est truthy. Pour false on dit qu'elle est falsy.

- -

Parmi les expressions qui peuvent être converties en false, citons celles qui seront évaluées à :

- - - -

Même si les opérateurs && et || peuvent être utilisés avec des opérandes qui ne sont pas des valeurs booléennes, ils peuvent toujours être considérés comme des opérateurs booléens puisque leurs valeurs de retour peuvent toujours être converties en valeurs booléennes.

- -

Évaluation court-circuit

- -

Comme les expressions logiques sont évaluées de gauche à droite, leur évaluation sera éventuellement « court-circuitée » à l'aide des règles suivantes :

- - - -

Les règles de la logique garantissent que ces évaluations seront toujours correctes. Notons que la partien'importe quoi des expressions mentionnées ci-dessus ne sera jamais évaluée, et que tout effet de bord éventuel induit par cette évaluation ne se produira pas.

- -

Ainsi, les deux fonctions suivantes sont équivalentes :

- -
function courtCircuit() {
-  // OU logique
-  faireQuelqueChose() || faireAutreChose();
-
- faireQuelqueChose() && faireAutreChose();
-}
-
-function évaluationÉquivalente() {
-  var orFlag = faireQuelqueChose();
-  if (!orFlag) {
-    faireAutreChose();
-  }
-
-  var andFlag = faireQuelqueChose();
-  if (andFlag) {
-    faireAutreChose();
-  }
-}
-
- -

Précédence des opérateurs

- -

Les expressions suivantes ne sont pas équivalentes en raison de la précédence des opérateurs. Cela permet de noter que l'opérande droit ne doit être qu'une seule expression (si nécessaire entourée de parenthèses).

- -
true || false && false   // renvoie true car && est appliqué en premier
-(true || false) && false // renvoie false car || est appliqué en premier grâce aux parenthèses
- -

ET logique (&&)

- -

Le code qui suit illustre comment utiliser l'opérateur && (ET logique).

- -
a1 = true  && true      // t && t renvoie true
-a2 = true  && false     // t && f renvoie false
-a3 = false && true      // f && t renvoie false
-a4 = false && (3 == 4)  // f && f renvoie false
-a5 = "Yip" && "Yop"     // t && t renvoie "Yop"
-a6 = false && "Yop"     // f && t renvoie false
-a7 = "Yop" && false     // t && f renvoie false
-a8 = ""    && true      // f && f renvoie ""
-a9 = false && ""        // f && f renvoie false
-
- -

OU logique (||)

- -

Le code qui suit illustre quelques exemples d'utilisation de l'opérateur || (OU logique).

- -
o1 = true  || true       // t || t renvoie true
-o2 = false || true       // f || t renvoie true
-o3 = true  || false      // t || f renvoie true
-o4 = false || (3 == 4)   // f || f renvoie false
-o5 = "Yip" || "Yop"      // t || t renvoie "Yip"
-o6 = false || "Yip"      // f || t renvoie "Yip"
-o7 = "Yip" || false      // t || f renvoie "Yip"
-o8 = ""    || false      // f || f renvoie false
-o9 = false || ""         // f || f renvoie ""
-010 = false|| monObjet   // f || objet renvoie monObjet
-
- -

NON logique(!)

- -

Le code qui suit illustre quelques exemples d'utilisation de l'opérateur ! (NON logique).

- -
n1 = !true              // !t renvoie false
-n2 = !false             // !f renvoie true
-n3 = !""                // !f renvoie true
-n3 = !"Yop"             // !t renvoie false
-
- -

Utilisation de la double négation

- -

Il est possible d'utiliser deux fois le NON logique à la suite afin de forcer la conversion d'une valeur en un booléen. On obtiendra ainsi le booléen true si la valeur est équivalente à vrai et false si la valeur est équivalente à faux. Cette opération de conversion peut également être réalisée grâce à la fonction {{jsxref("Boolean")}}.

- -
n1 = !!true;                 // une valeur équivalente à true renvoie true
-n2 = !!{};                   // un objet, même vide est toujours équivalent à true
-n3 = !!(new Boolean(false)); // même lorsque leur constructeur est Boolean !
-n4 = !!false;                // une valeur équivalente à false renvoie false
-n5 = !!"";                   // idem
-n6 = !!Boolean(false);       // ici Boolean n'est pas utilisé comme constructeur
-                             // et la valeur produite est bien équivalente à false
- -

Règles de conversions

- -

Convertir un ET logique avec des OU logiques

- -

L'opération suivante

- -
condition1 && condition2
- -

sera toujours égale à :

- -
!(!condition1 || !condition2)
- -

Convertir un OU logique avec des ET logiques

- -

L'opération suivante :

- -
condition1 || condition2
- -

sera toujours égale à :

- -
!(!condition1 && !condition2)
- -

Convertir des NON logiques successifs

- -

Si on a l'opération suivante avec un booléen :

- -
!!condition
-
- -

elle sera toujours équivalente à

- -
condition
- -

Retirer les parenthèses imbriquées

- -

Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer certaines parenthèses d'une expression complexe grâce à quelques règles.

- -

Retirer les parenthèses d'un ET imbriqué

- -

Cette opération :

- -
condition1 || (condition2 && condition3)
- -

sera toujours équivalente à :

- -
condition1 || condition2 && condition3
- -

Retirer les parenthèses d'un OU imbriqué

- -

Cette opération :

- -
condition1 && (condition2 || condition3)
- -

sera toujours équivalente à :

- -
!(!condition1 || !condition2 && !condition3)
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires
- -

Compatibilité des navigateurs

- - - -

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

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/operators/addition/index.html b/files/fr/web/javascript/reference/operators/addition/index.html index af5fb528e0..e67da71cd6 100644 --- a/files/fr/web/javascript/reference/operators/addition/index.html +++ b/files/fr/web/javascript/reference/operators/addition/index.html @@ -7,76 +7,64 @@ tags: - Reference translation_of: Web/JavaScript/Reference/Operators/Addition original_slug: Web/JavaScript/Reference/Opérateurs/Addition +browser-compat: javascript.operators.addition ---
{{jsSidebar("Operators")}}
-
L'opérateur d'addition (+) effectue la somme de deux opérandes numériques ou la concaténation de chaînes de caractères.
- - +

L'opérateur d'addition (+) produit la somme de deux opérandes numériques ou la concaténation de deux chaînes de caractères.

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

Syntaxe

+

Syntaxe

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

 
-
Exemples

+
Exemples

 
-
Addition numérique

+
Addition numérique

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

 
-
Concaténation de chaînes

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

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

+'toto' + false // "totofalse"

 
-
Spécifications

+
Spécifications

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

+
{{Specifications}}

 
-
Compatibilité des navigateurs

+
Compatibilité des navigateurs

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

+
{{Compat}}

 
-
Voir aussi

+
Voir aussi

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

+
{{jsSidebar("Operators")}}

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

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

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

 
-

+
Syntax

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

 
-
Syntaxe

+
Exemples

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

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

 
-
Examples

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

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

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

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

+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur ET binaire (&) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un 1 pour chaque position où les bits des deux opérandes valent 1.

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

+
+
Syntaxe

+
+
+a & b
+

+
+
Description

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

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

+
+
Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsque les deux valent 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.

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

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

+
+
+     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+

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

+
+
Exemples

+
+
Utiliser l'opérateur ET binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

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

+
+
Exemples

+
+
Utiliser l'affectation après ET binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+~a
+

+
+
Description

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

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

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

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

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

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

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

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

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

+
+
Exemples

+
+
Utiliser le NON binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+a | b
+

+
+
Description

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

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

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

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

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

+
+
+     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
+

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

+
+
Exemples

+
+
Utiliser l'opérateur OU binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

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

+
+
Exemples

+
+
Utiliser l'affectation après OU binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+a ^ b
+

+
+
Description

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

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

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

+
+
La table de vérité pour l'opérateur OU exclusif (XOR) est :

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

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

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

+
+
Exemples

+
+
Utiliser le OU exclusif binaire

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

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

+
+
Exemples

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

+
+
+let a = 5;      // 00000000000000000000000000000101
+a ^= 3;         // 00000000000000000000000000000011
+
+console.log(a); // 00000000000000000000000000000110
+// 6
+
+let b = 5;      // 00000000000000000000000000000101
+b ^= 0;         // 00000000000000000000000000000000
+
+console.log(b); // 00000000000000000000000000000101
+// 5
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de décrémentation (--) permet de décrémenter (c'est-à-dire de soustraire un) son opérande et renvoie une valeur qui est le résultat avant ou après la modification.

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

+
+
Syntaxe

+
+
+Opérateur : x-- ou --x
+

+
+
Description

+
+
Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans x--, l'opérateur décrémentera la valeur et renverra la valeur avant l'incrément.

+
+
Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans --x, l'opérateur décrémentera la valeur et renverra la valeur après l'incrément.

+
+
Exemples

+
+
Décrément en suffixe

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

+
+
Décrément en préfixe

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de division (/) fournit le quotient de l'opérande gauche (le numérateur) divisé par l'opérande droite (le dénominateur).

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

+
+
Syntaxe

+
+
+Opérateur : x / y
+

+
+
Exemples

+
+
Divisions simples

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

+
+
Division par zéro

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de division et d'affectation (/=) divise la variable fournie par l'opérande gauche par la valeur indiquée par l'opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x == y
+

+
+
Description

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

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

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

+
+
Exemples

+
+
Comparaison sans conversion de types

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

+
+
Comparaison avec conversion de types

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

+
+
Comparaison d'objets

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

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

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

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

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+Opérateur : var1 ** var2
+

+
+
Description

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

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

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

+
+
+-2 ** 2;
+// 4 en Bash, -4 pour d'autres langages.
+// Invalide en JavaScript car l'opération est ambigüe.
+
+-(2 ** 2);
+// -4 en JavaScript, les parenthèses évitent l'ambiguité.
+

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

+
+
Exemples

+
+
Exponentiation simple

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

+
+
Associativité

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

+
+
Avec les opérateurs unaires

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

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

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur d'exponentiation et d'affectation (**=) élève la valeur de la variable fournie par son opérande gauche à la puissance indiquée par son opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x > y
+

+
+
Description

+
+
Les opérandes sont comparés avec l'algorithme de comparaison abstraite relationnelle. Voir la documentation de l'opérateur inférieur strict pour un résumé de cet algorithme.

+
+
Exemples

+
+
Comparaison numérique

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
+console.log(true > false);     // true
+console.log(false > true);     // false
+
+console.log(true > 0);         // true
+console.log(true > 1);         // false
+
+console.log(null > 0);         // false
+console.log(1 > null);         // true
+
+console.log(undefined > 3);    // false
+console.log(3 > undefined);    // false
+
+console.log(3 > NaN);          // false
+console.log(NaN > 3);          // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x >= y
+

+
+
Description

+
+
Les opérandes sont comparés avec l'algorithme de comparaison abstraite relationnelle. Voir la documentation de l'opérateur inférieur strict pour un résumé de cet algorithme.

+
+
Exemples

+
+
Comparaison numérique

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
+console.log(true >= false);  // true
+console.log(true >= true);   // true
+console.log(false >= true);  // false
+
+console.log(true >= 0);      // true
+console.log(true >= 1);      // true
+
+console.log(null >= 0);      // true
+console.log(1 >= null);      // true
+
+console.log(undefined >= 3); // false
+console.log(3 >= undefined); // false
+
+console.log(3 >= NaN);       // false
+console.log(NaN >= 3);       // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur d'incrémentation (++) permet d'incrémenter (c'est-à-dire d'ajouter un) à son opérande et de renvoyer une valeur qui est le résultat avant ou après la modification.

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

+
+
Syntaxe

+
+
+Opérateur : x++ ou ++x
+

+
+
Description

+
+
Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans x++, l'opérateur incrémentera la valeur et renverra la valeur avant l'incrément.

+
+
Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans ++x, l'opérateur incrémentera la valeur et renverra la valeur après l'incrément.

+
+
Exemples

+
+
Incrément en suffixe

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

+
+
Incrément en préfixe

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

 
-
Expressions et opérateurs, par catégorie

+
Expressions et opérateurs par catégorie

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

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

 
-
Expressions primaires

+
Expressions primaires

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

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

 
 

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

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

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

+ 
this

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

+ 
function

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

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

+ 
class

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

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

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

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

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

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

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

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

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

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

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

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

- 
Littéral initialisateur de tableau.

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

- 
Littéral initialisateur d'objet.

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

- 
Littéral d'expression rationnelle.

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

+ 
function*

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

+ 
yield

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

+ 
yield*

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

+ 
async function

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

+ 
await

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

+ 
[]

+ 
Syntaxe d'initialisation littérale pour les tableaux.

+ 
{}

+ 
Syntaxe d'initialisation littérale pour les objets.

+ 
/ab+c/i

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

+ 
( )

  
Opérateur de groupement.

 

 
-
Expressions « vers la gauche »

+
Expression « vers la gauche »

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

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

 
 

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

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

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

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

- 
new.target

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

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

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

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

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

+ 
Accesseurs de propriété

+ 
Les opérateurs d'accès aux membres permettent d'accéder à une propriété ou à une méthode d'un objet.

+ (cela regroupe objet.propriete et objet["propriete"]).

+ 
new

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

+ 
new.target

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

+ 
import.meta

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

+ 
super

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

+ 
...obj

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

 

 
-
Incrémentation et décrémentation

+
Incrémentation et décrémentation

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

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

 
 

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

- 
Opérateur d'incrémentation suffixe.

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

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

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

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

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

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

+ 
A++

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

+ 
A--

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

+ 
++A

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

+ 
--A

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

 

 
-
Opérateurs unaires

+
Opérateurs unaires

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

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

 
 

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

+ 
delete

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

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

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

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

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

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

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

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

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

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

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

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

- 
L'opérateur du NON logique.

+ 
void

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

+ 
typeof

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

+ 
+

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

+ 
-

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

+ 
~

+ 
L'opérateur binaire NON.

+ 
!

+ 
L'opérateur logique NON.

 

 
-
Opérateurs arithmétiques

+
Opérateurs arithmétiques

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

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

 
 

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

+ 
+

  
L'opérateur d'addition.

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

+ 
-

  
L'opérateur de soustraction.

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

+ 
/

  
L'opérateur de division.

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

+ 
*

  
L'opérateur de multiplication.

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

+ 
%

  
L'opérateur du reste.

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

- 
Opérateur de puissance (exponentiation).

+ 
**

+ 
L'opérateur d'exponentiation.

 

 
-
Opérateurs relationnels

+
Opérateurs relationnels

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

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

 
 

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

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

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

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

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

- 
Opérateur inférieur strict.

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

- 
Opérateur supérieur strict.

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

- 
Opérateur inférieur ou égal.

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

- 
Opérateur supérieur ou égal.

+ 
in

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

+ 
instanceof

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

+ 
<

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

+ 
>

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

+ 
<=

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

+ 
>=

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

 

 
-

-
Note : => n'est pas un opérateur. Il s'agit de la notation utilisée pour les fonctions fléchées.

+

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

 

 
-
Opérateurs d'égalité

+
Opérateurs d'égalité

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

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

 
 

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

- 
Opérateur d'égalité faible.

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

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

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

- 
Opérateur d'égalité stricte.

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

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

+ 
==

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

+ 
!=

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

+ 
===

+ 
L'opérateur d'identité.

+ 
!==

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

 

 
-
Opérateurs de décalage binaires

+
Opérateurs de décalage binaires

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

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

 
 

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

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

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

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

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

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

+ 
<<

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

+ 
>>

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

+ 
>>>

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

 

 
-
Opérateurs binaires logiques

+
Opérateurs binaires booléens

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

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

 
 

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

- 
ET binaire (AND).

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

- 
OU binaire (OR).

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

- 
OU exclusif binaire (XOR).

+ 
&

+ 
Opérateur ET/AND binaire.

+ 
|

+ 
Opérateur OU/OR binaire.

+ 
^

+ 
Opérateur OU exclusif/XOR binaire.

 

 
-
Opérateurs logiques

+
Opérateurs logiques

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

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

 
 

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

- 
ET logique (AND).

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

- 
OU logique (OR).

+ 
&&

+ 
Opérateur logique ET/AND.

+ 
||

+ 
Opérateur logique OU/OR.

+ 
??

+ 
Opérateur de coalescence des nuls.

 

 
-
Opérateur conditionnel ternaire

+
Opérateur conditionnel ternaire

 
 

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

+ 
(condition ? ifTrue : ifFalse)

  

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

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

  

 

 
-
Opérateurs d'affectation

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

+
Opérateur de chaînage optionnel

 
 

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

- 
Opérateur d'affectation.

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

- 
Affectation après multiplication.

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

- 
Affectation après division.

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

- 
Affectation du reste.

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

- 
Affectation après addition.

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

- 
Affectation après soustraction.

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

- 
Affectation après décalage à gauche.

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

- 
Affectation après décalage à droite.

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

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

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

- 
Affectation après ET binaire.

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

- 
Affectation après OU exclusif binaire.

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

- 
Affectation après OU binaire.

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

+ 
?.

  

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

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

  

 

 
-
Opérateur virgule

+
Opérateurs d'affectation

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

 
 

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

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

+ 
=

+ 
Opérateur d'affectation.

+ 
*=

+ 
Opérateur de multiplication et d'affectation.

+ 
**=

+ 
Opérateur d'exponentiation et d'affectation.

+ 
/=

+ 
Opérateur de division et d'affectation.

+ 
%=

+ 
Opérateur de reste et d'affectation.

+ 
+=

+ 
Opérateur d'addition et d'affectation.

+ 
-=

+ 
Opérateur de soustraction et d'affectation

+ 
<<=

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

+ 
>>=

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

+ 
>>>=

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

+ 
&=

+ 
Opérateur binaire ET et d'affectation.

+ 
^=

+ 
Opérateur binaire OU exclusif et d'affectation.

+ 
|=

+ 
Opérateur binaire OU et d'affectation.

+ 
&&=

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

+ 
||=

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

+ 
??=

+ 
Opérateur d'affectation et de logique nulle.

+ 
[a, b] = [1, 2]

+ {a, b} = {a:1, b:2}

+ 

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

+ 

 

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

+
Opérateur virgule

 
 

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

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

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

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

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

- 
Compréhensions de tableau.

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

- 
Compréhensions de générateurs.

+ 
,

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

 

 
-
Spécifications

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

-
-
Compatibilité des navigateurs

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

-
-
Voir aussi

+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur d'inégalité (!=) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de l'opérateur d'inégalité stricte, l'opérateur d'inégalité tente une conversion de ses opérandes avant la comparaison si ceux-ci sont de types différents.

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

+
+
Syntaxe

+
+
+x != y
+

+
+
Description

+
+
L'opérateur d'inégalité vérifie si ses deux opérandes ne sont pas égaux. Il s'agit de la négation de l'opérateur d'égalité et les deux lignes suivantes fourniront donc toujours le même résultat :

+
+
+x != y
+!(x == y)
+

+
+
Pour plus de détails sur l'algorithme de comparaison utilisé, voir la page relative à l'opérateur d'égalité.
+

+
+
À l'instar de l'opérateur d'égalité, l'opérateur d'inégalité tentera une conversion des opérandes si ceux-ci ne sont pas de même type :

+
+
+3 != "3"; // false
+

+
+
Si cette conversion implicite n'est pas souhaitable et qu'on souhaite considérer des valeurs de types différents comme étant différentes, on privilégiera l'opérateur d'inégalité stricte à la place :

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

+
+
Exemples

+
+
Comparaison sans conversion de types

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

+
+
Comparaison avec conversion de types

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

+
+
Comparaison d'objets

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de décalage binaire à gauche (<<) décale la séquence de bits représentée par le premier opérande d'autant de bits vers la gauche que le nombre indiqué par le second opérande. Les bits en excès à gauche sont écartés et des bits à zéro sont introduits à droite.

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

+
+
Syntaxe

+
+
+a << b
+

+
+
Description

+
+
Cet opérateur décale les bits du premier opérande vers la gauche, d'autant que le nombre indiqué par le second opérande. Les bits qui dépassent à gauche sont abandonnés et des zéros sont introduits à droite.

+
+
Ainsi, 9 << 2 donnera la valeur 36 (en base 10) :

+
+
+       9 (base 10): 00000000000000000000000000001001 (base 2)
+                    --------------------------------
+  9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
+

+
+
Le décalage binaire de tout nombre x de y bits vers la gauche donnera comme résultat x * 2 ** y. Par exemple, 9 << 3 pourra être reformulé en 9 * (2 ** 3) = 9 * (8) = 72.

+
+
Exemples

+
+
Utiliser le décalage binaire à gauche

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de décalage à gauche et d'affectation (<<=) décale la séquence de bits représentée par l'opérande gauche d'autant de bits qu'indiqué par l'opérande droit puis affecte le résultat obtenu à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x < y
+

+
+
Description

+
+
Les opérandes sont comparés avec l'algorithme de comparaison abstraite relationnelle résumé comme suit :

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

+
+
Exemples

+
+
Comparaison numérique

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
+console.log(true < false);     // false
+console.log(false < true);     // true
+
+console.log(0 < true);         // true
+console.log(true < 1);         // false
+
+console.log(null < 0);         // false
+console.log(null < 1);         // true
+
+console.log(undefined < 3);    // false
+console.log(3 < undefined);    // false
+
+console.log(3 < NaN);          // false
+console.log(NaN < 3);          // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur inférieur ou égal (<=) renvoie true si l'opérande gauche est inférieur ou égal à l'opérande droit et false sinon.

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

+
+
Syntaxe

+
+
+x <= y
+

+
+
Description

+
+
Les opérandes sont comparés avec l'algorithme de comparaison abstraite relationnelle. Voir la documentation de l'opérateur inférieur strict pour un résumé de cet algorithme.

+
+
Exemples

+
+
Comparaison numérique

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

+
+
Comparaison entre un nombre et un BigInt

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

+
+
Comparaison entre chaînes de caractères

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

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

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

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

+
+
+console.log(true <= false);  // false
+console.log(true <= true);   // true
+console.log(false <= true);  // true
+
+console.log(true <= 0);      // false
+console.log(true <= 1);      // true
+
+console.log(null <= 0);      // true
+console.log(1 <= null);      // false
+
+console.log(undefined <= 3); // false
+console.log(3 <= undefined); // false
+
+console.log(3 <= NaN);       // false
+console.log(NaN <= 3);       // false
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+expr1 && expr2
+

+
+
Description

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

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

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

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

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

+
+
Évaluation en court-circuit

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

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

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

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

+
+
Précédence des opérateurs

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

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

+
+
Exemples

+
+
Utiliser le ET logique

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

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

+
+
Règles de conversion booléennes

+
+
Convertir ET en OU

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

+
+
+bCondition1 && bCondition2
+

+
+
sera toujours équivalente à :

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

+
+
Convertir OU en ET

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

+
+
+bCondition1 || bCondition2
+

+
+
sera toujours équivalente à :

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

+
+
Retrait des parenthèses imbriquées

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

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

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

+
+
sera toujours égale à :

+
+
+bCondition1 || bCondition2 && bCondition3
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+expr1 &&= expr2
+

+
+
Description

+
+
Évaluation en court-circuit

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

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

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

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

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

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

+
+
+x = x && y;
+

+
+
Exemples

+
+
Utiliser l'affectation après ET logique

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+!expr
+

+
+
Description

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

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

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

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

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

+
+
Exemples

+
+
Utiliser NON

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

+
+
+let n1 = !true     // !t renvoie false
+let n2 = !false    // !f renvoie true
+let n3 = !''       // !f renvoie true
+let n4 = !'Cat'    // !t renvoie false
+

+
+
Double NON (!!)

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

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

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

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

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

+
+
!!bCondition

+
+
est toujours égale à :

+
+
bCondition

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

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

+
+
Syntaxe

+
+
+expr1 ??= expr2
+

+
+
Description

+
+
Évaluation en court-circuit

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

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

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

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

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

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

+
+
+x = x ?? y;
+

+
+
Exemples

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

+
+
+function config(options) {
+  options.duration ??= 100;
+  options.speed ??= 25;
+  return options;
+}
+
+config({ duration: 125 }); // { duration: 125, speed: 25 }
+config({}); // { duration: 100, speed: 25 }
+

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntax

+
+
+expr1 || expr2
+

+
+
Description

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

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

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

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

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

+
+
Évaluation en court-circuit

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

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

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

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

+
+
Précédence des opérateurs

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

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

+
+
Exemples

+
+
Utiliser le OU logique

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

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

+
+

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

+

+
+
Règles de conversion booléennes

+
+
Convertir ET en OU

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

+
+
bCondition1 && bCondition2

+
+
sera toujours équivalente à :

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

+
+
Convertir OU en ET

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

+
+
bCondition1 || bCondition2

+
+
sera toujours équivalente à :

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

+
+
Retrait des parenthèses imbriquées

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

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

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

+
+
sera toujours équivalente à :

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+expr1 ||= expr2
+

+
+
Description

+
+
Évaluation en court-circuit

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

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

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

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

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

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

+
+
+x = x || y;
+

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

+
+
Exemples

+
+
Affecter une valeur par défaut

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

+
+
+document.getElementById('paroles').textContent ||= 'Aucune parole.'
+

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+Opérateur : x * y
+

+
+
Exemples

+
+
Avec des nombres

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

+
+
Avec l'infini

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

+
+
Avec des valeurs non-numériques

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de multiplication et d'affectation (*=) multiplie une variable fournie par l'opérande gauche par la valeur fournie par l'opérande droit puis affecte le résultat de l'opération à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

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

+
+
Syntaxe

+
+
+Opérateur : var1 % var2
+

+
+
Exemples

+
+
Reste avec numérateur positif

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

+
+
Reste avec numérateur négatif

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

+
+
Reste avec NaN

+
+
+NaN % 2 // NaN
+

+
+
Reste avec l'infini

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de reste et d'affectation (%=) calcule le reste de la division de l'opérande gauche par l'opérande droit et affecte ce résultat à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+a >> b
+

+
+
Description

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

+
+
Ainsi, 9 >> 2 donnera 2 :

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

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

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

+
+
Exemples

+
+
Utiliser le décalage à droite

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de décalage à droite et d'affectation (>>=) décale la séquence de bits indiquée par l'opérande gauche d'autant de bits qu'indiqués par l'opérande droit puis affecte le résultat obtenu à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x === y
+

+
+
Description

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

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

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

+
+
Exemples

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

+
+
+console.log("hello" === "hello");   // true
+console.log("hello" === "hola");    // false
+
+console.log(3 === 3);               // true
+console.log(3 === 4);               // false
+
+console.log(true === true);         // true
+console.log(true === false);        // false
+
+console.log(null === null);         // true
+

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

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

+
+
Comparaison d'objets

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+x !== y
+

+
+
Description

+
+
L'opérateur d'inégalité stricte vérifie que ses deux opérandes ne sont pas égaux. Il s'agit de la négation de l'opérateur d'égalité stricte. Les deux expressions suivantes fourniront toujours le même résultat :

+
+
+x !== y
+!(x === y)
+

+
+
Pour plus de détails sur l'algorithme de comparaison utilisé, voir la page sur l'opérateur d'égalité stricte.

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

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

+
+
Exemples

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

+
+
+console.log("hello" !== "hello");   // false
+console.log("hello" !== "hola");    // true
+
+console.log(3 !== 3);               // false
+console.log(3 !== 4);               // true
+
+console.log(true !== true);         // false
+console.log(true !== false);        // true
+
+console.log(null !== null);         // false
+

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

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

+
+
Comparaison d'objets

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+Opérateur : x - y
+

+
+
Exemples

+
+
Avec des valeurs numériques

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

+
+
Avec des valeurs non-numériques

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur d'affectation après soustraction (-=) calcule la soustraction de l'opérande gauche par l'opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.

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

+
+
Syntaxe

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+Opérateur : -x
+

+
+
Exemples

+
+
Avec des nombres

+
+
const x = 3;
+const y = -x;
+
+// y = -3
+// x = 3
+

+
+
Avec des valeurs non-numériques

+
+
L'opérateur de négation unaire peut être utilisé pour convertir une valeur non-numérique en nombre.

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de plus unaire (+) précède son opérande et évalue son opérande en essayant de le convertir en nombre si ce n'est pas déjà une valeur numérique.

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

+
+
Syntaxe

+
+
+Opérateur : +x
+

+
+
Description

+
+
Bien que la négation unaire (-) puisse également être utilisée pour convertir des valeurs non-numérique, le plus unaire est plus rapide et plus conventionnel, car il n'effectue pas d'autres opérations que la conversion. Il peut être utilisé pour convertir les représentations textuelles d'entiers ou de flottants ainsi que les valeurs true, false, et null. Les représentations entières au format décimal ou hexadécimal sont toutes les deux prises en charge. Les nombres négatifs sont pris en charge (hors représentation hexadécimale). L'utilisation de cet opérateur sur les valeurs de type BigInt déclenchera une exception TypeError. Si l'analyse de valeur ne permet pas de déduire une valeur numérique, le résultat sera NaN.

+
+
Exemples

+
+
Avec des nombres

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

+
+
Avec des valeurs non-numériques

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

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

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

+
+
Syntaxe

+
+
+a >>> b
+

+
+
Description

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

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

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

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

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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

+
+
L'opérateur de décalage à droite non signé et d'affectation (>>>=) décale la séquence de bits fournie par l'opérande gauche vers la droite, d'autant de bits qu'indiqués par l'opérande droit, puis affecte le résultat de l'opération à la variable indiquée par l'opérande gauche.

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

+
+
Syntax

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

+
+
Exemples

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

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

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

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