Les opérateurs de comparaison comparent les valeurs de deux opérandes et déterminent si l'instruction qu'ils forment est true ou false. L'exemple suivant utilise l'opérateur d'égalité stricte (===) pour comparer deux opérandes: l'expression 2 + 2 et la valeur 4. Étant donné que le résultat de l'expression et la valeur numérique 4 sont identiques, cette expression renvoie true:
2 + 2 === 4
> true
Coercition de type et égalité
Deux des opérateurs de comparaison les plus fréquemment utilisés sont == pour une égalité libre et === pour une égalité stricte. == effectue une comparaison approximative entre deux valeurs en forçant les opérandes à correspondre aux types de données, si possible. Par exemple, 2 == "2" renvoie true, même si la comparaison est effectuée entre une valeur numérique et une valeur de chaîne.
2 == 2
> true
2 == "2"
> true
Il en va de même pour !=, qui ne renvoie true que si les opérandes comparés ne sont pas faiblement égaux.
2 != 3
> true
2 != "2"
> false
Les comparaisons strictes utilisant === ou !== n'effectuent pas de coercition de type. Pour qu'une comparaison stricte soit évaluée sur true, les valeurs comparées doivent avoir le même type de données. De ce fait, 2 == "2" renvoie true, mais 2 === "2" renvoie false:
2 === 3
> false
2 === "2"
> false
Pour éliminer toute ambiguïté qui pourrait résulter de la coercition automatique, utilisez === dans la mesure du possible.
| Opérateur | Description | Utilisation | Résultat |
|---|---|---|---|
| === | Strictement égal | 2 === 2 | true |
| !== | Pas strictement égal | 2 !== "2" | true |
| == | Égal à (ou "grossièrement égal") | 2 == "2" | true |
| != | Not Equal (Non égal à) | 2 != "3" | true |
| > | Supérieur à | 3 > 2 | true |
| >= | Supérieur ou égal à | 2 >= 2 | true |
| < | Moins de | 2 < 3 | true |
| <= | Inférieur ou égal à | 2 <= 3 | true |
Vrai et faux
Toutes les valeurs en JavaScript sont implicitement true ou false et peuvent être forcées sur la valeur booléenne correspondante, par exemple à l'aide du comparateur "grossièrement égal". Un ensemble limité de valeurs est converti (par coercition) en false:
0nullundefinedNaN- Une chaîne vide (
"")
Toutes les autres valeurs sont converties de manière forcée en true, y compris toute chaîne contenant un ou plusieurs caractères et tous les nombres non nuls. Ce sont des valeurs communément appelées
« vérité » et « fausse ».
"My string" == true
> true
100 == true
> true
0 == true
> false
Opérateurs logiques
Utilisez les opérateurs logiques AND (&&), OR (||) et NOT (!) pour contrôler le flux d'un script en fonction de l'évaluation d'au moins deux instructions conditionnelles:
2 === 3 || 5 === 5;
> true
2 === 2 && 2 === "2"
> false
2 === 2 && !"My string."
> false
Une expression logique NOT (!) annule la valeur véridique ou fausse d'un opérande, en évaluant true si l'opérande renvoie false et false si l'opérande renvoie true:
true
> true
!true
> false
!false
> true
L'utilisation de l'opérateur logique NOT (!) devant un autre type de données, comme un nombre ou une chaîne, convertit cette valeur en valeur booléenne et inverse la valeur véridique ou fausse du résultat.
"string"
> "string"
!"string"
> false
0
> 0
!0
> true
Il est courant d'utiliser deux opérateurs NOT pour forcer rapidement la coercition de données dans leur valeur booléenne correspondante:
!!"string"
> true
!!0
> false
Les opérateurs logiques AND et OR n'effectuent pas de coercition seuls. Elles renvoient la valeur de l'un des deux opérandes évalués, l'opérande choisi étant déterminé par cette évaluation.
L'opérateur logique AND (&&) ne renvoie le premier de ses deux opérandes que si son résultat est false, et le deuxième dans le cas contraire. Dans les comparaisons qui évaluent des valeurs booléennes, elle ne renvoie true que si les opérandes des deux côtés de l'opérateur logique AND ont la valeur true. Si l'un ou l'autre des côtés renvoie false, il renvoie false.
true && false
> false
false && true
> false
false && false
> false
true && true
> true
Lorsque && est utilisé avec deux opérandes non booléens, le premier opérande est renvoyé tel quel s'il peut être forcé en false. Si le premier opérande peut être forcé à true, le deuxième opérande est renvoyé tel quel:
false && "My string"
> false
null && "My string"
> null
"My string" && false
> false
"My string" && "My second string"
> "My second string"
2 === 2 && "My string"
> "My string"
L'opérateur logique OU (||) ne renvoie le premier de ses deux opérandes que si son opérande renvoie true, et le deuxième dans le cas contraire. Dans les comparaisons qui renvoient des valeurs booléennes, cela signifie qu'elle renvoie true si l'un des opérandes renvoie true. Si aucun côté n'évalue la valeur true, il renvoie false:
true || false
> true
false || true
> true
true || true
> true
false || false
> false
Lorsque vous utilisez || avec deux opérandes non booléens, il renvoie le premier opérande non modifié s'il peut être forcé en true. Si le premier opérande peut être forcé à false, le deuxième opérande est renvoyé tel quel:
false || "My string"
> "My string"
null || "My string"
> "My string"
"My string" || false
> "My string"
"My string" || "My second string"
> "My string"
2 === 2 || "My string"
> true
Opérateur de coalescing nul
Introduit dans ES2020, "l'opérateur de coalisation nullh" (??) ne renvoie le premier opérande que si cet opérande a une valeur autre que null ou undefined. Sinon, il renvoie le deuxième opérande.
null ?? "My string"
> "My string"
undefined ?? "My string"
> "My string"
true ?? "My string";
> true
?? est semblable à un opérateur logique "OR", mais il est plus strict dans la façon dont le premier opérande est évalué. || renvoie le deuxième opérande pour toute expression pouvant être forcée en false, y compris undefined et null. ?? renvoie le deuxième opérande lorsque le premier est autre chose que null ou undefined, même s'il peut être forcé à false:
0 ?? "My string";
> 0
false ?? "My string";
> false
undefined ?? "My string";
> "My string"
Opérateurs d'affectation logique
Utilisez des opérateurs d'affectation pour attribuer la valeur d'un deuxième opérateur à un premier opérateur. L'exemple le plus courant est un seul signe égal (=), utilisé pour attribuer une valeur à une variable déclarée.
Utilisez des opérateurs d'attribution logique pour attribuer de manière conditionnelle une valeur à une variable en fonction de la valeur véridique ou erronée de cette variable.
L'opérateur d'affectation logique AND (&&=) évalue le deuxième opérande et l'attribue au premier s'il n'est évalué que si le premier est évalué à true. Autrement dit, "si le premier opérande est vrai, attribuez-lui la valeur du deuxième opérande à la place:"
let myVariable = false;
myVariable &&= 2 + 2;
> false
myVariable = true;
myVariable &&= 2 + 2;
> 4
La valeur véridique ou erronée du premier opérande détermine si une attribution est effectuée. Toutefois, lorsque vous essayez d'évaluer le premier opérande à l'aide d'un opérateur de comparaison, vous obtenez une valeur booléenne true ou false, qui ne peut pas se voir attribuer une valeur:
let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment
L'opérateur d'affectation logique OR (||=) évalue le deuxième opérande et l'attribue au premier si le premier opérande prend la valeur false. Autrement dit, "si le premier opérande est faux, attribuez-lui la valeur du deuxième opérande à la place:"
let myVariable = false;
myVariable ||= 2 + 2;
> 4
myVariable = true;
myVariable ||= 2 + 2;
> true
Testez vos connaissances
Quel opérateur indique "strictement égal" ?
======!=