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 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() {
  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)

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 Statut Commentaires
ECMAScript 5.1 (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

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)

 

Voir aussi

Étiquettes et contributeurs liés au document

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