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 (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`.
OU logique (`\|\|`)	`expr1 \|\|expr2`	Renvoie `expr1` si cette expression peut être convertie en `true`, sinon renvoie `expr2`.
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é