diff options
| author | SphinxKnight <SphinxKnight@users.noreply.github.com> | 2021-06-27 15:03:56 +0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-06-27 15:03:56 +0200 |
| commit | 9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 (patch) | |
| tree | e6aa6c44ea4c523dbf72464e77745bed1efc8c51 /files/fr/conflicting | |
| parent | dc9842009bd95e0db7e058a5ebb98f27d6a3f650 (diff) | |
| download | translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.gz translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.tar.bz2 translated-content-9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54.zip | |
Fix #756 by updating the JS operators in fr (#1306)
* Update Operators landing + revamp L10N for 4 operators
* Added NOT / ! -
* +multiplication
* Addition, exponentiation and comparison
* Operateurs de comparaison
* Binary ops
* Missing newline, thx GH UI
* Logical AND / OR
* Assignment ops
* Conflicting clean-up
* Missing EOF newline
* Fix history and redirects
* FIX: fix flaws
* FIX: minox typo fix
* FIX: link flaws
* FIX: fix tags detection
Co-authored-by: tristantheb <tristantheb@gmail.com>
Diffstat (limited to 'files/fr/conflicting')
6 files changed, 0 insertions, 1816 deletions
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> |