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.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
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 . |
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 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 (ECMA-262) | Standard évolutif | Définis dans plusieurs sections de la spécification : opérateur NON logique, opérateurs logiques binaires |
Compatibilité des navigateurs
No compatibility data found for javascript.operators.logical
.
Check for problems with this page or contribute missing data to mdn/browser-compat-data.
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
- Le type primitif booléen
- Le constructeur objet
Boolean