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 (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 enfalse
. - l'évaluation de
true || n'importe quoi
est court-circuitée entrue
.
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
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.
Ordinateur | Mobile | Serveur | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Logical AND (&& ) | Chrome Support complet 1 | Edge Support complet 12 | Firefox Support complet 1 | IE Support complet 3 | Opera Support complet Oui | Safari Support complet Oui | WebView Android Support complet 1 | Chrome Android Support complet 18 | Firefox Android Support complet 4 | Opera Android Support complet Oui | Safari iOS Support complet Oui | Samsung Internet Android Support complet 1.0 | nodejs Support complet Oui |
Logical OR (|| ) | Chrome Support complet 1 | Edge Support complet 12 | Firefox Support complet 1 | IE Support complet 3 | Opera Support complet Oui | Safari Support complet Oui | WebView Android Support complet 1 | Chrome Android Support complet 18 | Firefox Android Support complet 4 | Opera Android Support complet Oui | Safari iOS Support complet Oui | Samsung Internet Android Support complet 1.0 | nodejs Support complet Oui |
Logical NOT (! ) | Chrome Support complet 1 | Edge Support complet 12 | Firefox Support complet 1 | IE Support complet 3 | Opera Support complet Oui | Safari Support complet Oui | WebView Android Support complet 1 | Chrome Android Support complet 18 | Firefox Android Support complet 4 | Opera Android Support complet Oui | Safari iOS Support complet Oui | Samsung Internet Android Support complet 1.0 | nodejs Support complet Oui |
Légende
- Support complet
- Support complet
Voir aussi
- Les opérateurs binaires
- Le type primitif booléen
- Le constructeur objet
Boolean