mozilla
Vos résultats de recherche

    Opérateurs logiques

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

    Description

    Les opérateurs logiques sont décrits dans le tableau suivant :

    Opérateur Usage Description
    ET logique (&&) expr1 && expr2 Renvoie expr1 si cette expression peut être convertie en false, sinon renvoie expr2. Donc, lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes valent true, sinon il renvoie false.
    OU logique (||) expr1 || expr2 Renvoie expr1 si cette expression peut être convertie en true, sinon renvoie expr2. Donc, lorsqu'il est utilisé avec des valeurs booléennes, || renvoie true si au moins un des deux opérandes vaut true. Si les deux valent false, il renvoie également false.
    NON logique (!) ! expr Renvoie false si son opérande unique peut être converti en true, sinon il renvoie true.

    Parmi les expressions qui peuvent être converties en false, citons celles qui seront évaluées à null, à 0, à une chaîne vide ("") ou à undefined.

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

    Évaluation court-circuit

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

    • l'évaluation de false && n'importe quoi est court-circuitée en false.
    • l'évaluation de true || n'importe quoi est court-circuitée en true.

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

    Ainsi, les deux fonctions suivantes sont équivalentes :

    function courtCircuit() {
      faireQuelqueChose() || faireAutreChose();
    }
    
    function évaluationÉquivalente() {
      var flag = faireQuelqueChose();
      if (!flag) {
        faireAutreChose();
      }
    }
    

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

    false && true  || true      // returns true
    false && (true || true)     // returns false

    ET logique (&&)

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

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

    OU logique (||)

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

    o1 = true  || true       // t || t renvoie true
    o2 = false || true       // f || t renvoie true
    o3 = true  || false      // t || f renvoie true
    o4 = false || (3 == 4)   // f || f renvoie false
    o5 = "Yip" || "Yop"      // t || t renvoie "Yip"
    o6 = false || "Yip"      // f || t renvoie "Yip"
    o7 = "Yip" || false      // t || f renvoie "Yip"
    

    NON logique(!)

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

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

    Règles de conversions

    Convertir un ET logique avec des OU logiques

    L'opération suivante

    condition1 && condition2

    sera toujours égale à :

    !(!condition1 || !condition2)

    Convertir un OU logique avec des ET logiques

    L'opération suivante :

    condition1 || condition2

    sera toujours égale à :

    !(!condition1 && !condition2)

    Retirer les parenthèses imbriquées

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

    Retirer les parenthèses d'un ET imbriqué

    Cette opération :

    condition1 || (condition2 && condition3)

    sera toujours équivalente à :

    condition1 || condition2 && condition3

    Retirer les parenthèses d'un OU imbriqué

    Cette opération :

    condition1 && (condition2 || condition3)

    sera toujours équivalente à :

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

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale.
    ECMAScript 5.1 (ECMA-262)
    La définition de 'Logical NOT Operator' dans cette spécification.

    ECMAScript 5.1 (ECMA-262)
    La définition de 'Binary Logical Operators' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'Logical NOT operator' dans cette spécification.

    ECMAScript 6 (ECMA-262)
    La définition de 'Binary Logical Operators' dans cette spécification.
    En cours de validation comme recommandation  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    ET logique (&&) (Oui) (Oui) (Oui) (Oui) (Oui)
    OU logique (||) (Oui) (Oui) (Oui) (Oui) (Oui)
    NON logique (!) (Oui) (Oui) (Oui) (Oui) (Oui)
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    ET logique (&&) (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)
    OU logique (||) (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)
    NON logique (!) (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)

    Rétrocompatibilité : Comportement de JavaScript 1.0 et 1.1

    Les opérateurs && et || se comportaient de la façon suivante :

    Opérateur Syntaxe Comportement
    && expr1 && expr2 Si le premier opérande (expr1) peut être converti à false, l'opérateur && renverra false plutôt que la valeur d'expr1.
    || expr1 || expr2 Si le premier opérande (expr1) peut être converti à true, l'opérateur || renverra true plutôt que la valeur d'expr1.

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: Mgjbot, SphinxKnight, Jeremie, BenoitL, teoli, Kyodev
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale