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.

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 https://github.com/mdn/interactive-examples et à envoyer une pull request !

Description

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

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,
• 0,
• la 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 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();
  }
}

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)

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

Compatibilité des navigateurs

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 pull request sur https://github.com/mdn/browser-compat-data.

Voir aussi

• Les opérateurs binaires