From 9f030ef5fd3a0dc15d94c01d0e1bbd1aba1eed54 Mon Sep 17 00:00:00 2001 From: SphinxKnight Date: Sun, 27 Jun 2021 15:03:56 +0200 Subject: Fix #756 by updating the JS operators in fr (#1306) * Update Operators landing + revamp L10N for 4 operators * Added NOT / ! - * +multiplication * Addition, exponentiation and comparison * Operateurs de comparaison * Binary ops * Missing newline, thx GH UI * Logical AND / OR * Assignment ops * Conflicting clean-up * Missing EOF newline * Fix history and redirects * FIX: fix flaws * FIX: minox typo fix * FIX: link flaws * FIX: fix tags detection Co-authored-by: tristantheb --- .../reference/operators/logical_and/index.html | 157 +++++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 files/fr/web/javascript/reference/operators/logical_and/index.html (limited to 'files/fr/web/javascript/reference/operators/logical_and/index.html') diff --git a/files/fr/web/javascript/reference/operators/logical_and/index.html b/files/fr/web/javascript/reference/operators/logical_and/index.html new file mode 100644 index 0000000000..c40d0a1c2c --- /dev/null +++ b/files/fr/web/javascript/reference/operators/logical_and/index.html @@ -0,0 +1,157 @@ +--- +title: ET logique (&&) +slug: Web/JavaScript/Reference/Operators/Logical_AND +tags: + - JavaScript + - Language feature + - Logical Operator + - Operator + - Reference +browser-compat: javascript.operators.logical_and +translation-of: Web/JavaScript/Reference/Operators/Logical_AND +--- +
{{jsSidebar("Operators")}}
+ +

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

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

Syntaxe

+ +
+expr1 && expr2
+
+ +

Description

+ +

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

+ +

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

+ +

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

+ + + +

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

+ +

Évaluation en court-circuit

+ +

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

+ +

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

+ +

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

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

Précédence des opérateurs

+ +

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

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

Exemples

+ +

Utiliser le ET logique

+ +

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

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

Règles de conversion booléennes

+ +

Convertir ET en OU

+ +

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

+ +
+bCondition1 && bCondition2
+
+ +

sera toujours équivalente à :

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

Convertir OU en ET

+ +

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

+ +
+bCondition1 || bCondition2
+
+ +

sera toujours équivalente à :

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

Retrait des parenthèses imbriquées

+ +

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

+ +

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

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

sera toujours égale à :

+ +
+bCondition1 || bCondition2 && bCondition3
+
+ +

Spécifications

+ +

{{Specifications}}

+ +

Compatibilité des navigateurs

+ +

{{Compat}}

+ +

Voir aussi

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