diff options
Diffstat (limited to 'files/fr')
52 files changed, 3567 insertions, 2202 deletions
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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p><strong>Les opérateurs arithmétiques </strong>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 (/).</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</div> - -<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> - -<h2 id="Addition_2"><a name="Addition">Addition (+)</a></h2> - -<p>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.</p> - -<h3 id="Syntaxe">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x + y</pre> - -<h3 id="Exemples">Exemples</h3> - -<pre class="brush: js">// 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" -</pre> - -<h2 id="Soustraction_-"><a name="Subtraction">Soustraction (-)</a></h2> - -<p>L'opérateur de soustraction soustrait les deux opérandes pour obtenir leur différence.</p> - -<h3 id="Syntaxe_2">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x - y</pre> - -<h3 id="Exemples_2">Exemples</h3> - -<pre class="brush:js">5 - 3 // 2 -3 - 5 // -2 -"toto" - 3 // NaN -</pre> - -<h2 id="Division_2"><a name="Division">Division (/)</a></h2> - -<p>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.</p> - -<h3 id="Syntaxe_3">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x / y</pre> - -<h3 id="Exemples_3">Exemples</h3> - -<pre class="brush: js">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</pre> - -<h2 id="Multiplication_*"><a name="Multiplication">Multiplication (*)</a></h2> - -<p>L'opérateur de multiplication permet d'obtenir le produit des opérandes.</p> - -<h3 id="Syntaxe_4">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x * y</pre> - -<h3 id="Exemples_4">Exemples</h3> - -<pre class="brush: js">2 * 2 // 4 --2 * 2 // -4 -Infinity * 0 // NaN -Infinity * Infinity // Infinity -"toto" * 2 // NaN -</pre> - -<h2 id="Reste"><a name="Remainder">Reste (%)</a></h2> - -<p>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).</p> - -<h3 id="Syntaxe_5">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : var1 % var2</pre> - -<h3 id="Exemples_5">Exemples</h3> - -<pre class="brush: js">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</pre> - -<h2 id="Exponentiation_**"><a id="Exponentiation" name="Exponentiation">Exponentiation (**)</a></h2> - -<p>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 : <code>var1 ** var2</code> sera équivalent à <code>var1<sup>var2</sup></code> en notation mathématique. Cet opérateur est associatif à droite, autrement dit <code>a ** b ** c</code> est égal à <code>a ** (b ** c)</code>.</p> - -<h3 id="Syntaxe_6">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : var1 ** var2</pre> - -<h3 id="Notes">Notes</h3> - -<p>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.</p> - -<pre class="brush: js">-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é -</pre> - -<h3 id="Exemples_6">Exemples</h3> - -<pre class="brush: js">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</pre> - -<div class="note"> -<p><strong>Note :</strong> JavaScript possède également <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(XOR_binaire)">un opérateur binaire ^ (XOR logique)</a>. <code>**</code> et <code>^</code> sont deux opérateurs bien différents. Par exemple <code>2 ** 3 === 8</code> et <code>2 ^ 3 === 1</code>.</p> -</div> - -<h2 id="Incrément"><a name="Increment">Incrément (++)</a></h2> - -<p>L'opérateur d'incrément ajoute une unité à son opérande et renvoie une valeur.</p> - -<ul> - <li>Si l'opérateur est utilisé en suffixe (par exemple : x++), il renvoie la valeur avant l'incrémentation.</li> - <li>Si l'opérateur est utilisé en préfixe (par exemple : ++x), il renvoie la valeur après l'incrémentation.</li> -</ul> - -<h3 id="Syntaxe_7">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x++ ou ++x</pre> - -<h3 id="Exemples_7">Exemples</h3> - -<pre class="brush: js">// Suffixe -var x = 3; -y = x++; // y = 3, x = 4 - -// Préfixe -var a = 2; -b = ++a; // a = 3, b = 3 -</pre> - -<h2 id="Décrément_--"><a name="Decrement">Décrément (--)</a></h2> - -<p>L'opérateur de décrément soustrait une unité à son opérande et renvoie une valeur.</p> - -<ul> - <li>Si l'opérateur est utilisé en suffixe (par exemple : x--), il renvoie la valeur avant la décrémentation.</li> - <li>Si l'opérateur est utilisé en préfixe (par exemple : --x), il renvoie la valeur après la décrémentation.</li> -</ul> - -<h3 id="Syntaxe_8">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : x-- ou --x</pre> - -<h3 id="Exemples_8">Exemples</h3> - -<pre class="brush: js">// Suffixe -var x = 3; -y = x--; // y = 3, x = 2 - -// Préfixe -var a = 2; -b = --a; // a = 1, b = 1 -</pre> - -<h2 id="Négation_unaire_-"><a name="Unary_negation">Négation unaire (-)</a></h2> - -<p>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).</p> - -<h3 id="Syntaxe_9">Syntaxe</h3> - -<pre class="syntaxbox">Opérateur : -x</pre> - -<h3 id="Exemples_9">Exemples</h3> - -<pre class="brush: js">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 -</pre> - -<h2 id="Plus_unaire"><a name="Unary_plus">Plus unaire</a> (+)</h2> - -<p>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 <code>true</code>, <code>false</code>, et <code>null</code>. 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é à <a href="/fr/docs/JavaScript/Reference/Propriétés_globales/NaN">NaN</a>.</p> - -<h3 id="Syntaxe_10">Syntaxe</h3> - -<pre class="syntaxbox">Opérator : +x</pre> - -<h3 id="Exemples_10">Exemples</h3> - -<pre class="brush: js">+3 // 3 -+"3" // 3 -+true // 1 -+false // 0 -+null // 0 -+function(val){ return val; } // NaN -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td> - <td>{{Spec2('ES2017')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td> - <td>{{Spec2('ES2016')}}</td> - <td><a href="https://github.com/rwaldron/exponentiation-operator">Ajout de l'opérateur d'exponentiation.</a></td> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">opérateurs multiplicatifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">opérateurs unaires</a>.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.3')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.5">opérateurs multiplicatifs</a>,<a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.3"> expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.4">opérateurs unaires</a>.</td> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> - -<p>{{Compat("javascript.operators.arithmetic")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">Opérateurs d'affectation</a></li> -</ul> 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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>JavaScript possède des opérateurs de comparaisons stricts et des opérateurs de comparaisons qui effectuent des conversions. Une comparaison strict (ex. : <code>===</code>) ne sera vraie que si les deux opérandes sont du même type. La comparaison d'égalité faible (<code>==</code>) convertira les deux opérandes en un même type avant d'effectuer la comparaison. Pour les comparaisons relationnelles (ex. : <code><=</code>), les opérandes sont tout d'abord converties en valeurs, puis en valeurs du même type, enfin la comparaison est effectuée.</p> - -<p>Les chaînes de caractères sont comparées en fonction de l'ordre lexicographique, avec des valeurs Unicode.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div> - -<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> - -<p>Les règles de comparaisons pour <a href="/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives">les types primitifs</a> sont les suivantes :</p> - -<ul> - <li>Deux chaînes de caractères sont strictement égales lorsqu'elles ont la même séquence de caractères, la même longueur et les mêmes caractères aux mêmes positions.</li> - <li>Deux nombres sont strictement égaux lorsqu'ils ont la même valeur. {{jsxref("Objets_globaux/NaN","NaN")}} n'est égal à rien, y compris lui-même. Le zéro positif et le zéro négatif sont considérés égaux.</li> - <li>Deux booléens sont strictement égaux s'ils valent tous les deux <code>true</code> ou tous les deux <code>false</code>.</li> - <li>Deux objets distincts ne sont jamais égaux l'un à l'autre (pour l'égalité faible et stricte).</li> - <li>Deux objets sont égaux si les deux opérandes sont des références au même objet.</li> - <li>Les types nul et indéfini sont strictement égaux à eux-mêmes et sont faiblement égaux l'un à autre.</li> -</ul> - -<h2 id="Les_opérateurs_dégalité">Les opérateurs d'égalité</h2> - -<h3 id="Égalité_simple"><a>Égalité simple (==)</a></h3> - -<p>L'opérateur d'égalité simple convertit les deux opérandes s'<strong>ils ne sont pas du même type</strong>, ensuite la comparaison stricte est appliquée. Si <strong>les deux opérandes sont des objets</strong>, le moteur JavaScript comparera les références internes pour voir si elles réfèrent au même objet en mémoire.</p> - -<h4 id="Syntaxe">Syntaxe</h4> - -<pre class="syntaxbox">x == y -</pre> - -<h4 id="Exemples">Exemples</h4> - -<pre class="brush: js"> 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 -</pre> - -<h3 id="Inégalité_simple_!"><a>Inégalité simple (!=)</a></h3> - -<p>L'opérateur d'inégalité simple renvoie <code>true</code> si les deux opérandes ne sont pas égaux. Si les deux opérandes <strong>ne sont pas du même type</strong>, une conversion sera effectuée vers un type adéquat. <strong>Si les deux opérandes sont des objets,</strong> le moteur JavaScript comparera les références internes pour voir si elles réfèrent à des objets différents en mémoire.</p> - -<h4 id="Syntaxe_2">Syntaxe</h4> - -<pre class="syntaxbox">x != y</pre> - -<h4 id="Exemples_2">Exemples</h4> - -<pre class="brush: js">1 != 2; // true -1 != "1"; // false -1 != '1'; // false -1 != true; // false -0 != false; // false -</pre> - -<h3 id="Égalité_stricte"><a>Égalité stricte (===)</a></h3> - -<p>L'opérateur d'égalité stricte renvoie <code>true</code> si les opérandes sont strictement égaux (voir ci-avant), <strong>aucune conversion de type n'est effectuée</strong>.</p> - -<h4 id="Syntaxe_3">Syntaxe</h4> - -<pre class="syntaxbox">x === y</pre> - -<h4 id="Exemples_3">Exemples</h4> - -<pre class="brush: js ">3 === 3 // true -3 === '3' // false - -var objet1 = {'clé': 'valeur'}; -var objet2 = {'clé': 'valeur'}; -objet1 === objet2; // false -</pre> - -<h3 id="Inégalité_stricte_!"><a>Inégalité stricte (!==)</a></h3> - -<p>L'opérateur d'inégalité stricte renvoie <code>true</code> si les opérandes sont de types différents ou ne sont pas égaux.</p> - -<h4 id="Syntaxe_4">Syntaxe</h4> - -<pre class="syntaxbox">x !== y</pre> - -<h4 id="Exemples_4">Exemples</h4> - -<pre class="brush: js">3 !== '3' // true -4 !== 3 // true -</pre> - -<h2 id="Opérateurs_relationnels">Opérateurs relationnels</h2> - -<div class="note"> -<p><strong>Note :</strong> Chacun de ces opérateurs invoquera la fonction <code>valueOf()</code> des opérandes qui sont des objets avant d'effectuer la comparaison.</p> -</div> - -<h3 id="Supérieur_strict_>"><a>Supérieur strict (>)</a></h3> - -<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est strictement supérieur à l'opérande droit.</p> - -<h4 id="Syntaxe_5">Syntaxe</h4> - -<pre class="syntaxbox">x > y</pre> - -<h4 id="Exemples_5">Exemples</h4> - -<pre class="brush: js">4 > 3; // true -</pre> - -<h3 id="Supérieur_ou_égal_>"><a>Supérieur ou égal (>=)</a></h3> - -<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à l'opérande droit</p> - -<h4 id="Syntaxe_6">Syntaxe</h4> - -<pre class="syntaxbox"> x >= y</pre> - -<h4 id="Exemples_6">Exemples</h4> - -<pre class="brush: js">4 >= 3; // true -3 >= 3; // true -</pre> - -<h3 id="Inférieur_strict_<"><a>Inférieur strict (<)</a></h3> - -<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est strictement inférieur à l'opérande droit</p> - -<h4 id="Syntaxe_7">Syntaxe</h4> - -<pre class="syntaxbox"> x < y</pre> - -<h4 id="Exemples_7">Exemples</h4> - -<pre class="brush: js">3 < 4; // true -</pre> - -<h3 id="Inférieur_ou_égal_<"><a>Inférieur ou égal (<=)</a></h3> - -<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à l'opérande droit</p> - -<h4 id="Syntaxe_8">Syntaxe</h4> - -<pre class="syntaxbox"> x <= y</pre> - -<h4 id="Exemples_8">Exemples</h4> - -<pre class="brush: js">3 <= 4; // true -</pre> - -<h2 id="Utiliser_les_opérateurs_dégalité">Utiliser les opérateurs d'égalité</h2> - -<p>Les opérateurs d'égalité/inégalité faible (<code>==</code> et <code>!=</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">l'algorithme de comparaison d'égalité abstraite</a> 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 <code>5 == '5'</code>, la chaîne de droite est convertie en un nombre avant que la comparaison soit faite.</p> - -<p>Les opérateurs d'égalité/inégalité stricte (<code>===</code> et <code>!==</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">l'algorithme de comparaison d'égalité stricte</a>. Si les opérandes sont de types différents, le résultat sera toujours <code>false</code>, on aura donc <code>5 !== '5'</code>.</p> - -<p>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.</p> - -<p>Si un opérande doit être comparé à un autre type, le moteur effectuera une conversion de la façon suivante :</p> - -<ul> - <li>Lorsqu'une comparaison est opérée entre une chaîne de caractères et un nombre, Javascript tente de convertir la chaine en une valeur numérique. Une valeur mathématique est obtenue à partir de la chaîne littérale numérique, puis celle-ci est arrondie à une valeur de type Nombre.</li> - <li>Si l'un des opérandes est de type booléen, <code>true</code> sera converti en 1 et <code>false</code> en +0.</li> - <li>Si on compare un objet avec un nombre ou une chaîne, le moteur JavaScript tentera de renvoyer la valeur par défaut de l'objet. Les opérateurs opèrent une conversion grâce aux méthodes <code>valueOf</code> (pour obtenir un nombre) et <code>toString</code> (pour obtenir une chaîne de caractères). Si cela ne fonctionne pas, une exception sera levée.</li> - <li>Un objet sera converti en un type primitif autre uniquement si l'autre opérande est un type primitif (autre qu'objet). Si les deux opérandes sont des objets, ils seront comparés comme deux objets (voir ci-avant) et l'égalité ne sera vérifiée que si les opérandes font référence au même objet en mémoire</li> -</ul> - -<div class="note"> -<p><strong>Note :</strong> Voir également la page sur <a href="/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser">les différents tests d'égalité et quand les utiliser</a>.</p> -</div> - -<div class="note"><strong>Note :</strong> 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 :</div> - -<pre class="brush:js">// 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' </pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale. Implémentée avec JavaScript 1.0</td> - </tr> - <tr> - <td>{{SpecName('ES3')}}</td> - <td>{{Spec2('ES3')}}</td> - <td>Ajoute les opérateurs <code>===</code> et <code>!==</code>. Implémentés avec JavaScript 1.3</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.8')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.8">opérateurs relationnels</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9">opérateurs d'égalité</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-relational-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">opérateurs relationnels</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">opérateurs d'égalité</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://tc39.github.io/ecma262/#sec-relational-operators">opérateurs relationnels</a>, <a href="https://tc39.github.io/ecma262/#sec-equality-operators">opérateurs d'égalité</a></td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> - -<p>{{Compat("javascript.operators.comparison")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Object.is()")}}</li> - <li>{{jsxref("Math.sign()")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript">L'égalité en JavaScript</a></li> - <li><a href="/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser">Les différents tests d'égalité en JavaScript</a></li> -</ul> 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 ---- -<p> </p> -<h3 id="R.C3.A9sum.C3.A9" name="R.C3.A9sum.C3.A9">Résumé</h3> -<p>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 (<code>+</code>) permet d'assembler deux chaînes, en renvoyant une nouvelle chaîne étant l'union des deux opérandes chaînes. Par exemple, <code>"ma " + "chaîne"</code> renvoie la chaîne <code>"ma chaîne"</code>.</p> -<p>L'opérateur raccourci d'assignation <code>+=</code> peut également être utilisé pour concaténer des chaînes. Par exemple, si la variable <code>ma_chaine</code> a la valeur <code>"alpha"</code>, l'expression <code>ma_chaine += "bet"</code> sera évaluée à <code>"alphabet"</code> et assignera cette valeur à la variable <code>ma_chaine</code>.</p> -<table class="fullwidth-table"> - <tbody> - <tr> - <td class="header" colspan="2">Opérateur</td> - </tr> - <tr> - <td>Implémentation :</td> - <td>JavaScript 1.0</td> - </tr> - <tr> - <td>Version ECMA :</td> - <td>ECMA-262</td> - </tr> - </tbody> -</table> -<div class="noinclude"> - </div> -<p>{{ 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" } ) }}</p> 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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>Un <strong>opérateur d'affectation</strong> permet d'assigner une valeur à son opérande gauche en se basant sur la valeur de son opérande droit.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}</div> - -<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> - -<h2 id="Description">Description</h2> - -<p>L'opérateur utilisé pour l'affectation est le symbole égal (<code>=</code>), il permet d'affecter la valeur de l'opérande droit à son opérande gauche. Ainsi, quand on écrit <code>x = y</code>, on affecte la valeur de <code>y</code> à <code>x</code>. 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.</p> - -<table class="standard-table"> - <tbody> - <tr> - <th>Nom</th> - <th>Opérateur (raccourci)</th> - <th>Signification</th> - </tr> - <tr> - <td><a href="#Assignment">Affectation</a></td> - <td><code>x = y</code></td> - <td><code>x = y</code></td> - </tr> - <tr> - <td><a href="#Addition_assignment">Affectation après addition</a></td> - <td><code>x += y</code></td> - <td><code>x = x + y</code></td> - </tr> - <tr> - <td><a href="#Subtraction_assignment">Affectation après soustraction</a></td> - <td><code>x -= y</code></td> - <td><code>x = x - y</code></td> - </tr> - <tr> - <td><a href="#Multiplication_assignment">Affectation après multiplication</a></td> - <td><code>x *= y</code></td> - <td><code>x = x * y</code></td> - </tr> - <tr> - <td><a href="#Division_assignment">Affectation après division</a></td> - <td><code>x /= y</code></td> - <td><code>x = x / y</code></td> - </tr> - <tr> - <td><a href="#Remainder_assignment">Affectation du reste</a></td> - <td><code>x %= y</code></td> - <td><code>x = x % y</code></td> - </tr> - <tr> - <td><a href="#Exponentiation">Affectation après exponentiation</a></td> - <td><code>x **= y</code></td> - <td><code>x = x ** y</code></td> - </tr> - <tr> - <td><a href="#Left_shift_assignment">Affectation après décalage à gauche</a></td> - <td><code>x <<= y</code></td> - <td><code>x = x << y</code></td> - </tr> - <tr> - <td><a href="#Right_shift_assignment">Affectation après décalage à droite</a></td> - <td><code>x >>= y</code></td> - <td><code>x = x >> y</code></td> - </tr> - <tr> - <td><a href="#Unsigned_right_shift_assignment">Affectation après décalage à droite non-signé</a></td> - <td><code>x >>>= y</code></td> - <td><code>x = x >>> y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_AND_assignment">Affectation après ET binaire</a></td> - <td><code>x &= y</code></td> - <td><code>x = x & y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_XOR_assignment">Affectation après OU exclusif binaire</a></td> - <td><code>x ^= y</code></td> - <td><code>x = x ^ y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_OR_assignment">Affectation après OU binaire</a></td> - <td><code>x |= y</code></td> - <td><code>x = x | y</code></td> - </tr> - </tbody> -</table> - -<h2 id="Affectation"><a name="Assignment">Affectation</a></h2> - -<p>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.</p> - -<h4 id="Syntaxe">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x = y -</pre> - -<h4 id="Exemples">Exemples</h4> - -<pre class="brush: js">// 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 -</pre> - -<h3 id="Affectation_après_addition"><a name="Addition_assignment">Affectation après addition</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_2">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x += y -<strong>Signification :</strong> x = x + y -</pre> - -<h4 id="Exemples_2">Exemples</h4> - -<pre class="brush: js">// 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" -</pre> - -<h3 id="Affectation_après_soustraction"><a name="Subtraction_assignment">Affectation après soustraction</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_3">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x -= y -<strong>Signification :</strong> x = x - y -</pre> - -<h4 id="Exemples_3">Exemples</h4> - -<pre class="brush: js">// Si on a la variable suivante : -// truc = 5; - -truc -= 2; // 3 -truc -= "toto"; // NaN -</pre> - -<h3 id="Affectation_après_multiplication"><a name="Multiplication_assignment">Affectation après multiplication</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_4">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x *= y -<strong>Signification :</strong> x = x * y -</pre> - -<h4 id="Exemples_4">Exemples</h4> - -<pre class="brush: js">// Si on a la variable suivante : -// truc = 5; - -truc *= 2; // 10 -truc *= "toto"; // NaN -</pre> - -<h3 id="Affectation_après_division"><a name="Division_assignment">Affectation après division</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_5">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x /= y -<strong>Signification :</strong> x = x / y -</pre> - -<h4 id="Exemples_5">Exemples</h4> - -<pre class="brush: js">// Si on a la variable suivante : -// truc = 5; - -truc /= 2; // 2.5 -truc /= "toto"; // NaN -truc /= 0; // Infinity -</pre> - -<h3 id="Affectation_du_reste"><a name="Remainder_assignment">Affectation du reste</a></h3> - -<p>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)}}.</p> - -<h4 id="Syntaxe_6">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x %= y -<strong>Signification :</strong> x = x % y -</pre> - -<h4 id="Exemples_6">Exemples</h4> - -<pre class="brush: js">// Si on a la variable suivante : -// truc = 5; - -truc %= 2; // 1 -truc %= "toto"; // NaN -truc %= 0; // NaN -</pre> - -<h3 id="Affectation_après_exponentiation"><a id="Exponentiation" name="Exponentiation">Affectation après exponentiation</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_7">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x **= y -<strong>Signification :</strong> x = x ** y -</pre> - -<h4 id="Exemples_7">Exemples</h4> - -<pre class="brush: js">// Si on a la variable : -// toto = 5 - -toto **= 2 // 25 -toto **= "truc" // NaN</pre> - -<h3 id="Affectation_après_décalage_à_gauche"><a name="Left_shift_assignment">Affectation après décalage à gauche</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_8">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x <<= y -<strong>Signification :</strong> x = x << y -</pre> - -<h4 id="Exemples_8">Exemples</h4> - -<pre class="brush: js">var toto = 5; // (00000000000000000000000000000101) -toto <<= 2; // 20 (00000000000000000000000000010100) -</pre> - -<h3 id="Affectation_après_décalage_à_droite"><a name="Right_shift_assignment">Affectation après décalage à droite</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_9">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x >>= y -<strong>Signification :</strong> x = x >> y -</pre> - -<h4 id="Exemples_9">Exemples</h4> - -<pre class="brush: js">var toto = 5; // (00000000000000000000000000000101) -toto >>= 2; // 1 (00000000000000000000000000000001) - -var toto -5; // (-00000000000000000000000000000101) -toto >>= 2; // -2 (-00000000000000000000000000000010) -</pre> - -<h3 id="Affectation_après_décalage_à_droite_non-signé"><a name="Unsigned_right_shift_assignment">Affectation après décalage à droite non-signé</a></h3> - -<p>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.</p> - -<h4 id="Syntaxe_10">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x >>>= y -<strong>Signification :</strong> x = x >>> y -</pre> - -<h4 id="Exemples_10">Exemples</h4> - -<pre class="brush: js">var toto = 5; // (00000000000000000000000000000101) -toto >>>= 2; // 1 (00000000000000000000000000000001) - -var toto = -5; // (-00000000000000000000000000000101) -toto >>>= 2; // 1073741822 (00111111111111111111111111111110)</pre> - -<h3 id="Affectation_après_ET_binaire"><a name="Bitwise_AND_assignment">Affectation après ET binaire</a></h3> - -<p>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)}}.</p> - -<h4 id="Syntaxe_11">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x &= y -<strong>Signification :</strong> x = x & y -</pre> - -<h4 id="Exemple">Exemple</h4> - -<pre class="brush: js">var truc = 5; -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -truc &= 2; // 0 -</pre> - -<h3 id="Affectation_après_OU_exclusif_(XOR)_binaire"><a name="Bitwise_XOR_assignment">Affectation après OU exclusif (<em>XOR</em>) binaire</a></h3> - -<p>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)}}.</p> - -<h4 id="Syntaxe_12">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x ^= y -<strong>Signification :</strong> x = x ^ y -</pre> - -<h4 id="Exemple_2">Exemple</h4> - -<pre class="brush: js">var toto = 5; -toto ^= 2; // 7 -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -// ----------------------------------- -// 7: 00000000000000000000000000000111 -</pre> - -<h3 id="Affectation_après_OU_binaire"><a name="Bitwise_OR_assignment">Affectation après OU binaire</a></h3> - -<p>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)}}.</p> - -<h4 id="Syntaxe_13">Syntaxe</h4> - -<pre class="syntaxbox"><strong>Opérateur :</strong> x |= y -<strong>Signification :</strong> x = x | y -</pre> - -<h4 id="Exemple_3">Exemple</h4> - -<pre class="brush: js">var toto = 5; -toto |= 2; // 7 -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -// ----------------------------------- -// 7: 00000000000000000000000000000111 -</pre> - -<h2 id="Exemples_11">Exemples</h2> - -<h3 id="Opérande_gauche_utilisé_avec_un_autre_opérateur_d'affectation">Opérande gauche utilisé avec un autre opérateur d'affectation</h3> - -<p>Dans certains cas, l'opérateur d'affectation (par exemple<code> x += y</code>) n'est pas identique à l'expression développée correspondante (respectivement <code>x = x + y</code>). 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 :</p> - -<pre class="brush: js">a[i++] += 5 // i est évalué une fois -a[i++] = a[i++] + 5 // i est évalué deux fois -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> - -<p>{{Compat("javascript.operators.assignment")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques">Les opérateurs arithmétiques</a></li> -</ul> 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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>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.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div> - -<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> - -<p>Le tableau qui suit résume les opérateurs binaires de JavaScript :</p> - -<table class="standard-table"> - <tbody> - <tr> - <th>Opérateur</th> - <th>Utilisation</th> - <th>Description</th> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(ET_binaire)">ET binaire</a></td> - <td><code>a & b</code></td> - <td> - <p>Renvoie un <code>1</code> pour chaque position de bit pour laquelle les bits correspondants des deux opérandes sont des <code>1</code>.</p> - </td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(OU_binaire)">OU binaire</a></td> - <td><code>a | b</code></td> - <td>Renvoie un <code>1</code> pour chaque position de bit pour laquelle le bit correspondant d'au moins un des deux opérandes est un <code>1</code> .</td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(XOR_binaire)">OU exclusif binaire (<em>XOR</em>)</a></td> - <td><code>a ^ b</code></td> - <td>Renvoie un <code>1</code> pour chaque position de bit pour laquelle le bit correspondant d'un seul des deux opérandes est un <code>1</code>.</td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(NON_binaire)">NON binaire</a></td> - <td><code>~ a</code></td> - <td>Inverse les bits de son opérande.</td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#<<_(décalage_à_gauche)">Décalage à gauche</a></td> - <td><code>a << b</code></td> - <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la gauche, en introduisant des zéros par la droite.</td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>_(décalage_à_droite_avec_propagation_du_signe)">Décalage à droite avec propagation du signe</a></td> - <td><code>a >> b</code></td> - <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la droite, en rejetant les bits à droite.</td> - </tr> - <tr> - <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>>_(décalage_à_droite_avec_insertion_de_zéros)">Décalage à droite avec introduction de zéros</a></td> - <td><code>a >>> b</code></td> - <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la droite, en rejetant les bits à droite et en introduisant des zéros par la gauche.</td> - </tr> - </tbody> -</table> - -<h2 id="Entiers_sur_32_bits_signés">Entiers sur 32 bits signés</h2> - -<p>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 <a href="https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux">complément à deux</a> (à 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) :</p> - -<pre class="eval">00000000000000000000000100111010 -</pre> - -<p>La représentation suivante encode ~314, c'est-à-dire le complément à un de 314 :</p> - -<pre class="eval">11111111111111111111111011000101 -</pre> - -<p>Finalement, la représentation suivante encode -314, c'est-à-dire le complément à deux de 314 :</p> - -<pre class="eval">11111111111111111111111011000110 -</pre> - -<p>Le complément à deux garantit que le bit le plus à gauche soit 0 lorsque le nombre est positif, et <code>1</code> lorsque le nombre est négatif. C'est pourquoi on l'appelle le <em>bit de signe</em> .</p> - -<p>Le nombre 0 est l'entier constitué intégralement de bits à <code>0</code> .</p> - -<pre>0 (base 10) = 00000000000000000000000000000000 (base 2)</pre> - -<p>Le nombre -1 est l'entier constitué intégralement de bits à <code>1</code> .</p> - -<pre>-1 (base 10) = 11111111111111111111111111111111 (base 2)</pre> - -<p>Le nombre <code>-2147483648</code> (qui correspond à <code>-0x80000000</code> en notation hexadécimale) est l'entier uniquement composé de 0, à l'exception du premier bit (le plus à gauche) qui vaut 1.</p> - -<pre>-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)</pre> - -<p>Le nombre <code>2147483647</code> (qui correspond à <code>0x7fffffff</code> en notation hexadécimale) est l'entier uniquement composé de 1, à l'exception du premier bit (le plus à gauche) qui vaut 0.</p> - -<pre>2147483647 (base 10) = 01111111111111111111111111111111 (base 2)</pre> - -<p>Les nombres <code>-2147483648</code> et <code>2147483647</code> sont respectivement le nombre le plus petit et le plus grand qu'on peut représenter sur 32 bits (signés).</p> - -<h2 id="Opérateurs_logiques_binaires">Opérateurs logiques binaires</h2> - -<p>Conceptuellement, les opérateurs logiques binaires fonctionnent de la manière suivante :</p> - -<ul> - <li>Les opérandes sont convertis en entiers sur 32 bits et exprimés sous la forme d'une série de bits (des 1 et des 0). Les nombres sur plus de 32 bits voient leurs bits supplémentaires supprimés : - <pre class="brush: js">Avant : 11100110111110100000000000000110000000000001 -Après : 10100000000000000110000000000001</pre> - </li> - <li>Chaque bit du premier opérande est combiné avec le bit correspondant du second opérande : le premier bit avec le premier bit, le second bit avec le second bit, et ainsi de suite.</li> - <li>L'opérateur est appliqué à chaque paire de bits, et le résultat est construit bit après bit.</li> -</ul> - -<h3 id="(ET_binaire)"><a name="ET">& (ET binaire)</a></h3> - -<p>Effectue l'opération ET (<em>AND</em>) sur chaque paire de bits. <code>a</code> ET <code>b</code> donne 1 uniquement si à la fois <code>a</code> et <code>b</code> sont <code>1</code> . La table de vérité pour l'opération ET est :</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a ET b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="eval"> 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) -</pre> - -<p>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.</p> - -<h3 id="(OU_binaire)"><a name="OU">| (OU binaire)</a></h3> - -<p>Effectue l'opération OU (<em>OR</em>) sur chaque paire de bits. <code>a</code> OU <code>b</code> donne <code>1</code> si <code>a</code> ou <code>b</code> vaut 1. La table de vérité pour l'opération OU est :</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a OU b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="eval"> 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) -</pre> - -<p>Utiliser le OU binaire avec n'importe quel nombre x et 0 donne x. Utiliser le OU binaire avec n'importe quel nombre x et -1 donne -1.</p> - -<h3 id="(XOR_binaire)"><a name="XOR">^ (XOR binaire)</a></h3> - -<p>Effectue l'opération XOR (OU exclusif) sur chaque paire de bits. <code>a</code> XOR <code>b</code> donne <code>1</code> si <code>a</code> et <code>b</code> sont différents. La table de vérité pour l'opération XOR est :</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a XOR b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="eval"> 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) -</pre> - -<p>Utiliser le 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.</p> - -<h3 id="(NON_binaire)"><a name="NON">~ (NON binaire)</a></h3> - -<p>Effectue l'opération NON (<em>NOT</em>) sur chaque bit. NON <code>a</code> donne la valeur inversée (c'est-à-dire le complément à un) de <code>a</code>. La table de vérité de l'opération NON est :</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">NON a</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="eval"> 9 (base 10) = 00000000000000000000000000001001 (base 2) - -------------------------------- -~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) -</pre> - -<p>Utiliser le NON binaire avec n'importe quel nombre <code>x</code> donne <code>-(x + 1)</code>. Par exemple, <code>~-5</code> donne <code>4</code>.</p> - -<p>Étant donnée la représentation sur 32 bits des nombres en JavaScript, on a <code>~-1</code> et <code>~4294967295</code> (2<sup>32</sup>-1) qui valent tous les deux <code>0</code>.</p> - -<h2 id="Opérateurs_de_décalage_binaire">Opérateurs de décalage binaire</h2> - -<p>Les opérateurs de décalage binaire (<em>shift</em>) 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é.</p> - -<p>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.</p> - -<h3 id="<<_(décalage_à_gauche)"><a name="Gauche"><< (décalage à gauche)</a></h3> - -<p>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.</p> - -<p>Par exemple, <code>9 << 2</code> donne 36 :</p> - -<pre class="eval"> 9 (base 10) : 00000000000000000000000000001001 (base 2) - -------------------------------- -9 << 2 (base 10) : 00000000000000000000000000100100 (base 2) = 36 (base 10) -</pre> - -<p>Décaler un nombre <strong>x</strong> de <strong>y</strong> bits vers la gauche renverra <math><semantics><mrow><mi>x</mi><mo>*</mo><msup><mn>2</mn><mi>y</mi></msup></mrow><annotation encoding="TeX">x*2^y</annotation></semantics></math>. Par exemple, <code>9 << 3</code> correspondra à <code>9 * (2 ** 3) = 9 * 8 = 72</code>.</p> - -<h3 id=">>_(décalage_à_droite_avec_propagation_du_signe)"><a name="Droite">>> (décalage à droite avec propagation du signe)</a></h3> - -<p>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 ».</p> - -<p>Par exemple, <code>9 >> 2</code> donne 2 :</p> - -<pre class="eval"> 9 (base 10) : 00000000000000000000000000001001 (base 2) - -------------------------------- -9 >> 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10) -</pre> - -<p>De même, <code>-9 >> 2</code> donne -3, parce que le signe est préservé :</p> - -<pre class="eval"> -9 (base 10) : 11111111111111111111111111110111 (base 2) - -------------------------------- --9 >> 2 (base 10) : 11111111111111111111111111111101 (base 2) = -3 (base 10) -</pre> - -<h3 id=">>>_(décalage_à_droite_avec_insertion_de_zéros)"><a name="Droite_zero">>>> (décalage à droite avec insertion de zéros)</a></h3> - -<p>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.</p> - -<p>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, <code>9 >>> 2</code> donne 2, tout comme <code>9 >> 2</code> :</p> - -<pre class="eval"> 9 (base 10) : 00000000000000000000000000001001 (base 2) - -------------------------------- -9 >>> 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10) -</pre> - -<p>Cependant, ce n'est pas le cas des nombres négatifs. Par exemple, <code>-9 >>> 2</code> donne 1073741821, ce qui est différent de <code>-9 >> 2</code> (qui donne -3) :</p> - -<pre class="eval"> -9 (base 10) : 11111111111111111111111111110111 (base 2) - -------------------------------- --9 >>> 2 (base 10) : 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) -</pre> - -<h2 id="Exemples">Exemples</h2> - -<h3 id="Exemple_flags_et_bitmasks">Exemple : <em>flags</em> et <em>bitmasks</em></h3> - -<p>Les opérateurs logiques binaires sont souvent utilisés pour créer, manipuler et lire des séquences de<em>flags</em> , 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).</p> - -<p>Supposons que l'on ait 4 flags :</p> - -<ul> - <li>flag A : nous avons une araignée</li> - <li>flag B : nous avons une belette</li> - <li>flag C : nous avons un chat</li> - <li>flag D : nous avons un dinosaure</li> -</ul> - -<p>Ces flags sont représentés par une séquence de bits : DCBA. Lorsqu'un flag est <em>positionné</em>, il a une valeur de 1. Sinon, il a une valeur de 0. Supposons qu'une variable <code>flags</code> a la valeur binaire de 0101 :</p> - -<pre class="eval">var flags = 0x5; // 0101 en binaire -</pre> - -<p>Cette valeur indique :</p> - -<ul> - <li>le flag A est vrai (nous avons une araignée) ;</li> - <li>le flag B est faux (nous n'avons pas de belette) ;</li> - <li>le flag C est vrai (nous avons un chat) ;</li> - <li>le flag D est faux (nous n'avons pas de dinosaure).</li> -</ul> - -<p>Comme les opérateurs binaires sont sur 32 bits, <code>0101</code> est en fait <code>00000000000000000000000000000101</code>, mais les zéros qui précèdent peuvent être négligés étant donné qu'ils ne contiennent aucune information significative.</p> - -<p>Un <em>bitmask</em> est une séquence de bits qui peuvent manipuler et/ou lire des flags. Typiquement, un masque « primitif » pour chaque flag est défini :</p> - -<pre class="eval">var FLAG_A = 0x1; // 0001 -var FLAG_B = 0x2; // 0010 -var FLAG_C = 0x4; // 0100 -var FLAG_D = 0x8; // 1000 -</pre> - -<p>De nouveaux masques peuvent être créés à l'aide des opérateurs logiques binaires sur ces masques primitifs. Par exemple, le masque <code>1011</code> peut être créé avec une opération OU sur <code>FLAG_A</code>, <code>FLAG_B</code> et <code>FLAG_D</code> :</p> - -<pre class="eval">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 -</pre> - -<p>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 <em>masque</em> 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é :</p> - -<pre class="eval">// si l'on a un chat -if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true - // faire quelque chose -} -</pre> - -<p>Un masque avec plusieurs flags positionnés agit comme un « et/ou ». Par exemple, les deux instructions suivantes sont équivalentes :</p> - -<pre class="eval">// 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 -} -</pre> - -<pre class="eval">// 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 -} -</pre> - -<p>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 :</p> - -<pre class="eval">// oui, on a un chat et un dinosaure -var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100 -flags |= mask; // 0101 | 1100 => 1101 -</pre> - -<p>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 :</p> - -<pre class="eval">// non, nous n'avons pas d'araignée ou de chat -var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010 -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>Le masque aurait également pu être créé avec <code>~FLAG_A & ~FLAG_C</code> (Loi de De Morgan) :</p> - -<pre class="eval">// non, nous n'avons pas d'araignée ou de chat -var mask = ~FLAG_A & ~FLAG_C; -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>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 :</p> - -<pre class="eval">// 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 -</pre> - -<p>Finalement, les flags peuvent être tous inversés avec l'opérateur NON :</p> - -<pre class="eval">// entrée dans un univers parallèle... -flags = ~flags; // ~1010 => 0101 -</pre> - -<h3 id="Codes_de_conversion">Codes de conversion</h3> - -<p>Pour convertir une <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String">String</a></code> binaire en un <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number">Number</a></code> (en base 10):</p> - -<pre class="brush: js">var chaîneBinaire = "1011"; -var monNombre = parseInt(chaîneBinaire, 2); -console.log(monNombre); // affiche 11 (1011 en base 2) -</pre> - -<p>Pour convertir un <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number">Number</a></code> (en base 10) en une <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String">String</a></code> binaire :</p> - -<pre class="brush: js">var monNombre = 11; -var chaîneBinaire = monNombre.toString(2); -console.log(chaîneBinaire); // affiche 1011 (11 en base 10) -</pre> - -<h3 id="Automatiser_la_création_d'un_masque">Automatiser la création d'un masque</h3> - -<p>Si vous devez créer plusieurs masques à partir de booléens, il est possible d'automatiser ce processus :</p> - -<pre class="brush: js">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 -</pre> - -<h3 id="Algorithme_réciproque_obtenir_un_tableau_de_booléen_à_partir_d'un_masque">Algorithme réciproque : obtenir un tableau de booléen à partir d'un masque</h3> - -<p>Si on souhaite créer un tableau de booléens à partir d'un masque, on pourra utiliser le code suivant :</p> - -<pre class="brush: js">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 -</pre> - -<p>On peut ainsi utiliser les deux algorithmes :</p> - -<pre class="brush: js">var test = 19; // un masque quelconque -var résultat = créerMasque.apply(this, tableauMasque(test)); - -console.log(résultat); // 19 -</pre> - -<p>Pour l'exemple (car il existe la méthode <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toString">Number.toString(2)</a></code>), on peut également modifier l'algorithme précédent pour créer une chaîne à partir de la représentation binaire d'un nombre :</p> - -<pre class="brush: js">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 -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">Statut</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.7')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Définis au sein de plusieurs sections de la spécification : <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Opérateur NON binaire</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Opérateurs binaires de décalage</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Opérateurs binaires</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Définis au sein de plusieurs sections de la spécification : <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Opérateur NON binaire</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Opérateurs binaires de décalage</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Opérateurs binaires</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">opérateur NON binaire</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">opérateurs binaires de décalage</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">opérateurs binaires</a></td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> - -<p>{{Compat("javascript.operators.bitwise")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques">Les opérateurs logiques</a></li> -</ul> 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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>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 <code>&&</code> et <code>||</code> 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.</p> - -<p>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</p> - -<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> - -<h2 id="Description">Description</h2> - -<p>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) :</p> - -<table class="fullwidth-table"> - <tbody> - <tr> - <th>Opérateur</th> - <th>Usage</th> - <th>Description</th> - </tr> - <tr> - <td>ET logique (<code>&&</code>)</td> - <td><code><em>expr1</em> &&<em>expr2</em> </code></td> - <td>Renvoie <code>expr1</code> si cette expression peut être convertie en <code>false</code>, sinon renvoie <code>expr2</code>.</td> - </tr> - <tr> - <td>OU logique (<code>||</code>)</td> - <td><code><em>expr1</em> ||<em>expr2</em> </code></td> - <td>Renvoie <code>expr1</code> si cette expression peut être convertie en <code>true</code>, sinon renvoie <code>expr2</code>.</td> - </tr> - <tr> - <td>NON logique (<code>!</code>)</td> - <td><code>!<em>expr</em> </code></td> - <td>Renvoie <code>false</code> si son opérande unique peut être converti en <code>true</code>, sinon il renvoie <code>true</code>.</td> - </tr> - </tbody> -</table> - -<p>Si une valeur peut être convertie en <code>true</code>, on dit en anglais qu'elle est <em>truthy</em>. Pour <code>false</code> on dit qu'elle est <em>falsy</em>.</p> - -<p>Parmi les expressions qui peuvent être converties en <code>false</code>, citons celles qui seront évaluées à :</p> - -<ul> - <li><code>null</code>,</li> - <li><code>NaN</code>,</li> - <li><code>0</code>,</li> - <li>la chaîne vide (<code>""</code> ou <code>''</code> ou <code>``</code>),</li> - <li><code>undefined</code>.</li> -</ul> - -<p>Même si les opérateurs <code>&&</code> et <code>||</code> 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.</p> - -<h3 id="Évaluation_court-circuit">Évaluation court-circuit</h3> - -<p>Comme les expressions logiques sont évaluées de gauche à droite, leur évaluation sera éventuellement « court-circuitée » à l'aide des règles suivantes :</p> - -<ul> - <li>l'évaluation de <code>false &&<em> n'importe quoi</em> </code> est court-circuitée en <code>false</code>.</li> - <li>l'évaluation de <code>true ||<em> n'importe quoi</em> </code> est court-circuitée en <code>true</code>.</li> -</ul> - -<p>Les règles de la logique garantissent que ces évaluations seront toujours correctes. Notons que la partie<em>n'importe quoi</em> 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.</p> - -<p>Ainsi, les deux fonctions suivantes sont équivalentes :</p> - -<pre>function courtCircuit() { - // OU logique - faireQuelqueChose() || faireAutreChose(); - - faireQuelqueChose() && faireAutreChose(); -} - -function évaluationÉquivalente() { - var orFlag = faireQuelqueChose(); - if (!orFlag) { - faireAutreChose(); - } - - var andFlag = faireQuelqueChose(); - if (andFlag) { - faireAutreChose(); - } -} -</pre> - -<h3 id="Précédence_des_opérateurs">Précédence des opérateurs</h3> - -<p>Les expressions suivantes ne sont pas équivalentes en raison de <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Précédence_des_opérateurs">la précédence des opérateurs</a>. Cela permet de noter que l'opérande droit ne doit être qu'une seule expression (si nécessaire entourée de parenthèses).</p> - -<pre>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</pre> - -<h3 id="ET_logique"><a name="Logical_AND">ET logique (<code>&&</code>)</a></h3> - -<p>Le code qui suit illustre comment utiliser l'opérateur <code>&&</code> (ET logique).</p> - -<pre>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 -</pre> - -<h3 id="OU_logique"><a name="Logical_OR">OU logique (<code>||</code>)</a></h3> - -<p>Le code qui suit illustre quelques exemples d'utilisation de l'opérateur <code>||</code> (OU logique).</p> - -<pre>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 -</pre> - -<h3 id="NON_logique!"><a name="Logical_NOT">NON logique(<code>!</code>)</a></h3> - -<p>Le code qui suit illustre quelques exemples d'utilisation de l'opérateur <code>!</code> (NON logique).</p> - -<pre>n1 = !true // !t renvoie false -n2 = !false // !f renvoie true -n3 = !"" // !f renvoie true -n3 = !"Yop" // !t renvoie false -</pre> - -<h4 id="Utilisation_de_la_double_négation">Utilisation de la double négation</h4> - -<p>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 <code>true</code> si la valeur est équivalente à vrai et <code>false</code> si la valeur est équivalente à faux. Cette opération de conversion peut également être réalisée grâce à la fonction {{jsxref("Boolean")}}.</p> - -<pre class="brush: js">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</pre> - -<h3 id="Règles_de_conversions">Règles de conversions</h3> - -<h4 id="Convertir_un_ET_logique_avec_des_OU_logiques">Convertir un ET logique avec des OU logiques</h4> - -<p>L'opération suivante</p> - -<pre>condition1 && condition2</pre> - -<p>sera toujours égale à :</p> - -<pre>!(!condition1 || !condition2)</pre> - -<h4 id="Convertir_un_OU_logique_avec_des_ET_logiques">Convertir un OU logique avec des ET logiques</h4> - -<p>L'opération suivante :</p> - -<pre>condition1 || condition2</pre> - -<p>sera toujours égale à :</p> - -<pre>!(!condition1 && !condition2)</pre> - -<h4 id="Convertir_des_NON_logiques_successifs">Convertir des NON logiques successifs</h4> - -<p>Si on a l'opération suivante avec un booléen :</p> - -<pre>!!condition -</pre> - -<p>elle sera toujours équivalente à</p> - -<pre>condition</pre> - -<h3 id="Retirer_les_parenthèses_imbriquées">Retirer les parenthèses imbriquées</h3> - -<p>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.</p> - -<h4 id="Retirer_les_parenthèses_dun_ET_imbriqué">Retirer les parenthèses d'un ET imbriqué</h4> - -<p>Cette opération :</p> - -<pre>condition1 || (condition2 && condition3)</pre> - -<p>sera toujours équivalente à :</p> - -<pre>condition1 || condition2 && condition3</pre> - -<h4 id="Retirer_les_parenthèses_dun_OU_imbriqué">Retirer les parenthèses d'un OU imbriqué</h4> - -<p>Cette opération :</p> - -<pre>condition1 && (condition2 || condition3)</pre> - -<p>sera toujours équivalente à :</p> - -<pre>!(!condition1 || !condition2 && !condition3)</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.11')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">opérateur NON logique</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.11">opérateurs logiques binaires</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">opérateur NON logique</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">opérateurs logiques binaires</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définis dans plusieurs sections de la spécification : <a href="https://tc39.github.io/ecma262/#sec-logical-not-operator">opérateur NON logique</a>, <a href="https://tc39.github.io/ecma262/#sec-binary-logical-operators">opérateurs logiques binaires</a></td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> - -<p>{{Compat("javascript.operators.logical")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires">Les opérateurs binaires</a></li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_littéraux_booléens">Le type primitif booléen</a></li> - <li>Le constructeur objet {{jsxref("Boolean")}}</li> -</ul> diff --git a/files/fr/web/javascript/reference/operators/addition/index.html b/files/fr/web/javascript/reference/operators/addition/index.html index af5fb528e0..e67da71cd6 100644 --- a/files/fr/web/javascript/reference/operators/addition/index.html +++ b/files/fr/web/javascript/reference/operators/addition/index.html @@ -7,76 +7,64 @@ tags: - Reference translation_of: Web/JavaScript/Reference/Operators/Addition original_slug: Web/JavaScript/Reference/Opérateurs/Addition +browser-compat: javascript.operators.addition --- <div>{{jsSidebar("Operators")}}</div> -<div>L'opérateur d'addition (<code>+</code>) effectue la somme de deux opérandes numériques ou la concaténation de chaînes de <span class="ver" title="">caractères</span>.</div> - - +<p>L'opérateur d'addition (<code>+</code>) produit la somme de deux opérandes numériques ou la concaténation de deux chaînes de caractères.</p> <div>{{EmbedInteractiveExample("pages/js/expressions-addition.html")}}</div> -<div></div> - -<p class="hidden">La source de cet exemple interactif est stockée dans un référentiel GitHub. Si vous souhaitez contribuer au projet d'exemples interactifs, veuillez cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et envoyez-nous une pull request.</p> - -<h2 id="Syntaxe">Syntaxe</h2> +<h2 id="syntaxe">Syntaxe</h2> -<pre class="syntaxbox notranslate"><strong>Opérateur:</strong> <var>x</var> + <var>y</var> +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var> + <var>y</var> </pre> -<h2 id="Exemples">Exemples</h2> +<h2 id="examples">Exemples</h2> -<h3 id="Addition_numérique">Addition numérique</h3> +<h3 id="numeric_addition">Addition numérique</h3> -<pre class="brush: js notranslate">// Nombre + Nombre -> addition +<pre class="brush: js"> +// 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 </pre> -<h3 id="Concaténation_de_chaînes">Concaténation de chaînes</h3> +<h3 id="string_concatenation">Concaténation de chaînes de caractères</h3> -<pre class="brush: js notranslate">// String + String -> concatenation -'foo' + 'bar' // "foobar" +<pre class="brush: js">// String + String -> concatenation +'toto' + 'truc' // "tototruc" // Number + String -> concatenation -5 + 'foo' // "5foo" +5 + 'toto' // "5toto" // String + Boolean -> concatenation -'foo' + false // "foofalse"</pre> +'toto' + false // "totofalse"</pre> -<h2 id="Spécifications">Spécifications</h2> +<h2 id="specifications">Spécifications</h2> -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-addition-operator-plus', 'Addition operator')}}</td> - </tr> - </tbody> -</table> +<p>{{Specifications}}</p> -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> -<p>{{Compat("javascript.operators.addition")}}</p> +<p>{{Compat}}</p> -<h2 id="Voir_aussi">Voir aussi</h2> +<h2 id="see_also">Voir aussi</h2> <ul> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur reste</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> - <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur unaire plus</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> </ul> diff --git a/files/fr/web/javascript/reference/operators/addition_assignment/index.html b/files/fr/web/javascript/reference/operators/addition_assignment/index.html index 6648df2a7f..c0a2136c3d 100644 --- a/files/fr/web/javascript/reference/operators/addition_assignment/index.html +++ b/files/fr/web/javascript/reference/operators/addition_assignment/index.html @@ -1,59 +1,66 @@ --- -title: Addition avec assignement (+=) +title: Affectation après addition (+=) slug: Web/JavaScript/Reference/Operators/Addition_assignment tags: - - Fonctionnalité du language - - JavaScript - - Opérateur - - Opérateur d'assignement - - Reference -translation_of: Web/JavaScript/Reference/Operators/Addition_assignment -original_slug: Web/JavaScript/Reference/Opérateurs/Addition_avec_assignement +- Assignment operator +- JavaScript +- Language feature +- Operator +- Reference +translation-of: Web/JavaScript/Reference/Operators/Addition_assignment +browser-compat: javascript.operators.addition_assignment --- -<p>{{jsSidebar("Operators")}}</p> +<div>{{jsSidebar("Operators")}}</div> -<p>L'opérateur d'addition avec assignement (<code>+=</code>) permet d'ajouter une valeur à une variable. Le type des deux valeurs permet de définir si l'utilisation de cet opérateur les concatènera ou les additionnera.</p> +<p>L'opérateur d'addition et d'affectation (<code>+=</code>) calcule la somme ou la concaténation de ses deux opérandes puis affecte le résultat à la variable représentée par l'opérande gauche. C'est le type des opérandes qui détermine s'il y a somme ou concaténation.</p> <div>{{EmbedInteractiveExample("pages/js/expressions-addition-assignment.html")}}</div> -<div></div> +<h2 id="syntax">Syntax</h2> -<p class="hidden">La source de cet exemple interactif est stocké sur GitHub. Si vous voulez contribuer au projet de l'exemple interactif, merci de cloner ceci : <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et nous envoyer une "pull-request".</p> +<pre class="brush: js"> +<strong>Opérateur :</strong> x += y +<strong>Signification :</strong> x = x + y +</pre> -<h2 id="Syntaxe">Syntaxe</h2> +<h2 id="examples">Exemples</h2> -<pre class="notranslate"><strong>Opérateur :</strong> x += y -<strong>Signifie :</strong> x = x + y</pre> +<h3 id="using_addition_assignment">Utiliser l'opérateur d'addition et d'affectation</h3> -<h2 id="Examples">Examples</h2> +<pre class="brush: js"> +let toto = "toto"; +let truc = 5; +let machin = true; -<h3 id="Utilisation_de_lopérateur">Utilisation de l'opérateur</h3> +// nombre + nombre -> addition +truc += 2; // 7 -<pre class="brush: js notranslate">// On considère les variables suivantes : -var chaine = "Hello"; -var nombre = 5; -var booleen = true; +// booléen + nombre -> 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"</pre> -// Chaîne + Booléen -chaine += false; -// "Hellofalse" +<h2 id="specifications">Spécifications</h2> -// Chaîne + Chaîne -chaine += "World" -// "HelloWorld"</pre> +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">L'opérateur d'addition/concaténation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_and/index.html b/files/fr/web/javascript/reference/operators/bitwise_and/index.html new file mode 100644 index 0000000000..b1a3ca024b --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_and/index.html @@ -0,0 +1,102 @@ +--- +title: ET binaire (&) +slug: Web/JavaScript/Reference/Operators/Bitwise_AND +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_and +translation-of: Web/JavaScript/Reference/Operators/Bitwise_AND +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur ET binaire (<code>&</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où les bits des deux opérandes valent <code>1</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-and.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> & <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une séquence de bits. Les nombres sur plus de 32 bits ont leurs bits en excès écartés. Par exemple, l'entier suivant nécessite plus de 32 bits pour être représenté et il sera converti en un entier sur 32 bits :</p> + +<pre class="brush: js"> +Avant: 11100110111110100000000000000110000000000001 +Après: 10100000000000000110000000000001 +</pre> + +<p>Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsque les deux valent 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.</p> + +<p>La table de vérité pour l'opérateur ET est :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">a</th> + <th class="header" scope="col">b</th> + <th class="header" scope="col">a ET b</th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre class="brush: js"> + 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) +</pre> + +<p>Utiliser un ET binaire sur n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> d'autre part renverra <code>0</code>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_and">Utiliser l'opérateur ET binaire</h3> + +<pre class="brush: js"> +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +5 & 2; // 0 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html new file mode 100644 index 0000000000..3300032225 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_and_assignment/index.html @@ -0,0 +1,50 @@ +--- +title: Affectation après ET binaire (&=) +slug: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_and_assignment +translation-of: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après ET binaire (<code>&=</code>) utilise la représentation binaire des deux opérandes, applique un ET logique entre chaque puis affecte le résultat de l'opération à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-and-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x &= y +<strong>Signification :</strong> x = x & y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_and_assignment">Utiliser l'affectation après ET binaire</h3> + +<pre class="brush: js"> +let a = 5; +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +a &= 2; // 0 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND">L'opérateur ET binaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_not/index.html b/files/fr/web/javascript/reference/operators/bitwise_not/index.html new file mode 100644 index 0000000000..f3e1856a90 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_not/index.html @@ -0,0 +1,90 @@ +--- +title: NON binaire (~) +slug: Web/JavaScript/Reference/Operators/Bitwise_NOT +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_not +translation_of: Web/JavaScript/Reference/Operators/Bitwise_NOT +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur binaire NON (<code>~</code>) prend l'opposé de chaque bit de son opérande et fournit la valeur ainsi obtenue. À l'instar des autres opérateurs binaires, il convertit son opérande en un entier signé sur 32 bits.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-not.html")}}</div> + +<h2 id="syntaxe">Syntaxe</h2> + +<pre class="brush: js"> +~a +</pre> + +<h2 id="description">Description</h2> + +<p>L'opérande est converti en un entier signé sur 32 bits. Les nombres avec plus de 32 bits voient leurs bits les plus significatifs être tronqués. Voici un exemple où l'entier qui suit est supérieur à une valeur pouvant être exprimée sur 32 bits : la conversion écrête la valeur pour obtenir un entier signé sur 32 bits :</p> + +<pre class="brush: js"> +Avant : 11100110111110100000000000000110000000000001 +Après : 10100000000000000110000000000001 +</pre> + +<p>Pour former le résultat, chaque bit qui compose l'opérande est inversé.</p> + +<p>La table de vérité pour l'opération <code>NON</code> est :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">a</th> + <th class="header" scope="col">NON a</th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre class="brush: js"> + 9 (base 10) = 00000000000000000000000000001001 (base 2) + -------------------------------- +~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) +</pre> + +<p>L'entier signé sur 32 bits est inversé selon <a href="https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux">le complément à deux</a>. Autrement dit, la présence du bit le plus significatif est utilisée pour exprimer des entiers négatifs.</p> + +<p>Appliquer un NON binaire sur n'importe quel nombre <code>x</code> fournira la valeur <code>-(x + 1)</code>. Ainsi, <code>~-5</code> renverra <code>4</code>.</p> + +<p>Étant donné l'utilisation d'une représentation sur 32 bits, <code>~-1</code> et <code>~4294967295</code> (2^32 - 1) donneront tous les deux <code>0</code>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="Using_bitwise_NOT">Utiliser le NON binaire</h3> + +<pre class="brush: js">~0; // -1 +~-1; // 0 +~1; // -2 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_or/index.html b/files/fr/web/javascript/reference/operators/bitwise_or/index.html new file mode 100644 index 0000000000..72d4ed3043 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_or/index.html @@ -0,0 +1,104 @@ +--- +title: OU binaire (|) +slug: Web/JavaScript/Reference/Operators/Bitwise_OR +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_or +translation-of: Web/JavaScript/Reference/Operators/Bitwise_OR +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur OU binaire (<code>|</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où au moins un des bits des deux opérandes vaut <code>1</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-or.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> | <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une séquence de bits. Les nombres sur plus de 32 bits ont leurs bits en excès écartés. Par exemple, l'entier suivant nécessite plus de 32 bits pour être représenté et il sera converti en un entier sur 32 bits :</p> + +<pre class="brush: js"> +Avant: 11100110111110100000000000000110000000000001 +Après: 10100000000000000110000000000001 +</pre> + +<p>Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsqu'au moins un de ces bit vaut 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.</p> + +<p>La table de vérité pour l'opérateur OU est :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">a</th> + <th class="header" scope="col">b</th> + <th class="header" scope="col">a OU b</th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre class="brush: js"> + 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) +</pre> + +<p>Utiliser le OU binaire avec n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> renverra toujours <code><var>x</var></code>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_or">Utiliser l'opérateur OU binaire</h3> + +<pre class="brush: js"> +// 9 (00000000000000000000000000001001) +// 14 (00000000000000000000000000001110) + +14 | 9; +// 15 (00000000000000000000000000001111) +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html new file mode 100644 index 0000000000..5c03784a45 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_or_assignment/index.html @@ -0,0 +1,53 @@ +--- +title: Affectation après OU binaire (|=) +slug: Web/JavaScript/Reference/Operators/Bitwise_OR_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_or_assignment +translation-of: Web/JavaScript/Reference/Operators/Bitwise_OR_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après OU binaire (<code>|=</code>) utilise la représentation binaire des deux opérandes et effectue un OU logique entre chaque puis affecte le résultat à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-or-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x |= y +<strong>Signification :</strong> x = x | y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_or_assignment">Utiliser l'affectation après OU binaire</h3> + +<pre class="brush: js"> +let a = 5; +a |= 2; // 7 +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +// ----------------------------------- +// 7: 00000000000000000000000000000111 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR">L'opérateur OU binaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment">L'opérateur d'affectation après OU logique (<code>||=</code>)</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_xor/index.html b/files/fr/web/javascript/reference/operators/bitwise_xor/index.html new file mode 100644 index 0000000000..eff1d79f8f --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_xor/index.html @@ -0,0 +1,104 @@ +--- +title: OU exclusif binaire (^) +slug: Web/JavaScript/Reference/Operators/Bitwise_XOR +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_xor +translation-of: Web/JavaScript/Reference/Operators/Bitwise_XOR +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur binaire OU exclusif (XOR) (<code>^</code>) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un <code>1</code> pour chaque position où exactement un des bits des deux opérandes vaut <code>1</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> ^ <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une séquence de bits. Les nombres sur plus de 32 bits ont leurs bits en excès écartés. Par exemple, l'entier suivant nécessite plus de 32 bits pour être représenté et il sera converti en un entier sur 32 bits :</p> + +<pre class="brush: js"> +Avant: 11100110111110100000000000000110000000000001 +Après: 10100000000000000110000000000001 +</pre> + +<p>Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsqu'exactement un de ces bit vaut 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.</p> + +<p>La table de vérité pour l'opérateur OU exclusif (XOR) est :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">a</th> + <th class="header" scope="col">b</th> + <th class="header" scope="col">a XOR b</th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre class="brush: js"> +. 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) +</pre> + +<p>Utiliser le OU exclusif binaire avec n'importe quel nombre <code><var>x</var></code> d'une part et <code>0</code> d'autre part renverra <code><var>x</var></code>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_xor">Utiliser le OU exclusif binaire</h3> + +<pre class="brush: js"> +// 9 (00000000000000000000000000001001) +// 14 (00000000000000000000000000001110) + +14 ^ 9; +// 7 (00000000000000000000000000000111) +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide javascript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur ET binaire et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html b/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html new file mode 100644 index 0000000000..15074eaf64 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/bitwise_xor_assignment/index.html @@ -0,0 +1,57 @@ +--- +title: Affectation après OU exclusif binaire (^=) +slug: Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.bitwise_xor_assignment +translation-of: Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après OU exclusif (XOR) binaire (<code>^=</code>) utilise la représentation binaire des deux opérandes, effectue un OU exclusif entre chaque puis affecte le résultat obtenu à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x ^= y +<strong>Signification :</strong> x = x ^ y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_bitwise_xor_assignment">Utiliser l'affectation après OU exclusif binaire</h3> + +<pre class="brush: js"> +let a = 5; // 00000000000000000000000000000101 +a ^= 3; // 00000000000000000000000000000011 + +console.log(a); // 00000000000000000000000000000110 +// 6 + +let b = 5; // 00000000000000000000000000000101 +b ^= 0; // 00000000000000000000000000000000 + +console.log(b); // 00000000000000000000000000000101 +// 5 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR">L'opérateur OU exclusif binaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/decrement/index.html b/files/fr/web/javascript/reference/operators/decrement/index.html new file mode 100644 index 0000000000..291f46393f --- /dev/null +++ b/files/fr/web/javascript/reference/operators/decrement/index.html @@ -0,0 +1,70 @@ +--- +title: Décrémentation (--) +slug: Web/JavaScript/Reference/Operators/Decrement +tags: + - Decrement + - JavaScript + - Language feature + - Operator +browser-compat: javascript.operators.decrement +translation_of: Web/JavaScript/Reference/Operators/Decrement +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de décrémentation (<code>--</code>) permet de décrémenter (c'est-à-dire de soustraire un) son opérande et renvoie une valeur qui est le résultat avant ou après la modification.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-decrement.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var>-- ou --<var>x</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans <code><var>x</var>--</code>, l'opérateur décrémentera la valeur et renverra la valeur avant l'incrément.</p> + +<p>Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans <code>--<var>x</var></code>, l'opérateur décrémentera la valeur et renverra la valeur après l'incrément.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="postfix_decrement">Décrément en suffixe</h3> + +<pre class="brush: js">let x = 3; +let y = x--; + +// y = 3 +// x = 2 +</pre> + +<h3 id="prefix_decrement">Décrément en préfixe</h3> + +<pre class="brush: js">let a = 2; +let b = --a; + +// a = 1 +// b = 1 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur de plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/division/index.html b/files/fr/web/javascript/reference/operators/division/index.html new file mode 100644 index 0000000000..25d572fce0 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/division/index.html @@ -0,0 +1,63 @@ +--- +title: Division (/) +slug: Web/JavaScript/Reference/Operators/Division +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.division +translation-of: Web/JavaScript/Reference/Operators/Division +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de division (<code>/</code>) fournit le quotient de l'opérande gauche (le numérateur) divisé par l'opérande droite (le dénominateur).</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-division.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var> / <var>y</var> +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="basic_division">Divisions simples</h3> + +<pre class="brush: js"> +1 / 2 // 0.5 +Math.floor(3 / 2) // 1 +1.0 / 2.0 // 0.5 +</pre> + +<h3 id="division_by_zero">Division par zéro</h3> + +<pre class="brush: js"> +2.0 / 0 // Infinity +2.0 / 0.0 // Infinity, because 0.0 === 0 +2.0 / -0.0 // -Infinity +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/division_assignment/index.html b/files/fr/web/javascript/reference/operators/division_assignment/index.html new file mode 100644 index 0000000000..cd72e5d239 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/division_assignment/index.html @@ -0,0 +1,51 @@ +--- +title: Affectation après division (/=) +slug: Web/JavaScript/Reference/Operators/Division_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.division_assignment +translation-of: Web/JavaScript/Reference/Operators/Division_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de division et d'affectation (<code>/=</code>) divise la variable fournie par l'opérande gauche par la valeur indiquée par l'opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-division-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x /= y +<strong>Signification:</strong> x = x / y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_division_assignment">Utiliser l'opérateur de division et d'affectation</h3> + +<pre class="brush: js"> +let truc = 5; +truc /= 2; // 2.5 +truc /= 2; // 1.25 +truc /= 0; // Infinity +truc /= 'toto'; // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">L'opérateur de division</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/equality/index.html b/files/fr/web/javascript/reference/operators/equality/index.html new file mode 100644 index 0000000000..0668aa74d4 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/equality/index.html @@ -0,0 +1,125 @@ +--- +title: Égalité (==) +slug: Web/JavaScript/Reference/Operators/Equality +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.equality +translation-of: Web/JavaScript/Reference/Operators/Equality +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'égalité (<code>==</code>) vérifie si ses deux opérandes sont égaux et renvoie un booléen indiquant le résultat de la comparaison. À la différence de l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">d'égalité stricte</a>, l'opérateur d'égalité tente de convertir ses opérandes avant la comparaison si ceux-ci sont de types différents.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x == y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérateurs d'égalité (<code>==</code> et <code>!=</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">l'algorithme de comparaison d'égalité abstraite</a> pour comparer deux opérandes. On peut le résumer ainsi :</p> + +<ul> + <li>Si les opérandes sont deux objets, on renvoie <code>true</code> uniquement si les deux opérandes référencent le même objet.</li> + <li>Si un opérande vaut <code>null</code> et que l'autre vaut <code>undefined</code>, on renvoie <code>true</code>.</li> + <li>Si les opérandes sont de types différents, on tente une conversion pour avoir le même type de part et d'autre avant la comparaison : + <ul> + <li>Si on compare un nombre à une chaîne de caractères, on tentera de convertir la chaîne en une valeur numérique.</li> + <li>Si l'un des opérandes est un booléen, on le convertira en 1 s'il vaut <code>true</code> et en +0 s'il vaut <code>false</code>.</li> + <li>Si l'un des opérandes est un objet et que l'autre est un nombre ou une chaîne de caractères, on tentera de convertir l'objet en une valeur primitive grâce aux méthodes <code>valueOf()</code> et <code>toString()</code> de l'objet.</li> + </ul> + </li> + <li>Si les opérandes sont du même types, on les compare comme suit : + <ul> + <li><code>String</code> : on renvoie <code>true</code> uniquement si les deux opérandes ont les mêmes caractères dans le même ordre.</li> + <li><code>Number</code> : on renvoie <code>true</code> uniquement si les deux opérandes ont la même valeur. <code>+0</code> et <code>-0</code> sont considérés comme la même valeur. Si au moins un des opérandes vaut <code>NaN</code>, on renvoie <code>false</code>.</li> + <li><code>Boolean</code> : on renvoie <code>true</code> uniquement si les deux opérandes valent tous les deux <code>true</code> ou s'ils valent tous les deux <code>false</code>.</li> + </ul> + </li> +</ul> + +<p>La différence fondamentale entre cet opérateur et <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">l'opérateur d'égalité stricte</a> (<code>===</code>) est que ce dernier n'opère pas de conversion de type. L'opérateur d'égalité stricte considère toujours que deux valeurs de types différents sont différentes.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="comparison_with_no_type_conversion">Comparaison sans conversion de types</h3> + +<pre class="brush: js"> +1 == 1; // true +"coucou" == "coucou"; // true +</pre> + +<h3 id="comparison_with_type_conversion">Comparaison avec conversion de types</h3> + +<pre class="brush: js"> +"1" == 1; // true +1 == "1"; // true +0 == false; // true +0 == null; // false +0 == undefined; // false +0 == !!null; // true, voir la documentation pour !! +0 == !!undefined; // true, voir la documentation pour !! +null == undefined; // true + +const nombre1 = new Number(3); +const nombre2 = new Number(3); +nombre1 == 3; // true +nombre1 == nombre2; // false +</pre> + +<h3 id="comparison_of_objects">Comparaison d'objets</h3> + +<pre class="brush: js"> +const objet1 = {"clé": "valeur"} +const objet2 = {"clé": "valeur"}; + +objet1 == objet2 // false +objet2 == objet2 // true +</pre> + +<h3 id="comparing_strings_and_string_objects">Comparaison entre des chaînes de caractères et des objets String</h3> + +<p>On notera que les chaînes de caractères construites avec <code>new String()</code> sont des objets. Si on compare une telle valeur avec une chaîne de caractères "primitives", l'objet <code>String</code> sera converti en une chaîne de caractères et les contenus de ces chaînes seront comparés. Toutefois, si les deux opérandes sont des objets <code>String</code>, ils seront comparés comme tels et devront référencer le même objet pour être considérés égaux :</p> + +<pre class="brush: js"> +const string1 = "coucou"; +const string2 = String("coucou"); +const string3 = new String("coucou"); +const string4 = new String("coucou"); + +console.log(string1 == string2); // true +console.log(string1 == string3); // true +console.log(string2 == string3); // true +console.log(string3 == string4); // false +console.log(string4 == string4); // true +</pre> + +<h3 id="comparing_dates_and_strings">Comparaison entre les dates et les chaînes de caractères</h3> + +<pre class="brush: js"> +const d = new Date('December 17, 1995 03:24:00'); +const s = d.toString(); // par exemple : "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)" +console.log(d == s); //true +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/exponentiation/index.html b/files/fr/web/javascript/reference/operators/exponentiation/index.html new file mode 100644 index 0000000000..310a21c8fe --- /dev/null +++ b/files/fr/web/javascript/reference/operators/exponentiation/index.html @@ -0,0 +1,95 @@ +--- +title: Exponentiation (**) +slug: Web/JavaScript/Reference/Operators/Exponentiation +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.exponentiation +translation-of: Web/JavaScript/Reference/Operators/Exponentiation +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'exponentiation (<code>**</code>) fournit le résultat obtenu lorsqu'on élève le premier opérande à la puissance indiquée par le second. Il est équivalent <code>Math.pow</code> exception faite que cet opérateur permet également d'utiliser des valeurs BigInt comme opérandes.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-exponentiation.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>var1</var> ** <var>var2</var> +</pre> + +<h2 id="description">Description</h2> + +<p>L'opérateur d'exponentiation est associatif à droite : <code><var>a</var> ** <var>b</var> ** <var>c</var></code> est équivalent à <code><var>a</var> ** (<var>b</var> ** <var>c</var>)</code>.</p> + +<p>Pour la plupart des langages possédant un opérateur d'exponentiation (ex. PHP, Python, etc.), l'opérateur d'exponentiation possède une précédence plus élevée que les opérateurs unaires (comme l'addition unaire <code>+</code> ou la soustraction unaire <code>-</code>). Il existe toutefois quelques exceptions comme Bash, où <code>**</code> possède une précédence inférieure à celles des opérateurs unaires.</p> + +<p>En JavaScript, il est impossible d'écrire une expression d'exponentiation ambigüe : on ne peut pas placer un opérateur unaire (<code>+/-/~/!/delete/void/typeof</code>) avant le nombre servant de base, cela provoquera une exception <code>SyntaxError</code>.</p> + +<pre class="brush: js"> +-2 ** 2; +// 4 en Bash, -4 pour d'autres langages. +// Invalide en JavaScript car l'opération est ambigüe. + +-(2 ** 2); +// -4 en JavaScript, les parenthèses évitent l'ambiguité. +</pre> + +<p>Attnetion, certains langages de programmation utilisent l'accent circonflexe <kbd>^</kbd> pour exprimer l'exponentiaion mais JavaScript utilise ce symbole pour <a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">l'opérateur binaire OU exclusif (XOR)</a>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="basic_exponentiation">Exponentiation simple</h3> + +<pre class="brush: js"> +2 ** 3 // 8 +3 ** 2 // 9 +3 ** 2.5 // 15.588457268119896 +10 ** -1 // 0.1 +NaN ** 2 // NaN +</pre> + +<h3 id="associativity">Associativité</h3> + +<pre class="brush: js"> +2 ** 3 ** 2 // 512 +2 ** (3 ** 2) // 512 +(2 ** 3) ** 2 // 64</pre> + +<h3 id="usage_with_unary_operators">Avec les opérateurs unaires</h3> + +<p>Pour prendre l'opposé du résultat :</p> + +<pre class="brush: js"> +-(2 ** 2) // -4 +</pre> + +<p>Pour forcer le signe de la base en négatif :</p> + +<pre class="brush: js">(-2) ** 2 // 4 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html b/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html new file mode 100644 index 0000000000..b83a331cf4 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/exponentiation_assignment/index.html @@ -0,0 +1,49 @@ +--- +title: Affectation après exponentiation (**=) +slug: Web/JavaScript/Reference/Operators/Exponentiation_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.exponentiation_assignment +translation-of: Web/JavaScript/Reference/Operators/Exponentiation_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'exponentiation et d'affectation (<code>**=</code>) élève la valeur de la variable fournie par son opérande gauche à la puissance indiquée par son opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-exponentiation-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x **= y +<strong>Signification :</strong> x = x ** y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_exponentiation_assignment">Utiliser l'opérateur d'exponentiation et d'affectation</h3> + +<pre class="brush: js"> +let truc = 5; +truc **= 2; // 25 +truc **= 'toto'; // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">L'opérateur d'exponentiation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/greater_than/index.html b/files/fr/web/javascript/reference/operators/greater_than/index.html new file mode 100644 index 0000000000..84d44509a0 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/greater_than/index.html @@ -0,0 +1,100 @@ +--- +title: Supérieur strict (>) +slug: Web/JavaScript/Reference/Operators/Greater_than +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.greater_than +translation-of: Web/JavaScript/Reference/Operators/Greater_than +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur supérieur strict (<code>></code>) renvoie <code>true</code> si l'opérande gauche est strictement supérieur à l'opérande droit et <code>false</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-greater-than.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x > y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="number_to_number_comparison">Comparaison numérique</h3> + +<pre class="brush: js"> +console.log(5 > 3); // true +console.log(3 > 3); // false +console.log(3 > 5); // false +</pre> + +<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3> + +<pre class="brush: js"> +console.log(5n > 3); // true +console.log(3 > 5n); // false +</pre> + +<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("a" > "b"); // false +console.log("a" > "a"); // false +console.log("a" > "3"); // true +</pre> + +<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("5" > 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 +</pre> + +<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3> + +<pre class="brush: js"> +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 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html b/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html new file mode 100644 index 0000000000..4737d5161d --- /dev/null +++ b/files/fr/web/javascript/reference/operators/greater_than_or_equal/index.html @@ -0,0 +1,99 @@ +--- +title: Supérieur ou égal (>=) +slug: Web/JavaScript/Reference/Operators/Greater_than_or_equal +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.greater_than_or_equal +translation-of: Web/JavaScript/Reference/Operators/Greater_than_or_equal +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur supérieur ou égal (<code>>=</code>) renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à l'opérande droit et <code>false</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-greater-than-or-equal.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x >= y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="number_to_number_comparison">Comparaison numérique</h3> + +<pre class="brush: js"> +console.log(5 >= 3); // true +console.log(3 >= 3); // true +console.log(3 >= 5); // false +</pre> + +<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3> + +<pre class="brush: js"> +console.log(5n >= 3); // true +console.log(3 >= 3n); // true +console.log(3 >= 5n); // false +</pre> + +<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("a" >= "b"); // false +console.log("a" >= "a"); // true +console.log("a" >= "3"); // true +</pre> + +<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("5" >= 3); // true +console.log("3" >= 3); // true +console.log("3" >= 5); // false + +console.log("coucou" >= 5); // false +console.log(5 >= "coucou"); // false +</pre> + +<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3> + +<pre class="brush: js"> +console.log(true >= 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 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/increment/index.html b/files/fr/web/javascript/reference/operators/increment/index.html new file mode 100644 index 0000000000..ab9d79b09f --- /dev/null +++ b/files/fr/web/javascript/reference/operators/increment/index.html @@ -0,0 +1,70 @@ +--- +title: Incrémentation (++) +slug: Web/JavaScript/Reference/Operators/Increment +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.increment +translation_of: Web/JavaScript/Reference/Operators/Increment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'incrémentation (<code>++</code>) permet d'incrémenter (c'est-à-dire d'ajouter un) à son opérande et de renvoyer une valeur qui est le résultat avant ou après la modification.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-increment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var>++ ou ++<var>x</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Utilisé comme suffixe (l'opérateur étant placé après l'opérande), comme dans <code><var>x</var>++</code>, l'opérateur incrémentera la valeur et renverra la valeur avant l'incrément.</p> + +<p>Utilisé comme préfixe (l'opérateur étant placé avant l'opérande), comme dans <code>++<var>x</var></code>, l'opérateur incrémentera la valeur et renverra la valeur après l'incrément.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="postfix_increment">Incrément en suffixe</h3> + +<pre class="brush: js">let x = 3; +let y = x++; + +// y = 3 +// x = 4 +</pre> + +<h3 id="prefix_increment">Incrément en préfixe</h3> + +<pre class="brush: js">let a = 2; +let b = ++a; + +// a = 3 +// b = 3 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="See_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur de plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/index.html b/files/fr/web/javascript/reference/operators/index.html index ba82e8321e..83d4f9aa69 100644 --- a/files/fr/web/javascript/reference/operators/index.html +++ b/files/fr/web/javascript/reference/operators/index.html @@ -1,301 +1,286 @@ --- -title: Opérateurs +title: Expressions et opérateurs slug: Web/JavaScript/Reference/Operators tags: - JavaScript - - Opérateurs + - Landing page + - Operators + - Overview - Reference translation_of: Web/JavaScript/Reference/Operators original_slug: Web/JavaScript/Reference/Opérateurs +browser-compat: javascript.operators --- <div>{{jsSidebar("Operators")}}</div> -<p>Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés utilisés en JavaScript.</p> +<p class="summary">Ce chapitre documente l'ensemble des opérateurs, expressions et mots-clés pour le langage JavaScript.</p> -<h2 id="Expressions_et_opérateurs_par_catégorie">Expressions et opérateurs, par catégorie</h2> +<h2 id="expressions_and_operators_by_category">Expressions et opérateurs par catégorie</h2> -<p>Pour une liste alphabétique, voir le volet de navigation situé à gauche sur cette page.</p> +<p>Pour une liste triée par ordre alphabétique, voir sur la barre de navigation à gauche.</p> -<h3 id="Expressions_primaires">Expressions primaires</h3> +<h3 id="primary_expressions">Expressions primaires</h3> -<p>Les mots-clés basiques et les expressions générales en JavaScript.</p> +<p>Mots-clés de base et expressions générales en JavaScript.</p> <dl> - <dt>{{jsxref("Opérateurs/L_opérateur_this", "this")}}</dt> - <dd>Le mot-clé <code>this</code> fait référence à une propriété spéciale du contexte d'exécution de la fonction.</dd> - <dt>{{jsxref("Opérateurs/L_opérateur_function", "function")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/this"><code>this</code></a></dt> + <dd>Le mot-clé <code>this</code> fait référence à une propriété spéciale indiquant le contexte d'exécution.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/function"><code>function</code></a></dt> <dd>Le mot-clé <code>function</code> définit une expression de fonction.</dd> - <dt>{{jsxref("Opérateurs/class", "class")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/class"><code>class</code></a></dt> <dd>Le mot-clé <code>class</code> définit une expression de classe.</dd> - <dt> {{jsxref("Opérateurs/function*", "function*")}}</dt> - <dd>Le mot-clé <code>function*</code> définit une expression pour une fonction génératrice.</dd> - <dt>{{jsxref("Opérateurs/yield", "yield")}}</dt> - <dd>Cet opérateur permet de suspendre et de reprendre l'exécution d'une fonction génératrice.</dd> - <dt>{{jsxref("Opérateurs/yield*", "yield*")}}</dt> - <dd>Cet opérateur permet de déléguer l'exécution de la fonction à une autre fonction ou un autre objet itérable.</dd> - <dt>{{experimental_inline}} {{jsxref("Opérateurs/async_function", "async function*")}}</dt> - <dd>L'opérateur <code>async function</code> définit une expression de fonction asynchrone.</dd> - <dt>{{experimental_inline}} {{jsxref("Opérateurs/await", "await")}}</dt> - <dd>Cet opérateur permet de stopper et de reprendre l'exécution d'une fonction asynchrone et d'attendre pour la résolution ou le rejet d'une promesse.</dd> - <dt>{{jsxref("Objets_globaux/Array", "[]")}}</dt> - <dd>Littéral initialisateur de tableau.</dd> - <dt>{{jsxref("Opérateurs/Initialisateur_objet", "{}")}}</dt> - <dd>Littéral initialisateur d'objet.</dd> - <dt>{{jsxref("Objets_globaux/RegExp", "/ab+c/i")}}</dt> - <dd>Littéral d'expression rationnelle.</dd> - <dt>{{jsxref("Opérateurs/Groupement", "( )")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/function*"><code>function*</code></a></dt> + <dd>Le mot-clé <code>function*</code> définit une expression de générateur.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield"><code>yield</code></a></dt> + <dd>Ce mot-clé permet de suspendre ou de reprendre l'exécution d'une fonction génératrice.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield*"><code>yield*</code></a></dt> + <dd>Ce mot-clé délègue à une autre fonction génératrice ou à un objet itérable.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/async_function"><code>async function</code></a></dt> + <dd>Le couple de mots-clés <code>async function</code> définit une expression de fonction asynchrone.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/await"><code>await</code></a></dt> + <dd>Ce mot-clé permet de suspendre et de reprendre l'exécution d'une fonction asynchrone et d'attendre la résolution ou l'échec de la promesse.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array"><code>[]</code></a></dt> + <dd>Syntaxe d'initialisation littérale pour les tableaux.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer"><code>{}</code></a></dt> + <dd>Syntaxe d'initialisation littérale pour les objets.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>/ab+c/i</code></a></dt> + <dd>Syntaxe pour les expressions littérales d'expressions rationnelles.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Grouping"><code>( )</code></a></dt> <dd>Opérateur de groupement.</dd> </dl> -<h3 id="Expressions_«_vers_la_gauche_»">Expressions « vers la gauche »</h3> +<h3 id="left-hand-side_expressions">Expression « vers la gauche »</h3> -<p>On affectera des valeurs aux variables à gauche de l'expression.</p> +<p>Les valeurs situées à gauche sont la cible de l'affectation.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_de_membres", "Opérateurs de membres", "", 1)}}</dt> - <dd>Les opérateurs de membres permettent d'accéder à une propriété ou une méthode d'un objet (<code>objet.propriété</code> et <code>object["propriété"]</code>).</dd> - <dt>{{jsxref("Opérateurs/L_opérateur_new", "new")}}</dt> - <dd>L'opérateur <code>new</code> permet de créer une instance d'un constructeur.</dd> - <dt><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></dt> - <dd>Dans les constructeurs, <code>new.target</code> fait référence au constructeur invoqué par {{jsxref("Opérateurs/new", "new")}}.</dd> - <dt>{{jsxref("Opérateurs/super", "super")}}</dt> - <dd>Le mot-clé <code>super</code> permet d'appeler le constructeur parent.</dd> - <dt>{{jsxref("Opérateurs/Syntaxe_décomposition", "...obj")}}</dt> - <dd>L'opérateur de décomposition permet de développer une expression là où on attend plusieurs arguments (pour des appels de fonctions) ou plusieurs éléments (pour les littéraux de tableaux).</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Accesseurs de propriété</a></dt> + <dd>Les opérateurs d'accès aux membres permettent d'accéder à une propriété ou à une méthode d'un objet.<br> + (cela regroupe <code>objet.propriete</code> et <code>objet["propriete"]</code>).</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></dt> + <dd>L'opérateur <code>new</code> crée une instance grâce à un constructeur.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/new.target"><code>new.target</code></a></dt> + <dd>Pour les constructeurs, <code>new.target</code> fait référence au constructeur invoqué avec <a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a>.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Statements/import.meta"><code>import.meta</code></a></dt> + <dd>Un objet qui expose des métadonnées spécifiques au contexte pour un module JavaScript.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/super"><code>super</code></a></dt> + <dd>Le mot-clé <code>super</code> appelle le constructeur parent.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Spread_syntax"><code>...obj</code></a></dt> + <dd>La syntaxe de décomposition permet de développer une expression là où plusieurs arguments (dans le cas des appels à une fonction) ou là où plusieurs éléments (dans le cas des tableaux) sont attendus.</dd> </dl> -<h3 id="Incrémentation_et_décrémentation">Incrémentation et décrémentation</h3> +<h3 id="increment_and_decrement">Incrémentation et décrémentation</h3> -<p>Les opérateurs d'incrémentation et de décrémentation, suffixe et préfixe :</p> +<p>Des opérateurs préfixes ou suffixes pour incrémenter/décrémenter.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A++", "#Incr.C3.A9ment_(.2B.2B)")}}</dt> - <dd>Opérateur d'incrémentation suffixe.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "A--", "#D.C3.A9cr.C3.A9ment_(--)")}}</dt> - <dd>Opérateur de décrémentation suffixe.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "++A", "#Incr.C3.A9ment_(.2B.2B)")}}</dt> - <dd>Opérateur d'incrémentation préfixe.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "--A", "#D.C3.A9cr.C3.A9ment_(--)")}}</dt> - <dd>Opérateur de décrémentation préfixe.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment"><code>A++</code></a></dt> + <dd>L'opérateur d'incrémentation suffixe.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement"><code>A--</code></a></dt> + <dd>L'opérateur de décrémentation suffixe.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment"><code>++A</code></a></dt> + <dd>L'opérateur d'incrémentation préfixe.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement"><code>--A</code></a></dt> + <dd>L'opérateur de décrémentation préfixe.</dd> </dl> -<h3 id="Opérateurs_unaires">Opérateurs unaires</h3> +<h3 id="unary_operators">Opérateurs unaires</h3> -<p>Une opération unaire est une opération qui ne possède qu'un opérande.</p> +<p>Une opération unaire est une opération qui ne manipule qu'un seul opérande.</p> <dl> - <dt>{{jsxref("Opérateurs/L_opérateur_delete", "delete")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/delete"><code>delete</code></a></dt> <dd>L'opérateur <code>delete</code> permet de supprimer une propriété d'un objet.</dd> - <dt>{{jsxref("Opérateurs/L_opérateur_void", "void")}}</dt> - <dd>L'opérateur <code>void</code> écarte la valeur de retour d'une expression.</dd> - <dt>{{jsxref("Opérateurs/L_opérateur_typeof", "typeof")}}</dt> - <dd>L'opérateur <code>typeof</code> permet de déterminer le type d'un objet donné.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Plus_unaire_(.2B)")}}</dt> - <dd>Le plus unaire permet de convertir son opérande en une valeur du type <code>Number</code>.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#N.C3.A9gation_unaire_(-)")}}</dt> - <dd>La négation unaire permet de convertir son opérande en une valeur du type <code>Number</code> puis d'en prendre l'opposé.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "~", "#.7E_.28NON_binaire.29")}}</dt> - <dd>L'opérateur binaire NON (<em>NOT</em>).</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "!", "#NON_logique_.28.21.29")}}</dt> - <dd>L'opérateur du NON logique.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/void"><code>void</code></a></dt> + <dd>L'opérateur <code>void</code> permet d'ignorer la valeur de retour d'une expression.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code></a></dt> + <dd>L'opérateur <code>typeof</code> détermine le type d'un objet donné.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus"><code>+</code></a></dt> + <dd>L'opérateur unaire <code>+</code> convertit son opérande en une valeur de type <code>number</code>.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation"><code>-</code></a></dt> + <dd>L'opérateur unaire <code>-</code> convertit son opérande en nombre puis prend son opposé.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT"><code>~</code></a></dt> + <dd>L'opérateur binaire NON.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT"><code>!</code></a></dt> + <dd>L'opérateur logique NON.</dd> </dl> -<h3 id="Opérateurs_arithmétiques">Opérateurs arithmétiques</h3> +<h3 id="arithmetic_operators">Opérateurs arithmétiques</h3> -<p>Les opérateurs arithmétiques utilisent des opérandes numériques et renvoie une valeur numérique.</p> +<p>Les opérateurs arithmétiques utilisent des valeurs numériques (littérales ou variables) pour leurs opérandes et renvoient une seule valeur numérique en résultat.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "+", "#Addition_(.2B)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition"><code>+</code></a></dt> <dd>L'opérateur d'addition.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "-", "#Soustraction_(-)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction"><code>-</code></a></dt> <dd>L'opérateur de soustraction.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "/", "#Division_(.2F)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division"><code>/</code></a></dt> <dd>L'opérateur de division.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "*", "#Multiplication_(*)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication"><code>*</code></a></dt> <dd>L'opérateur de multiplication.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques", "%", "#Reste_(.25)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder"><code>%</code></a></dt> <dd>L'opérateur du reste.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_arithmétiques","**","#Exponentiation")}}</dt> - <dd>Opérateur de puissance (exponentiation).</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation"><code>**</code></a></dt> + <dd>L'opérateur d'exponentiation.</dd> </dl> -<h3 id="Opérateurs_relationnels">Opérateurs relationnels</h3> +<h3 id="relational_operators">Opérateurs relationnels</h3> -<p>Un opérateur de comparaison permet de comparer deux opérandes et de renvoyer une valeur booléenne selon le résultat de cette comparaison.</p> +<p>Un opérateur de comparaison compare ses opérandes et renvoie une valeur booléenne en fonction de la vérité de cette comparaison.</p> <dl> - <dt>{{jsxref("Opérateurs/L_opérateur_in", "in")}}</dt> - <dd>L'opérateur <code>in</code> permet de déterminer si un objet possède une propriété donnée.</dd> - <dt>{{jsxref("Opérateurs/instanceof", "instanceof")}}</dt> - <dd>L'opérateur <code>instanceof</code> permet de déterminer si un objet est une instance d'un autre objet.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "<", "#Op.C3.A9rateur_inf.C3.A9rieur_strict_(<)")}}</dt> - <dd>Opérateur inférieur strict.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", ">", "#Op.C3.A9rateur_sup.C3.A9rieur_strict_(>)")}}</dt> - <dd>Opérateur supérieur strict.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "<=", "#Op.C3.A9rateur_inf.C3.A9rieur_ou_.C3.A9gal_(<.3D)")}}</dt> - <dd>Opérateur inférieur ou égal.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", ">=", "#Op.C3.A9rateur_sup.C3.A9rieur_ou_.C3.A9gal_(>.3D)")}}</dt> - <dd>Opérateur supérieur ou égal.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/in"><code>in</code></a></dt> + <dd>L'opérateur <code>in</code> détermine la présence d'une propriété donnée au sein d'un objet.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code></a></dt> + <dd>L'opérateur <code>instanceof</code> détermine si un objet est une instance d'un autre objet.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than"><code><</code></a></dt> + <dd>L'opérateur d'infériorité strict.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than"><code>></code></a></dt> + <dd>L'opérateur de supériorité stricte.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal"><code><=</code></a></dt> + <dd>L'opérateur d'infériorité.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal"><code>>=</code></a></dt> + <dd>L'opérateur de supériorité.</dd> </dl> -<div class="note"> -<p><strong>Note :</strong> <code>=></code> n'est pas un opérateur. Il s'agit de la notation utilisée pour <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">les fonctions fléchées</a>.</p> +<div class="notecard note"> +<p><strong>Note :</strong> <code>=></code> n'est pas un opérateur mais la notation utilisée pour <a href="/fr/docs/Web/JavaScript/Reference/Functions/Arrow_functions">les fonctions fléchées</a>.</p> </div> -<h3 id="Opérateurs_d'égalité">Opérateurs d'égalité</h3> +<h3 id="equality_operators">Opérateurs d'égalité</h3> -<p>Un opérateur d'égalité considère deux opérandes et produit un résultat booléen basé sur le résultat de la comparaison.</p> +<p>Le résultat de l'évaluation fournie par un opérateur d'égalité est toujours un booléen, fonction de la vérité de la comparaison effectuée.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#Egalit.C3.A9_(.3D.3D)")}}</dt> - <dd>Opérateur d'égalité faible.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!=", "#Inequality_(!.3D)")}}</dt> - <dd>Opérateur d'inégalité faible.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}}</dt> - <dd>Opérateur d'égalité stricte.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_de_comparaison", "!==", "#Non-identity_.2F_strict_not_equal_(!.3D.3D)")}}</dt> - <dd>Opérateur d'inégalité stricte.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality"><code>==</code></a></dt> + <dd>L'opérateur d'égalité.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality"><code>!=</code></a></dt> + <dd>L'opérateur d'inégalité.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality"><code>===</code></a></dt> + <dd>L'opérateur d'identité.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality"><code>!==</code></a></dt> + <dd>L'opérateur d'inégalité stricte.</dd> </dl> -<h3 id="Opérateurs_de_décalage_binaires">Opérateurs de décalage binaires</h3> +<h3 id="bitwise_shift_operators">Opérateurs de décalage binaires</h3> -<p>Ces opérations permettent de décaler les bits contenus dans l'opérande.</p> +<p>Ces opérations permettent de décaler les bits de la représentation binaire de l'opérande.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "<<", "#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29")}}</dt> - <dd>Opérateur binaire de décalage à gauche.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", ">>", "#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29")}}</dt> - <dd>Opérateur binaire de décalage à droite.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", ">>>", "#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29")}}</dt> - <dd>Opérateur binaire de décalage à droite non-signé.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift"><code><<</code></a></dt> + <dd>Opérateur de décalage binaire à gauche.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift"><code>>></code></a></dt> + <dd>Opérateur de décalage binaire à droite.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift"><code>>>></code></a></dt> + <dd>Opérateur de décalage binaire à droite non signé.</dd> </dl> -<h3 id="Opérateurs_binaires_logiques">Opérateurs binaires logiques</h3> +<h3 id="Binary_bitwise_operators">Opérateurs binaires booléens</h3> -<p>Les opérateurs binaires logiques traitent leurs opérandes comme des valeurs sur 32 bits et renvoient une valeur numérique JavaScript correspondant au résultat.</p> +<p>Ces opérateurs manipulent leurs opérandes comme des ensembles de 32 bits et renvoient des valeurs numériques standard.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "&", "#&_.28ET_binaire.29")}}</dt> - <dd>ET binaire (<em>AND</em>).</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "|", "#|_.28OU_binaire.29")}}</dt> - <dd>OU binaire (<em>OR</em>).</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_binaires", "^", "#.5E_.28XOR_binaire.29")}}</dt> - <dd>OU exclusif binaire (<em>XOR</em>).</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND"><code>&</code></a></dt> + <dd>Opérateur ET/AND binaire.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR"><code>|</code></a></dt> + <dd>Opérateur OU/OR binaire.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR"><code>^</code></a></dt> + <dd>Opérateur OU exclusif/XOR binaire.</dd> </dl> -<h3 id="Opérateurs_logiques">Opérateurs logiques</h3> +<h3 id="binary_logical_operators">Opérateurs logiques</h3> -<p>Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes et renvoient une valeur booléenne, résultat de l'opération.</p> +<p>Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes, quand c'est le cas, la valeur de retour de l'expression est une valeur booléenne.</p> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "&&", "#ET_logique_.28&&.29")}}</dt> - <dd>ET logique (<em>AND</em>).</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_logiques", "||", "#OU_logique_.28||.29")}}</dt> - <dd>OU logique (<em>OR</em>).</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND"><code>&&</code></a></dt> + <dd>Opérateur logique ET/AND.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR"><code>||</code></a></dt> + <dd>Opérateur logique OU/OR.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator"><code>??</code></a></dt> + <dd>Opérateur de coalescence des nuls.</dd> </dl> -<h3 id="Opérateur_conditionnel_ternaire">Opérateur conditionnel ternaire</h3> +<h3 id="conditional_ternary_operator">Opérateur conditionnel ternaire</h3> <dl> - <dt>{{jsxref("Opérateurs/L_opérateur_conditionnel", "(condition ? siVrai : siFaux)")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator"><code>(condition ? ifTrue : ifFalse)</code></a></dt> <dd> - <p>Cet opérateur renvoie une des deux valeurs fournie en fonction de la valeur logique de la condition.</p> + <p>L'opérateur conditionnel renvoie une valeur parmi deux selon la valeur logique de la condition portée par le premier opérande.</p> </dd> </dl> -<h3 id="Opérateurs_d'affectation">Opérateurs d'affectation</h3> - -<p>Un opérateur d'affectation permet d'affecter une valeur à son opérande gauche en se basant sur la valeur de l'opérande droit.</p> +<h3 id="optional_chaining_operator">Opérateur de chaînage optionnel</h3> <dl> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "=", "#Assignment")}}</dt> - <dd>Opérateur d'affectation.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "*=", "#Multiplication_assignment")}}</dt> - <dd>Affectation après multiplication.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "/=", "#Division_assignment")}}</dt> - <dd>Affectation après division.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "%=", "#Remainder_assignment")}}</dt> - <dd>Affectation du reste.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "+=", "#Addition_assignment")}}</dt> - <dd>Affectation après addition.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "-=", "#Subtraction_assignment")}}</dt> - <dd>Affectation après soustraction.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "<<=", "#Left_shift_assignment")}}</dt> - <dd>Affectation après décalage à gauche.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", ">>=", "#Right_shift_assignment")}}</dt> - <dd>Affectation après décalage à droite.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", ">>>=", "#Unsigned_right_shift_assignment")}}</dt> - <dd>Affectation après décalage à droite non-signé.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "&=", "#Bitwise_AND_assignment")}}</dt> - <dd>Affectation après ET binaire.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "^=", "#Bitwise_AND_assignment")}}</dt> - <dd>Affectation après OU exclusif binaire.</dd> - <dt>{{jsxref("Opérateurs/Opérateurs_d_affectation", "|=","#Bitwise_OR_assignment")}}</dt> - <dd>Affectation après OU binaire.</dd> - <dt>{{jsxref("Opérateurs/Affecter_par_décomposition", "[a, b] = [1, 2]")}} {{jsxref("Opérateurs/Affecter_par_décomposition", "{a, b} = {a:1, b:2}")}}</dt> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Optional_chaining"><code>?.</code></a></dt> <dd> - <p>L'affectation par décomposition permet de d'affecter des propriétés d'un objet ou des éléments d'un tableau à plusieurs variables. Cela permet d'utiliser une syntaxe semblable aux littéraux de tableaux/objets.</p> + <p>L'opérateur de chaînage optionnel renvoie <code>undefined</code> plutôt que de causer une erreur si une référence vaut <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>.</p> </dd> </dl> -<h3 id="Opérateur_virgule">Opérateur virgule</h3> +<h3 id="assignment_operators">Opérateurs d'affectation</h3> + +<p>Un opérateur d'affectation permet d'affecter une valeur à son opérande gauche en fonction de la valeur de son opérande droit.</p> <dl> - <dt>{{jsxref("Opérateurs/L_opérateur_virgule", ",")}}</dt> - <dd>L'opérateur virgule permet d'évaluer plusieurs expressions en une seule instruction et de renvoyer le résultat de la dernière expression.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Assignment"><code>=</code></a></dt> + <dd>Opérateur d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication_assignment"><code>*=</code></a></dt> + <dd>Opérateur de multiplication et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation_assignment"><code>**=</code></a></dt> + <dd>Opérateur d'exponentiation et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division_assignment"><code>/=</code></a></dt> + <dd>Opérateur de division et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder_assignment"><code>%=</code></a></dt> + <dd>Opérateur de reste et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition_assignment"><code>+=</code></a></dt> + <dd>Opérateur d'addition et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction_assignment"><code>-=</code></a></dt> + <dd>Opérateur de soustraction et d'affectation</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift_assignment"><code><<=</code></a></dt> + <dd>Opérateur de décalage à gauche et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift_assignment"><code>>>=</code></a></dt> + <dd>Opérateur de décalage à droite et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment"><code>>>>=</code></a></dt> + <dd>Opérateur de décalage à droite non signé et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment"><code>&=</code></a></dt> + <dd>Opérateur binaire ET et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment"><code>^=</code></a></dt> + <dd>Opérateur binaire OU exclusif et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR_assignment"><code>|=</code></a></dt> + <dd>Opérateur binaire OU et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND_assignment"><code>&&=</code></a></dt> + <dd>Opérateur booléen ET et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment"><code>||=</code></a></dt> + <dd>Opérateur booléen OU et d'affectation.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_nullish_assignment"><code>??=</code></a></dt> + <dd>Opérateur d'affectation et de logique nulle.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment"><code>[a, b] = [1, 2]</code></a><br> + <a href="/fr/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment"><code>{a, b} = {a:1, b:2}</code></a></dt> + <dd> + <p>L'affectation par décomposition permet d'affecter les propriétés d'un tableau ou d'un objet à des variables en utilisant une syntaxe similaire à celle des littéraux pour les tableaux et les objets.</p> + </dd> </dl> -<h3 id="Fonctionnalités_non-standardsnon-standard_inline">Fonctionnalités non-standards{{non-standard_inline}}</h3> +<h3 id="comma_operator">Opérateur virgule</h3> <dl> - <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fermetures", "Expression de fermetures", "", 1)}}</dt> - <dd>La syntaxe d'expression de fermeture est un raccourci pour écrire des fonctions simples.</dd> - <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Expression_fonction_génératrice_historique", "", 1)}}</dt> - <dd>Le mot-clé <code>function</code> peut être utilisé afin de définir une fonction génératrice historique. au sein d'une expression.</dd> - <dt>{{non-standard_inline}} {{jsxref("Opérateurs/Compréhensions_de_tableau", "[for (x of y) x]")}}</dt> - <dd>Compréhensions de tableau.</dd> - <dt>{{non-standard_inline}}{{jsxref("Opérateurs/Compréhensions_de_générateur", "(for (x of y) y)")}}</dt> - <dd>Compréhensions de générateurs.</dd> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators/Comma_Operator"><code>,</code></a></dt> + <dd>L'opérateur virgule permet d'évaluer plusieurs expressions dans une seule instruction et renvoie le résultat de la dernière expression.</dd> </dl> -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1','#sec-11','Expressions')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Nouveaux éléments : opérateur de décomposition, affectation par décomposition, mot-clé <code>super</code> .</td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.operators")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> <ul> - <li><a href="/fr/docs/JavaScript/Reference/Operators/Pr%C3%A9c%C3%A9dence_des_op%C3%A9rateurs">La précédence des opérateurs</a> en JavaScript</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Précédence des opérateurs en JavaScript</a></li> </ul> diff --git a/files/fr/web/javascript/reference/operators/inequality/index.html b/files/fr/web/javascript/reference/operators/inequality/index.html new file mode 100644 index 0000000000..d9465f8ba5 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/inequality/index.html @@ -0,0 +1,102 @@ +--- +title: Inégalité (!=) +slug: Web/JavaScript/Reference/Operators/Inequality +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.inequality +translation-of: Web/JavaScript/Reference/Operators/Inequality +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'inégalité (<code>!=</code>) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">d'inégalité stricte</a>, l'opérateur d'inégalité tente une conversion de ses opérandes avant la comparaison si ceux-ci sont de types différents.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-inequality.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x != y +</pre> + +<h2 id="description">Description</h2> + +<p>L'opérateur d'inégalité vérifie si ses deux opérandes ne sont pas égaux. Il s'agit de la négation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a> et les deux lignes suivantes fourniront donc toujours le même résultat :</p> + +<pre class="brush: js"> +x != y +!(x == y) +</pre> + +<p>Pour plus de détails sur l'algorithme de comparaison utilisé, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">la page relative à l'opérateur d'égalité</a>. +</p> + +<p>À l'instar de l'opérateur d'égalité, l'opérateur d'inégalité tentera une conversion des opérandes si ceux-ci ne sont pas de même type :</p> + +<pre class="brush: js"> +3 != "3"; // false +</pre> + +<p>Si cette conversion implicite n'est pas souhaitable et qu'on souhaite considérer des valeurs de types différents comme étant différentes, on privilégiera <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">l'opérateur d'inégalité stricte</a> à la place :</p> + +<pre class="brush: js"> +3 !== "3"; // true +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="comparison_with_no_type_conversion">Comparaison sans conversion de types</h3> + +<pre class="brush: js"> +1 != 2; // true +"hello" != "hola"; // true + +1 != 1; // false +"hello" != "hello"; // false +</pre> + +<h3 id="comparison_with_type_conversion">Comparaison avec conversion de types</h3> + +<pre class="brush: js"> +"1" != 1; // false +1 != "1"; // false +0 != false; // false +0 != null; // true +0 != undefined; // true +0 != !!null; // false, voir la documentation pour !! +0 != !!undefined; // false, voir la documentation pour !! +null != undefined; // false + +const number1 = new Number(3); +const number2 = new Number(3); +number1 != 3; // false +number1 != number2; // true +</pre> + +<h3 id="comparison_of_objects">Comparaison d'objets</h3> + +<pre class="brush: js"> +const objet1 = {"clé": "valeur"} +const objet2 = {"clé": "valeur"}; + +objet1 != objet2 // true +objet2 != objet2 // false +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/left_shift/index.html b/files/fr/web/javascript/reference/operators/left_shift/index.html new file mode 100644 index 0000000000..325adc9947 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/left_shift/index.html @@ -0,0 +1,62 @@ +--- +title: Décalage binaire à gauche (<<) +slug: Web/JavaScript/Reference/Operators/Left_shift +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.left_shift +translation-of: Web/JavaScript/Reference/Operators/Left_shift +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de <strong>décalage binaire à gauche (<code><<</code>)</strong> décale la séquence de bits représentée par le premier opérande d'autant de bits vers la gauche que le nombre indiqué par le second opérande. Les bits en excès à gauche sont écartés et des bits à zéro sont introduits à droite.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-left-shift.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> << <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Cet opérateur décale les bits du premier opérande vers la gauche, d'autant que le nombre indiqué par le second opérande. Les bits qui dépassent à gauche sont abandonnés et des zéros sont introduits à droite.</p> + +<p>Ainsi, <code>9 << 2</code> donnera la valeur 36 (en base 10) :</p> + +<pre class="brush: js"> + 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- + 9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10) +</pre> + +<p>Le décalage binaire de tout nombre <code>x</code> de <code>y</code> bits vers la gauche donnera comme résultat <code>x * 2 ** y</code>. Par exemple, <code>9 << 3</code> pourra être reformulé en <code>9 * (2 ** 3) = 9 * (8) = 72</code>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_left_shift">Utiliser le décalage binaire à gauche</h3> + +<pre class="brush: js"> +9 << 3; // 72 + +// 9 * (2 ** 3) = 9 * (8) = 72 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift_assignment">L'opérateur de décalage binaire à gauche et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html new file mode 100644 index 0000000000..85b349301b --- /dev/null +++ b/files/fr/web/javascript/reference/operators/left_shift_assignment/index.html @@ -0,0 +1,51 @@ +--- +title: Affectation après décalage à gauche (<<=) +slug: Web/JavaScript/Reference/Operators/Left_shift_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +translation-of: Web/JavaScript/Reference/Operators/Left_shift_assignment +browser-compat: javascript.operators.left_shift_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de décalage à gauche et d'affectation (<code><<=</code>) décale la séquence de bits représentée par l'opérande gauche d'autant de bits qu'indiqué par l'opérande droit puis affecte le résultat obtenu à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-left-shift-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x <<= y +<strong>Signification :</strong> x = x << y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_left_shift_assignment">Utiliser l'opérateur de décalage à gauche et d'affectation</h3> + +<pre class="brush: js"> +let a = 5; +// 00000000000000000000000000000101 + +a <<= 2; // 20 +// 00000000000000000000000000010100 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift">L'opérateur de décalage à gauche binaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/less_than/index.html b/files/fr/web/javascript/reference/operators/less_than/index.html new file mode 100644 index 0000000000..5748798f15 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/less_than/index.html @@ -0,0 +1,115 @@ +--- +title: Inférieur strict (<) +slug: Web/JavaScript/Reference/Operators/Less_than +tags: + - JavaScript + - Language feature + - Operator + - Reference +translation-of: Web/JavaScript/Reference/Operators/Less_than +browser-compat: javascript.operators.less_than +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur inférieur strict (<code><</code>) renvoie <code>true</code> si son opérande gauche est strictement inférieur à son opérande droit et <code>false</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-less-than.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x < y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a> résumé comme suit :</p> + +<ul> + <li>Tout d'abord, les objets sont convertis en valeurs primitives avec <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive">Symbol.ToPrimitive</a></code> en utilisant le paramètre <code>hint</code> avec la valeur <code>'number'</code>.</li> + <li>Si les deux valeurs sont des chaînes de caractères, elles sont comparées comme telles selon les valeurs des codes Unicode qu'elles contiennent.</li> + <li>Sinon, le moteur JavaScript tente de convertir les valeurs primitives non-numériques en valeurs numériques : + <ul> + <li>Les valeurs booléennes <code>true</code> et <code>false</code> sont respectivement converties en 1 et 0.</li> + <li><code>null</code> est converti en 0.</li> + <li><code>undefined</code> est converti en <code>NaN</code>.</li> + <li>Les chaînes de caractères sont converties en fonction de la valeur qu'elles contiennent et, si elles ne contiennent pas de valeurs numériques, elles sont converties en <code>NaN</code>.</li> + </ul> + </li> + <li>Si l'une des valeurs vaut <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a></code>, l'opérateur renverra <code>false</code>.</li> + <li>Sinon, les valeurs sont comparées numériquement.</li> +</ul> + +<h2 id="examples">Exemples</h2> + +<h3 id="number_to_number_comparison">Comparaison numérique</h3> + +<pre class="brush: js"> +console.log(5 < 3); // false +console.log(3 < 3); // false +console.log(3 < 5); // true +</pre> + +<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3> + +<pre class="brush: js"> +console.log(5n < 3); // false +console.log(3 < 5n); // true +</pre> + +<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("a" < "b"); // true +console.log("a" < "a"); // false +console.log("a" < "3"); // false +</pre> + +<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("5" < 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 +</pre> + +<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3> + +<pre class="brush: js"> +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 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal">L'opérateur inférieur ou égal</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html b/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html new file mode 100644 index 0000000000..19d84e0f8c --- /dev/null +++ b/files/fr/web/javascript/reference/operators/less_than_or_equal/index.html @@ -0,0 +1,99 @@ +--- +title: Inférieur ou égal (<=) +slug: Web/JavaScript/Reference/Operators/Less_than_or_equal +tags: + - JavaScript + - Language feature + - Operator + - Reference +translation-of: Web/JavaScript/Reference/Operators/Less_than_or_equal +browser-compat: javascript.operators.less_than_or_equal +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur inférieur ou égal (<code><=</code>) renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à l'opérande droit et <code>false</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-less-than-or-equal.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x <= y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérandes sont comparés avec l'algorithme de <a href="https://tc39.es/ecma262/#sec-abstract-relational-comparison">comparaison abstraite relationnelle</a>. Voir la documentation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">l'opérateur inférieur strict</a> pour un résumé de cet algorithme.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="number_to_number_comparison">Comparaison numérique</h3> + +<pre class="brush: js"> +console.log(5 <= 3); // false +console.log(3 <= 3); // true +console.log(3 <= 5); // true +</pre> + +<h3 id="number_to_bigint_comparison">Comparaison entre un nombre et un BigInt</h3> + +<pre class="brush: js"> +console.log(5n <= 3); // false +console.log(3 <= 3n); // true +console.log(3 <= 5n); // true +</pre> + +<h3 id="string_to_string_comparison">Comparaison entre chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("a" <= "b"); // true +console.log("a" <= "a"); // true +console.log("a" <= "3"); // false +</pre> + +<h3 id="string_to_number_comparison">Comparaison entre nombres et chaînes de caractères</h3> + +<pre class="brush: js"> +console.log("5" <= 3); // false +console.log("3" <= 3); // true +console.log("3" <= 5); // true + +console.log("coucou" <= 5); // false +console.log(5 <= "coucou"); // false +</pre> + +<h3 id="comparing_boolean_null_undefined_nan">Comparaison avec des booléens, null, undefined, NaN</h3> + +<pre class="brush: js"> +console.log(true <= 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 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal">L'opérateur supérieur ou égal</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than">L'opérateur supérieur strict</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than">L'opérateur inférieur strict</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_and/index.html b/files/fr/web/javascript/reference/operators/logical_and/index.html new file mode 100644 index 0000000000..c40d0a1c2c --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_and/index.html @@ -0,0 +1,157 @@ +--- +title: ET logique (&&) +slug: Web/JavaScript/Reference/Operators/Logical_AND +tags: + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_and +translation-of: Web/JavaScript/Reference/Operators/Logical_AND +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur ET logique (<code>&&</code>) (conjonction logique) renvoie vrai si et uniquement si ses deux opérandes sont <code>true</code> ou équivalents à <code>true</code>. Il est généralement utilisé avec des valeurs booléennes et, quand c'est le cas, il renvoie une valeur booléenne. Toutefois, l'opérateur <code>&&</code> renvoie en fait la valeur d'un de ses opérandes et, si cet opérateur est utilisé avec des valeurs non-booléennes, il renverra une valeur non-booléenne.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-and.html", "shorter")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>expr1</var> && <var>expr2</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Si <code>expr1</code> peut être converti en <code>true</code>, le résultat sera <code>expr2</code> ; sinon, ce sera <code>expr1</code>. +</p> + +<p>Si une valeur peut être convertie en <code>true</code>, elle peut être qualifiée de <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. Si une valeur peut être convertie en <code>false</code>, on la qualifiera alors de <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p> + +<p>Parmi les expressions qui peuvent être converties en <code>false</code>, on a :</p> + +<ul> + <li><code>null</code> ;</li> + <li><code>NaN</code> ;</li> + <li><code>0</code> ;</li> + <li>la chaîne de caractères vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li> + <li><code>undefined</code>.</li> +</ul> + +<p>Bien que l'opérateur <code>&&</code> puisse être utilisé avec des opérandes qui ne soient pas des valeurs booléennes, il reste un opérateur booléen, car sa valeur de retour peut toujours être convertie en <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">une valeur primitive booléenne</a>. Pour convertir explicitement la valeur de retour (ou tout expression de façon plus générale) dans sa valeur booléenne correspondante, on pourra utiliser un double <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT">opérateur NON (<code>!</code>)</a> ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean"><code>Boolean()</code></a>.</p> + +<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3> + +<p>L'expression utilisant un ET logique est évaluée de gauche à droite. Le moteur cherche s'il est possible d'utiliser un court-circuit de la façon suivante :</p> + +<p><code>(une expression équivalente à faux) && <var>expr</var></code> sera court-circuité pour fournir directement le résultat de l'expression équivalente à faux.</p> + +<p>Cette notion de court-circuit indique que la partie <code><var>expr</var></code> ci-avant <strong>n'est pas évaluée</strong>, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si <code><var>expr</var></code> est un appel de fonction, la fonction n'est pas appelée). Ce fonctionnement a lieu, car la valeur du résultat peut d'office être déterminée par l'évaluation du premier opérande. Par exemple :</p> + +<pre class="brush: js"> +function A(){ + console.log('A a été appelée'); + return false; +} + +function B(){ + console.log('B a été appelée'); + return true; +} + +console.log( A() && B() ); +// affichera "A a été appelée" dans la console via l'appel de la fonction +// puis affichera false (la valeur du résultat de l'expression avec l'opérateur) +// on voit que la fonction B n'est pas du tout appelée +</pre> + +<h3 id="operator_precedence">Précédence des opérateurs</h3> + +<p>Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur <code>&&</code> est exécuté avant l'opérateur <code>||</code> (voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">l'article sur la précédence des opérateurs</a>).</p> + +<pre class="brush: js"> +true || false && 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 +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_AND">Utiliser le ET logique</h3> + +<p>Le code suivant illustre quelques usages de l'opérateur ET logique <code>&&</code>.</p> + +<pre class="brush: js"> +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 +</pre> + +<h3 id="conversion_rules_for_booleans">Règles de conversion booléennes</h3> + +<h4 id="converting_and_to_or">Convertir ET en OU</h4> + +<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p> + +<pre class="brush: js"> +bCondition1 && bCondition2 +</pre> + +<p>sera toujours équivalente à :</p> + +<pre class="brush: js"> +!(!bCondition1 || !bCondition2) +</pre> + +<h4 id="converting_or_to_and">Convertir OU en ET</h4> + +<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p> + +<pre class="brush: js"> +bCondition1 || bCondition2 +</pre> + +<p>sera toujours équivalente à :</p> + +<pre class="brush: js"> +!(!bCondition1 && !bCondition2) +</pre> + +<h3 id="removing_nested_parentheses">Retrait des parenthèses imbriquées</h3> + +<p>Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer les parenthèses d'une expression complexe en suivant quelques règles.</p> + +<p>L'opération composite suivant, qui utilise des <strong>booléens</strong> :</p> + +<pre class="brush: js"> +bCondition1 || (bCondition2 && bCondition3) +</pre> + +<p>sera toujours égale à :</p> + +<pre class="brush: js"> +bCondition1 || bCondition2 && bCondition3 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li> + <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li> + <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html new file mode 100644 index 0000000000..e788d794d6 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_and_assignment/index.html @@ -0,0 +1,78 @@ +--- +title: Affectation après ET logique (&&=) +slug: Web/JavaScript/Reference/Operators/Logical_AND_assignment +tags: + - JavaScript + - Language feature + - Logical assignment + - Operator + - Reference +browser-compat: javascript.operators.logical_and_assignment +translation-of: Web/JavaScript/Reference/Operators/Logical_AND_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après ET logique (<code>x &&= y</code>) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est <a href="/fr/docs/Glossary/Truthy">équivalent à vrai (<i>truthy</i>)</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-and-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>expr1</var> &&= <var>expr2</var> +</pre> + +<h2 id="description">Description</h2> + +<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3> + +<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND">ET logique</a> est évalué de gauche à droite et le moteur vérifie s'il peut utiliser un court-circuit avec la régle suivante :</p> + +<p><code>(une expression équivalente à faux) && expr</code> sera court-circuitée pour fournir directement l'expression équivalente à faux.</p> + +<p>Ce « court-circuit » indique que <code><var>expr</var></code> <strong>n'est pas évaluée</strong>. Tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple si <code><var>expr</var></code> est un appel de fonction, la fonction n'est pas exécutée).</p> + +<p>L'opérateur d'affectation après ET logique utilise également ce court-circuit et <code>x &&= y</code> est donc équivalent à :</p> + +<pre class="brush: js"> +x && (x = y); +</pre> + +<p>En revanche, <strong>il n'est pas équivalent</strong> à ce qui suit, et qui effectue quoi qu'il arrive une affectation :</p> + +<pre class="brush: js example-bad"> +x = x && y; +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_logical_and_assignment">Utiliser l'affectation après ET logique</h3> + +<pre class="brush: js"> +let x = 0; +let y = 1; + +x &&= 0; // 0 +x &&= 1; // 0 +y &&= 1; // 1 +y &&= 0; // 0 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND">L'opérateur ET logique (&&)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment">L'opérateur d'affectation après ET binaire (<code>&=</code>)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Le type <code>Boolean</code></a> + <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li> + <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_not/index.html b/files/fr/web/javascript/reference/operators/logical_not/index.html new file mode 100644 index 0000000000..da1f26ea14 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_not/index.html @@ -0,0 +1,95 @@ +--- +title: NON logique (!) +slug: Web/JavaScript/Reference/Operators/Logical_NOT +tags: + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_not +translation-of: Web/JavaScript/Reference/Operators/Logical_NOT +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur logique NON (<code>!</code>) prend l'opposé logique de la valeur fournie par son opérande. Vrai devient faux et vice versa. Il est généralement utilisé avec les <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">booléens</a>. Lorsque cet opérateur est utilisé avec une valeur non-booléenne, il renvoie <code>false</code> si son opérande peut être converti en <code>true</code> et <code>true</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-not.html", "shorter")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +!<var>expr</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Cet opérateur renvoie <code>false</code> si son opérande peut être converti en <code>true</code> ; sinon il renvoie <code>true</code>.</p> + +<p>Si une valeur peut être convertie en <code>true</code>, on dira en anglais qu'elle est <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. À l'inverse, si elle peut être convertie en <code>false</code>, on dira en anglais qu'elle est <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p> + +<p>Voici des exemples d'expression qui peuvent être converties en <code>false</code> :</p> + +<ul> + <li><code>null</code> ;</li> + <li><code>NaN</code> ;</li> + <li><code>0</code> ;</li> + <li>la chaîne vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li> + <li><code>undefined</code>.</li> +</ul> + +<p>Bien que l'opérateur <code>!</code> puisse être utilisé avec des opérandes non booléens, sa valeur de retour sera toujours un <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">booléen</a>. Pour convertir une valeur (ou une expression) en sa valeur booléenne correspondante, on pourra utiliser un double NON ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_NOT">Utiliser NON</h3> + +<p>Le code suivant illustre l'utilisation de l'opérateur <code>!</code> pour le NON logique.</p> + +<pre class="brush: js"> +let n1 = !true // !t renvoie false +let n2 = !false // !f renvoie true +let n3 = !'' // !f renvoie true +let n4 = !'Cat' // !t renvoie false +</pre> + +<h3 id="Double_NOT_!!">Double NON (<code>!!</code>)</h3> + +<p>Il est possible d'utiliser deux opérateurs NON à la suite pour convertir n'importe quelle valeur en booléen selon qu'elle est <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a> ou <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p> + +<p>Une conversion équivalente pourra être obtenue avec le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>.</p> + +<pre class="brush: js"> +let n1 = !!true // !!truthy renvoie true +let n2 = !!{} // !!truthy renvoie true : <strong>tout</strong> objet est truthy +let n3 = !!(new Boolean(false)) // Attention, un objet Boolean est toujours truthy ! +let n4 = !!false // !!falsy renvoie false +let n5 = !!"" // !!falsy renvoie false +let n6 = !!Boolean(false) // !!falsy renvoie false +</pre> + +<h3 id="Converting_between_NOTs">Équivalence booléenne de la double négation</h3> + +<p>L'expression qui suit, utilisée avec des booléens :</p> + +<pre class="brush: js">!!bCondition</pre> + +<p>est toujours égale à :</p> + +<pre class="brush: js">bCondition</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li>{{jsxref("Boolean")}}</li> + <li>{{Glossary("Truthy")}}</li> + <li>{{Glossary("Falsy")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html new file mode 100644 index 0000000000..4860c3558b --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_nullish_assignment/index.html @@ -0,0 +1,78 @@ +--- +title: Affectation après coalescence des nuls (??=) +slug: Web/JavaScript/Reference/Operators/Logical_nullish_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_nullish_assignment +translation-of: Web/JavaScript/Reference/Operators/Logical_nullish_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après coalescence des nuls (<code>x ??= y</code>) effectue une affectation uniquement si l'opérande de gauche (<code>x</code>) vaut <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>undefined</code></a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-nullish-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>expr1</var> ??= <var>expr2</var> +</pre> + +<h2 id="description">Description</h2> + +<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3> + +<p>L'opérateur de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">coalescence des nuls</a> est évalué de gauche à droite et le moteur teste s'il est possible d'utiliser un court-circuit grâce à la règle suivante :</p> + +<p><code>(une expression qui renvoie null ou undefined) ?? expr</code> sera court-circuité pour fournir l'opérande gauche si celle-ci ne vaut ni <code>null</code> ni <code>undefined</code>.</p> + +<p>Ce « court-circuit » implique que l'expression <code><var>expr</var></code> <strong>n'est pas évaluée</strong> si ce n'est pas nécessaire. Ainsi, tout effet de bord lié à celle-ci n'aura pas lieu (par exemple, si <code><var>expr</var></code> appelle une fonction, cette dernière n'est pas exécutée).</p> + +<p>L'opérateur d'affectation après coalescence des nuls obéit également à cette logique. Ainsi, <code>x ??= y</code> sera équivalent à :</p> + +<pre class="brush: js"> +x ?? (x = y); +</pre> + +<p>En revanche, ce ne sera pas équivalent à l'expression suivante qui effectue une affectation quoi qu'il arrive :</p> + +<pre class="brush: js example-bad"> +x = x ?? y; +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_logical_nullish_assignment">Utiliser l'opérateur d'affectation après coalescence des nuls</h3> + +<pre class="brush: js"> +function config(options) { + options.duration ??= 100; + options.speed ??= 25; + return options; +} + +config({ duration: 125 }); // { duration: 125, speed: 25 } +config({}); // { duration: 100, speed: 25 } +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li> + <li><a href="/fr/docs/Glossary/Nullish"><i>Nullish</i></a></li> + <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li> + <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_or/index.html b/files/fr/web/javascript/reference/operators/logical_or/index.html new file mode 100644 index 0000000000..b3c22c6874 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_or/index.html @@ -0,0 +1,158 @@ +--- +title: OU logique (||) +slug: Web/JavaScript/Reference/Operators/Logical_OR +tags: + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_or +translation-of: Web/JavaScript/Reference/Operators/Logical_OR +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur OU logique (<code>||</code>) (disjonction logique) renvoie vrai si et seulement si au moins un de ses opérandes est vrai. Cet opérateur est généralement utilisé avec des valeurs booléennes et, lorsque c'est le cas, il renvoie une valeur booléenne. Toutefois, <code>||</code> peut aussi être utilisé avec des valeurs non-booléennes et, dans ce cas, renverra une valeur non-booléenne.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-or.html", "shorter")}}</div> + +<h2 id="syntax">Syntax</h2> + +<pre class="brush: js"> +<var>expr1</var> || <var>expr2</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Si <code>expr1</code> peut être converti en <code>true</code>, c'est <code>expr1</code> qui sera renvoyé, sinon ce sera <code>expr2</code>.</p> + +<p>Si une valeur peut être convertie en <code>true</code>, elle peut être qualifiée de <a href="/fr/docs/Glossary/Truthy"><i>truthy</i></a>. Si une valeur peut être convertie en <code>false</code>, on la qualifiera alors de <a href="/fr/docs/Glossary/Falsy"><i>falsy</i></a>.</p> + +<p>Parmi les expressions qui peuvent être converties en <code>false</code>, on a :</p> + +<ul> + <li><code>null</code> ;</li> + <li><code>NaN</code> ;</li> + <li><code>0</code> ;</li> + <li>la chaîne de caractères vide (<code>""</code> ou <code>''</code> ou <code>``</code>) ;</li> + <li><code>undefined</code>.</li> +</ul> + +<p>Bien que l'opérateur <code>||</code> puisse être utilisé avec des opérandes qui ne soient pas des valeurs booléennes, il reste un opérateur booléen, car sa valeur de retour peut toujours être convertie en <a href="/fr/docs/Web/JavaScript/Data_structures#boolean_type">une valeur primitive booléenne</a>. Pour convertir explicitement la valeur de retour (ou tout expression de façon plus générale) dans sa valeur booléenne correspondante, on pourra utiliser un double <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT">opérateur NON (<code>!</code>)</a> ou le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean"><code>Boolean()</code></a>.</p> + +<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3> + +<p>L'expression utilisant un OU logique est évaluée de gauche à droite. Le moteur cherche s'il est possible d'utiliser un court-circuit de la façon suivante :</p> + +<p><code>(une expression équivalente à vrai) && <var>expr</var></code> sera court-circuité pour fournir directement le résultat de l'expression équivalente à vrai.</p> + +<p>Cette notion de court-circuit indique que la partie <code><var>expr</var></code> ci-avant <strong>n'est pas évaluée</strong>, tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple, si <code><var>expr</var></code> est un appel de fonction, la fonction n'est pas appelée). Ce fonctionnement a lieu, car la valeur du résultat peut d'office être déterminée par l'évaluation du premier opérande. Par exemple :</p> + +<pre class="brush: js"> +function A(){ + console.log('A a été appelée'); + return false; +} + +function B(){ + console.log('B a été appelée'); + return true; +} + +console.log( B() || A() ); +// affichera "B a été appelée" dans la console via l'appel de la fonction +// puis affichera true (la valeur du résultat de l'expression avec l'opérateur) +// on voit que la fonction A n'est pas du tout appelée +</pre> + +<h3 id="operator_precedence">Précédence des opérateurs</h3> + +<p>Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur <code>&&</code> est exécuté avant l'opérateur <code>||</code> (voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">l'article sur la précédence des opérateurs</a>).</p> + +<pre class="brush: js"> +true || false && 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 +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_or">Utiliser le OU logique</h3> + +<p>Le code suivant illustre quelques usages de l'opérateur OU logique <code>||</code>.</p> + +<pre class="brush: js"> +o1 = true || true // t || t renvoie true +o2 = false || true // f || t renvoie true +o3 = true || false // t || f renvoie true +o4 = false || (3 == 4) // f || f renvoie false +o5 = 'Chat' || 'Chien' // t || t renvoie "Chat" +o6 = false || 'Chat' // f || t renvoie "Chat" +o7 = 'Chat' || false // t || f renvoie "Chat" +o8 = '' || false // f || f renvoie false +o9 = false || '' // f || f renvoie "" +o10 = false || varObject // f || object renvoie varObject +</pre> + +<div class="notecard note"> + <p><strong>Note :</strong> Si vous utilisez cet opérateur afin de fournir une valeur par défaut à une variable. Soyez conscient⋅e qu'une valeur équivalente à <code>false</code> ne pourra pas être utilisée ainsi. Si vous souhaitez uniquement écarter <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>, privilégiez l'utilisation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">l'opérateur de coalescence des nuls</a>.</p> +</div> + +<h3 id="conversion_rules_for_booleans">Règles de conversion booléennes</h3> + +<h4 id="converting_and_to_or">Convertir ET en OU</h4> + +<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p> + +<pre class="brush: js">bCondition1 && bCondition2</pre> + +<p>sera toujours équivalente à :</p> + +<pre class="brush: js"> +!(!bCondition1 || !bCondition2) +</pre> + +<h4 id="converting_or_to_and">Convertir OU en ET</h4> + +<p>L'opération suivante, utilisant des <strong>booléens</strong> :</p> + +<pre class="brush: js">bCondition1 || bCondition2</pre> + +<p>sera toujours équivalente à :</p> + +<pre class="brush: js"> +!(!bCondition1 && !bCondition2) +</pre> + +<h3 id="removing_nested_parentheses">Retrait des parenthèses imbriquées</h3> + +<p>Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer les parenthèses d'une expression complexe en suivant quelques règles.</p> + +<p>L'opération composite suivante, utilisant des <strong>booléens</strong> :</p> + +<pre class="brush: js"> +bCondition1 && (bCondition2 || bCondition3) +</pre> + +<p>sera toujours équivalente à :</p> + +<pre class="brush: js"> +!(!bCondition1 || !bCondition2 && !bCondition3) +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li> + <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li> + <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html b/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html new file mode 100644 index 0000000000..433c5f2109 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_or_assignment/index.html @@ -0,0 +1,84 @@ +--- +title: Affectation après OU logique (||=) +slug: Web/JavaScript/Reference/Operators/Logical_OR_assignment +tags: + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_or_assignment +translation-of: Web/JavaScript/Reference/Operators/Logical_OR_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après OU logique (<code>x ||= y</code>) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est <a href="/fr/docs/Glossary/Falsy">équivalent à faux (<i>falsy</i>)</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logical-or-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>expr1</var> ||= <var>expr2</var> +</pre> + +<h2 id="description">Description</h2> + +<h3 id="short-circuit_evaluation">Évaluation en court-circuit</h3> + +<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR">OU logique</a> fonctionne ainsi :</p> + +<pre class="brush: js"> +x || y; +// renvoie x lorsque x est équivalent à vrai +// renvoie y lorsque x n'est pas équivalent à vrai +</pre> + +<p>L'opérateur OU logique peut utiliser un court-circuit : le second opérande est uniquement évalué si le premier opérande n'est pas équivalent à vrai.</p> + +<p>L'opérateur d'affectation après OU logique observe les mêmes règles : l'affectation a uniquement lieu si l'opération logique a besoin d'évaluer l'opérande droit. Autrement dit, <code>x ||= y</code> est équivalent à :</p> + +<pre class="brush: js"> +x || (x = y); +</pre> + +<p>En revanche, il n'est pas équivalent à l'expression suivante qui effectue, quoi qu'il arrive, une affectation :</p> + +<pre class="brush: js example-bad"> +x = x || y; +</pre> + +<p>On notera que ce comportement est différent entre les opérateurs binaires et les opérateurs logiques.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="setting_default_content">Affecter une valeur par défaut</h3> + +<p>Dans l'exemple qui suit, si <code>paroles</code> est vide, on y place une valeur par défaut :</p> + +<pre class="brush: js"> +document.getElementById('paroles').textContent ||= 'Aucune parole.' +</pre> + +<p>Ici, la notion de court-circuit est utile, car l'élément ne sera pas mis à jour si ce n'est pas nécessaire. Il n'y aura pas d'effet de bord indésiré comme une autre étape de rendu ou la perte du focus, etc.</p> + +<p>Attention toutefois à la valeur qu'on teste. Si on souhaite affecter une valeur lorsqu'on rencontre une chaîne de caractère vide (équivalente à faux), on pourra utiliser <code>||=</code>. Sinon, si on souhaite uniquement distinguer <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>undefined</code></a>, on utilisera l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator"><code>??=</code></a>.</p> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR">L'opérateur OU logique (||)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">L'opérateur de coalescence des nuls (<code>??</code>)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR_assignment">L'opérateur d'affectation après OU binaire (<code>|=</code>)</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Le type <code>Boolean</code></a> + <li><a href="/fr/docs/Glossary/Truthy"><i>Truthy</i></a></li> + <li><a href="/fr/docs/Glossary/Falsy"><i>Falsy</i></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/multiplication/index.html b/files/fr/web/javascript/reference/operators/multiplication/index.html new file mode 100644 index 0000000000..8729f46328 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/multiplication/index.html @@ -0,0 +1,65 @@ +--- +title: Multiplication (*) +slug: Web/JavaScript/Reference/Operators/Multiplication +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.multiplication +translation-of: Web/JavaScript/Reference/Operators/Multiplication +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de multiplication (<code>*</code>) fournit le produit de la multiplication des deux opérandes.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-multiplication.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var> * <var>y</var> +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="multiplication_using_numbers">Avec des nombres</h3> + +<pre class="brush: js"> 2 * 2 // 4 +-2 * 2 // -4 +</pre> + +<h3 id="multiplication_with_infinity">Avec l'infini</h3> + +<pre class="brush: js"> +Infinity * 0 // NaN +Infinity * Infinity // Infinity +</pre> + +<h3 id="multiplication_with_non-numbers">Avec des valeurs non-numériques</h3> + +<pre class="brush: js"> +'foo' * 2 // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html b/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html new file mode 100644 index 0000000000..13d0a6d9e7 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/multiplication_assignment/index.html @@ -0,0 +1,48 @@ +--- +title: Affectation après multiplication (*=) +slug: Web/JavaScript/Reference/Operators/Multiplication_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.multiplication_assignment +translation-of: Web/JavaScript/Reference/Operators/Multiplication_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de multiplication et d'affectation (<code>*=</code>) multiplie une variable fournie par l'opérande gauche par la valeur fournie par l'opérande droit puis affecte le résultat de l'opération à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-multiplication-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x *= y +<strong>Signification :</strong> x = x * y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_multiplication_assignment">Utiliser l'opérateur de multiplication et d'affectation</h3> + +<pre class="brush: js"> +let truc = 5; +truc *= 2; // 10 +truc *= 'toto'; // NaN</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">L'opérateur de multiplication</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/remainder/index.html b/files/fr/web/javascript/reference/operators/remainder/index.html new file mode 100644 index 0000000000..c5df6dd43d --- /dev/null +++ b/files/fr/web/javascript/reference/operators/remainder/index.html @@ -0,0 +1,80 @@ +--- +title: Reste (%) +slug: Web/JavaScript/Reference/Operators/Remainder +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.remainder +translation-of: Web/JavaScript/Reference/Operators/Remainder +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur du reste (<code>%</code>) renvoie le reste de la division de l'opérande gauche par l'opérande droit. Le résultat a toujours le signe du numérateur.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-remainder.html")}}</div> + +<p>Bien que dans la plupart des langages, <code>%</code> est un opérateur de reste, pour d'autres (par exemple <a href="https://en.wikipedia.org/wiki/Modulo_operation#In_programming_languages">Python, Perl</a>) c'est un opérateur de modulo. Lorsqu'on utilise des valeurs positives, les deux opérateurs sont équivalents mais lorsque le numérateur et de dénominateur ont des signes différents, le reste et le modulo fourniront des signes différents. Pour obtenir une opération équivalente au modulo en JavaScript, on pourra utiliser <code>((a % n ) + n ) % n</code>.</p> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>var1</var> % <var>var2</var> +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="remainder_with_positive_dividend">Reste avec numérateur positif</h3> + +<pre class="brush: js"> +12 % 5 // 2 + 1 % -2 // 1 + 1 % 2 // 1 + 2 % 3 // 2 +5.5 % 2 // 1.5 +</pre> + +<h3 id="remainder_with_negative_dividend">Reste avec numérateur négatif</h3> + +<pre class="brush: js"> +-12 % 5 // -2 +-1 % 2 // -1 +-4 % 2 // -0 +</pre> + +<h3 id="remainder_with_nan">Reste avec NaN</h3> + +<pre class="brush: js"> +NaN % 2 // NaN +</pre> + +<h3 id="remainder_with_infinity">Reste avec l'infini</h3> + +<pre class="brush: js"> +Infinity % 2 // NaN +Infinity % 0 // NaN +Infinity % Infinity // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/remainder_assignment/index.html b/files/fr/web/javascript/reference/operators/remainder_assignment/index.html new file mode 100644 index 0000000000..87a47940d9 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/remainder_assignment/index.html @@ -0,0 +1,50 @@ +--- +title: Affectation après reste (%=) +slug: Web/JavaScript/Reference/Operators/Remainder_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.remainder_assignment +translation-of: Web/JavaScript/Reference/Operators/Remainder_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de reste et d'affectation (<code>%=</code>) calcule le reste de la division de l'opérande gauche par l'opérande droit et affecte ce résultat à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-remainder-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x %= y +<strong>Signification :</strong> x = x % y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_remainder_assignment">Utiliser l'opérateur de reste et d'affectation</h3> + +<pre class="brush: js"> +let truc = 5; +truc %= 2; // 1 +truc %= 'toto'; // NaN +truc %= 0; // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">L'opérateur de reste</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/right_shift/index.html b/files/fr/web/javascript/reference/operators/right_shift/index.html new file mode 100644 index 0000000000..79c94864a3 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/right_shift/index.html @@ -0,0 +1,67 @@ +--- +title: Décalage binaire à droite (>>) +slug: Web/JavaScript/Reference/Operators/Right_shift +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.right_shift +translation-of: Web/JavaScript/Reference/Operators/Right_shift +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de <strong>décalage binaire à droite (<code>>></code>)</strong> décale la séquence de bits représentée par le premier opérande d'autant de bits vers la droite que le nombre indiqué par le second opérande. Les bits en excès à droite sont écartés. Pour le remplissage des bits par la gauche, c'est le bit le plus à gauche initialement qui est recopié autant de fois que nécessaire. Aussi, le bit le plus à gauche dans le résultat sera le même que le bit le plus à gauche de l'opérande et les deux valeurs auront donc le même signe.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-right-shift.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> >> <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Cet opérateur décale les bits de la valeur fournie par le premier opérande d'autant de fois qu'indiqué par le deuxième opérande. Les bits en excès à droite sont écartés et pour les bits les plus à gauche, c'est le bit initialement le plus à gauche qui est dupliqué. On garde ainsi le même signe entre la valeur du premier opérande et la valeur fournie par le résultat.</p> + +<p>Ainsi, <code>9 >> 2</code> donnera <code>2</code> :</p> + +<pre class="brush: js"> + 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- + 9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>De même, <code>-9 >> 2</code> donnera <code>-3</code>, car le signe est préservé :</p> + +<pre class="brush: js"> + -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- + -9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10) +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_right_shift">Utiliser le décalage à droite</h3> + +<pre class="brush: js"> + 9 >> 2; // 2 +-9 >> 2; // -3 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift_assignment">L'opérateur de décalage binaire à droite et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html new file mode 100644 index 0000000000..1674985313 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/right_shift_assignment/index.html @@ -0,0 +1,51 @@ +--- +title: Affectation après décalage à droite (>>=) +slug: Web/JavaScript/Reference/Operators/Right_shift_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.right_shift_assignment +translation: Web/JavaScript/Reference/Operators/Right_shift_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de décalage à droite et d'affectation (<code>>>=</code>) décale la séquence de bits indiquée par l'opérande gauche d'autant de bits qu'indiqués par l'opérande droit puis affecte le résultat obtenu à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-right-shift-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x >>= y +<strong>Signification :</strong> x = x >> y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_right_shift_assignment">Utiliser l'opérateur de décalage à droite et d'affectation</h3> + +<pre class="brush: js"> +let a = 5; // (00000000000000000000000000000101) +a >>= 2; // 1 (00000000000000000000000000000001) + +let b = -5; // (-00000000000000000000000000000101) +b >>= 2; // -2 (-00000000000000000000000000000010) +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift">L'opérateur de décalage à droite</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/strict_equality/index.html b/files/fr/web/javascript/reference/operators/strict_equality/index.html new file mode 100644 index 0000000000..ba45dffaae --- /dev/null +++ b/files/fr/web/javascript/reference/operators/strict_equality/index.html @@ -0,0 +1,100 @@ +--- +title: Égalité stricte (===) +slug: Web/JavaScript/Reference/Operators/Strict_equality +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.strict_equality +translation-of: Web/JavaScript/Reference/Operators/Strict_equality +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'égalité stricte (<code>===</code>) vérifie si ses deux opérandes sont égaux et renvoie un booléen correspondant au résultat. À la différence de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a>, l'opérateur d'égalité stricte considère toujours des opérandes de types différents comme étant différents.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-strict-equality.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x === y +</pre> + +<h2 id="description">Description</h2> + +<p>Les opérateurs d'égalité stricte (<code>===</code> et <code>!==</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">l'algorithme de comparaison d'égalité stricte</a> pour comparer deux opérandes.</p> + +<ul> + <li>Si les opérandes sont de types différents, on renvoie <code>false</code>.</li> + <li>Si les deux opérandes sont des objets, on renvoie <code>true</code> uniquement s'ils réfèrent au même objet.</li> + <li>Si les deux opérandes valent <code>null</code> ou si les deux opérandes valent <code>undefined</code>, on renvoie <code>true</code>.</li> + <li>Si au moins l'un des opérandes vaut <code>NaN</code>, on renvoie <code>false</code>.</li> + <li>Sinon, on compare la valeur des deux opérandes : + <ul> + <li>Les nombres doivent avoir la même valeur. <code>+0</code> and <code>-0</code> sont considérés comme égaux.</li> + <li>Les chaînes de caractères doivent avoir les mêmes caractères, dans le même ordre.</li> + <li>Les booléens doivent avoir la même valeur (tous les deux <code>true</code> ou tous les deux <code>false</code>).</li> + </ul> + </li> +</ul> + +<p>La différence fondamentale avec <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a> (<code>==</code>) est que, lorsque les opérandes sont de types différents, <code>==</code> tentera une conversion vers un type commun avant la comparaison.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="comparing_operands_of_the_same_type">Comparaison d'opérandes de même type</h3> + +<pre class="brush: js"> +console.log("hello" === "hello"); // true +console.log("hello" === "hola"); // false + +console.log(3 === 3); // true +console.log(3 === 4); // false + +console.log(true === true); // true +console.log(true === false); // false + +console.log(null === null); // true +</pre> + +<h3 id="comparing_operands_of_different_types">Comparaison d'opérandes de types différents</h3> + +<pre class="brush: js"> +console.log("3" === 3); // false + +console.log(true === 1); // false + +console.log(null === undefined); // false +</pre> + +<h3 id="comparing_objects">Comparaison d'objets</h3> + +<pre class="brush: js"> +const objet1 = { + name: "coucou" +} + +const objet2 = { + name: "coucou" +} + +console.log(objet1 === objet2); // false +console.log(objet1 === objet1); // true +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/strict_inequality/index.html b/files/fr/web/javascript/reference/operators/strict_inequality/index.html new file mode 100644 index 0000000000..d436d5af46 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/strict_inequality/index.html @@ -0,0 +1,97 @@ +--- +title: Inégalité stricte (!==) +slug: Web/JavaScript/Reference/Operators/Strict_inequality +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.strict_inequality +translation-of: Web/JavaScript/Reference/Operators/Strict_inequality +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'inégalité stricte (<code>!==</code>) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">l'opérateur d'inégalité</a>, l'opérateur d'inégalité stricte considère toujours des opérandes de types différents comme étant différents.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-strict-inequality.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +x !== y +</pre> + +<h2 id="description">Description</h2> + +<p>L'opérateur d'inégalité stricte vérifie que ses deux opérandes ne sont pas égaux. Il s'agit de la négation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">l'opérateur d'égalité stricte</a>. Les deux expressions suivantes fourniront toujours le même résultat :</p> + +<pre class="brush: js"> +x !== y +!(x === y) +</pre> + +<p>Pour plus de détails sur l'algorithme de comparaison utilisé, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">la page sur l'opérateur d'égalité stricte</a>.</p> + +<p>À l'instar de l'opérateur d'égalité stricte, l'opérateur d'inégalité stricte considèrera toujours des opérandes de types différents comme étant différents :</p> + +<pre class="brush: js"> +3 !== "3"; // true +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="comparing_operands_of_the_same_type">Comparaison d'opérandes de même type</h3> + +<pre class="brush: js"> +console.log("hello" !== "hello"); // false +console.log("hello" !== "hola"); // true + +console.log(3 !== 3); // false +console.log(3 !== 4); // true + +console.log(true !== true); // false +console.log(true !== false); // true + +console.log(null !== null); // false +</pre> + +<h3 id="comparing_operands_of_different_types">Comparaison d'opérandes de types différents</h3> + +<pre class="brush: js"> +console.log("3" !== 3); // true + +console.log(true !== 1); // true + +console.log(null !== undefined); // true +</pre> + +<h3 id="comparing_objects">Comparaison d'objets</h3> + +<pre class="brush: js"> +const objet1 = { + name: "coucou" +} + +const objet2 = { + name: "coucou" +} + +console.log(objet1 !== objet2); // true +console.log(objet1 !== objet1); // false +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality">L'opérateur d'inégalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/subtraction/index.html b/files/fr/web/javascript/reference/operators/subtraction/index.html new file mode 100644 index 0000000000..cdada5f8cb --- /dev/null +++ b/files/fr/web/javascript/reference/operators/subtraction/index.html @@ -0,0 +1,59 @@ +--- +title: Soustraction (-) +slug: Web/JavaScript/Reference/Operators/Subtraction +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.subtraction +translation-of: Web/JavaScript/Reference/Operators/Subtraction +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de soustraction (<code>-</code>) effectue la soustraction entre les deux opérandes et fournit la différence obtenue.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-subtraction.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> <var>x</var> - <var>y</var> +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="subtraction_with_numbers">Avec des valeurs numériques</h3> + +<pre class="brush: js"> +5 - 3 // 2 +3 - 5 // -2 +</pre> + +<h3 id="subtraction_with_non-numbers">Avec des valeurs non-numériques</h3> + +<pre class="brush: js"> +'toto' - 3 // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html b/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html new file mode 100644 index 0000000000..ad67f469d6 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/subtraction_assignment/index.html @@ -0,0 +1,49 @@ +--- +title: Affectation après soustraction (-=) +slug: Web/JavaScript/Reference/Operators/Subtraction_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.subtraction_assignment +translation-of: Web/JavaScript/Reference/Operators/Subtraction_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur d'affectation après soustraction (<code>-=</code>) calcule la soustraction de l'opérande gauche par l'opérande droit puis affecte le résultat à la variable représentée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-subtraction-assignment.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x -= y +<strong>Signification :</strong> x = x - y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_subtraction_assignment">Utiliser l'opérateur de soustraction et d'affectation</h3> + +<pre class="brush: js"> +let truc = 5; +truc -= 2; // 3 +truc -= 'toto'; // NaN +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">L'opérateur de soustraction</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/unary_negation/index.html b/files/fr/web/javascript/reference/operators/unary_negation/index.html new file mode 100644 index 0000000000..bbe81aaeb6 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/unary_negation/index.html @@ -0,0 +1,65 @@ +--- +title: Négation unaire (-) +slug: Web/JavaScript/Reference/Operators/Unary_negation +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.unary_negation +translation_of: Web/JavaScript/Reference/Operators/Unary_negation +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de négation unaire (<code>-</code>) se place devant son opérande et le transforme en son opposé.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-unary-negation.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> -<var>x</var> +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="negating_numbers">Avec des nombres</h3> + +<pre class="brush: js">const x = 3; +const y = -x; + +// y = -3 +// x = 3 +</pre> + +<h3 id="negating_non-numbers">Avec des valeurs non-numériques</h3> + +<p>L'opérateur de négation unaire peut être utilisé pour convertir une valeur non-numérique en nombre.</p> + +<pre class="brush: js">const x = "4"; +const y = -x; + +// y = -4 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus">Opérateur plus unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/unary_plus/index.html b/files/fr/web/javascript/reference/operators/unary_plus/index.html new file mode 100644 index 0000000000..37e7148369 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/unary_plus/index.html @@ -0,0 +1,69 @@ +--- +title: Plus unaire (+) +slug: Web/JavaScript/Reference/Operators/Unary_plus +tags: + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.unary_plus +translation_of: Web/JavaScript/Reference/Operators/Unary_plus +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de plus unaire (<code>+</code>) précède son opérande et évalue son opérande en essayant de le convertir en nombre si ce n'est pas déjà une valeur numérique.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-unary-plus.html", "taller")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> +<var>x</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Bien que la négation unaire (<code>-</code>) puisse également être utilisée pour convertir des valeurs non-numérique, le plus unaire est plus rapide et plus conventionnel, car il n'effectue pas d'autres opérations que la conversion. Il peut être utilisé pour convertir les représentations textuelles d'entiers ou de flottants ainsi que les valeurs <code>true</code>, <code>false</code>, et <code>null</code>. Les représentations entières au format décimal ou hexadécimal sont toutes les deux prises en charge. Les nombres négatifs sont pris en charge (hors représentation hexadécimale). L'utilisation de cet opérateur sur les valeurs de type <code>BigInt</code> déclenchera une exception <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError"><code>TypeError</code></a>. Si l'analyse de valeur ne permet pas de déduire une valeur numérique, le résultat sera <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a>.</p> + +<h2 id="examples">Exemples</h2> + +<h3 id="usage_with_numbers">Avec des nombres</h3> + +<pre class="brush: js">const x = 1; +const y = -1; + +console.log(+x); +// 1 +console.log(+y); +// -1</pre> + +<h3 id="usage_with_non-numbers">Avec des valeurs non-numériques</h3> + +<pre class="brush: js">+true // 1 ++false // 0 ++null // 0 ++function(val){ return val } // NaN ++1n // throws TypeError: Cannot convert BigInt value to number +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Addition">Opérateur d'addition</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction">Opérateur de soustraction</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Division">Opérateur de division</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication">Opérateur de multiplication</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder">Opérateur de reste</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation">Opérateur d'exponentiation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Increment">Opérateur d'incrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Decrement">Opérateur de décrémentation</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation">Opérateur de négation unaire</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html b/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html new file mode 100644 index 0000000000..e3255ae767 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/unsigned_right_shift/index.html @@ -0,0 +1,66 @@ +--- +title: Décalage binaire à droite non-signé (>>>) +slug: Web/JavaScript/Reference/Operators/Unsigned_right_shift +tags: + - Bitwise operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.unsigned_right_shift +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de <strong>décalage binaire à droite non-signé (<code>>>></code>)</strong> décale la séquence de bits formée par le premier opérande d'autant de bits vers la droite que la valeur indiquée par le second opérande. Les bits en excès à droite sont écartés et ce sont des zéros qui sont ajoutés à gauches. Le bit de signe devient alors nécessairement <code>0</code> et le résultat est donc positif. À la différence des autres opérateurs binaires, cet opérateur renvoie un entier non-signé sur 32 bits.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift.html")}}</div> + +<h2 id="syntax">Syntaxe</h2> + +<pre class="brush: js"> +<var>a</var> >>> <var>b</var> +</pre> + +<h2 id="description">Description</h2> + +<p>Ce opérateur décale les bits du premier opérande vers la droite, selon la valeur du deuxième opérande. Les bits dépassant à droite sont éliminés tandis que des zéros sont ajoutés à gauche. Le bit de signe vaut alors <code>0</code> et en conséquence le résultat est positif. La valeur fournie par cet opérateur, à la différence des autres opérateurs binaires, est une valeur entière sur 32 bits non-signée.</p> + +<p>Pour les nombres positifts, le décalage binaire à droite et le décalage binaire à droite non-signés renverront le même résultat. Par exemple, <code>9 >>> 2</code> renvoie 2, également renvoyé par <code>9 >> 2</code>:</p> + +<pre class="brush: js"> + 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- + 9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>Toutefois, ce n'est pas le cas pour les nombres négatifs : <code>-9 >>> 2</code> renverra 1073741821, qui est différent de <code>-9 >> 2</code> (qui renvoie <code>-3</code>) :</p> + +<pre class="brush: js"> + -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- + -9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_unsigned_right_shift">Utiliser le décalage à droite non-signé</h3> + +<pre class="brush: js"> + 9 >>> 2; // 2 +-9 >>> 2; // 1073741821 +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise">Les opérateurs binaires dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment">L'opérateur de décalage binaire à droite non-signé et d'affectation</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html b/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html new file mode 100644 index 0000000000..1196307586 --- /dev/null +++ b/files/fr/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html @@ -0,0 +1,51 @@ +--- +title: Affectation après décalage à droite non signé (>>>=) +slug: Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference +browser-compat: javascript.operators.unsigned_right_shift_assignment +translation-of: Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>L'opérateur de décalage à droite non signé et d'affectation (<em><code>>>>=</code></em>) décale la séquence de bits fournie par l'opérande gauche vers la droite, d'autant de bits qu'indiqués par l'opérande droit, puis affecte le résultat de l'opération à la variable indiquée par l'opérande gauche.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-unsigned-right-shift-assignment.html")}}</div> + +<h2 id="syntax">Syntax</h2> + +<pre class="brush: js"> +<strong>Opérateur :</strong> x >>>= y +<strong>Signification :</strong> x = x >>> y +</pre> + +<h2 id="examples">Exemples</h2> + +<h3 id="using_unsigned_right_shift_assignment">Utiliser l'opérateur de décalage à droite non signé et d'affectation</h3> + +<pre class="brush: js"> +let a = 5; // (00000000000000000000000000000101) +a >>>= 2; // 1 (00000000000000000000000000000001) + +let b = -5; // (-00000000000000000000000000000101) +b >>>= 2; // 1073741822 (00111111111111111111111111111110) +</pre> + +<h2 id="specifications">Spécifications</h2> + +<p>{{Specifications}}</p> + +<h2 id="browser_compatibility">Compatibilité des navigateurs</h2> + +<p>{{Compat}}</p> + +<h2 id="see_also">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment">Les opérateurs d'affectation dans le guide JavaScript</a></li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift">L'opérateur de décalage à droite</a></li> +</ul> |