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 (les expressions indiquées comme opérandes peuvent être de n'importe quel type et pas nécessairement être booléennes au sens strict) :

Opé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 peuvent être converties en 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 peut être convertie en 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.

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

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

  • null,
  • NaN,
  • 0,
  • la chaîne vide ("" ou '' 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 partien'importe quoi des expressions mentionnées ci-dessus ne sera jamais évaluée, et que tout effet de bord éventuel induit par cette évaluation ne se produira pas.

Ainsi, les deux fonctions suivantes sont équivalentes :

function courtCircuit() {
  // OU logique
  faireQuelqueChose() || faireAutreChose();

 faireQuelqueChose() && faireAutreChose();    
}

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

  var andFlag = faireQuelqueChose();
  if (andFlag) {
    faireAutreChose();
  }
}

Précédence des opérateurs

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

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

ET logique (&&)

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

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

OU logique (||)

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

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

NON logique(!)

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

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

Utilisation de la double négation

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

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

Règles de conversions

Convertir un ET logique avec des OU logiques

L'opération suivante

condition1 && condition2

sera toujours égale à :

!(!condition1 || !condition2)

Convertir un OU logique avec des ET logiques

L'opération suivante :

condition1 || condition2

sera toujours égale à :

!(!condition1 && !condition2)

Convertir des NON logiques successifs

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

!!condition

elle sera toujours équivalente à

condition

Retirer les parenthèses imbriquées

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

Retirer les parenthèses d'un ET imbriqué

Cette opération :

condition1 || (condition2 && condition3)

sera toujours équivalente à :

condition1 || condition2 && condition3

Retirer les parenthèses d'un OU imbriqué

Cette opération :

condition1 && (condition2 || condition3)

sera toujours équivalente à :

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

Spécifications

Spécification État Commentaires
ECMAScript 1st Edition (ECMA-262) Standard Définition initiale.
ECMAScript 5.1 (ECMA-262) Standard Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires
ECMAScript 2015 (6th Edition, ECMA-262) Standard Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires
ECMAScript Latest Draft (ECMA-262) Projet Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires

Compatibilité des navigateurs

Update compatibility data on GitHub
OrdinateurMobileServeur
ChromeEdgeFirefoxInternet ExplorerOperaSafariWebview AndroidChrome pour AndroidEdge MobileFirefox pour AndroidOpera pour AndroidSafari sur iOSSamsung InternetNode.js
Logical AND (&&)Chrome Support complet OuiEdge Support complet OuiFirefox Support complet 1IE Support complet OuiOpera Support complet OuiSafari Support complet OuiWebView Android Support complet OuiChrome Android Support complet OuiEdge Mobile Support complet OuiFirefox Android Support complet 4Opera Android Support complet OuiSafari iOS Support complet OuiSamsung Internet Android Support complet Ouinodejs Support complet Oui
Logical OR (||)Chrome Support complet OuiEdge Support complet OuiFirefox Support complet 1IE Support complet OuiOpera Support complet OuiSafari Support complet OuiWebView Android Support complet OuiChrome Android Support complet OuiEdge Mobile Support complet OuiFirefox Android Support complet 4Opera Android Support complet OuiSafari iOS Support complet OuiSamsung Internet Android Support complet Ouinodejs Support complet Oui
Logical NOT (!)Chrome Support complet OuiEdge Support complet OuiFirefox Support complet 1IE Support complet OuiOpera Support complet OuiSafari Support complet OuiWebView Android Support complet OuiChrome Android Support complet OuiEdge Mobile Support complet OuiFirefox Android Support complet 4Opera Android Support complet OuiSafari iOS Support complet OuiSamsung Internet Android Support complet Ouinodejs Support complet Oui

Légende

Support complet  
Support complet

Voir aussi

Étiquettes et contributeurs liés au document

Étiquettes : 
Contributeurs à cette page : SphinxKnight, mdnwebdocs-bot, Darkilen, teoli, Jeremie, Mgjbot, Kyodev, BenoitL
Dernière mise à jour par : SphinxKnight,