Les opérateurs de comparaison comparent les valeurs de deux opérandes et évaluent 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
Contrainte de type et égalité
Deux des opérateurs de comparaison les plus fréquemment utilisés sont == pour l'égalité lâche et === pour l'égalité stricte. == effectue une comparaison lâche entre deux valeurs en forçant les opérandes à des types de données correspondants, 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 approximativement égaux.
2 != 3
> true
2 != "2"
> false
Les comparaisons strictes à l'aide de === ou de !== n'effectuent pas de coercition de type. Pour qu'une comparaison stricte aboutisse à true, les valeurs comparées doivent avoir le même type de données. Par conséquent, 2 == "2" renvoie true, mais 2 === "2" renvoie false:
2 === 3
> false
2 === "2"
> false
Pour supprimer toute ambiguïté pouvant résulter de la coercition automatique, utilisez === dans la mesure du possible.
| Opérateur | Description | Utilisation | Résultat |
|---|---|---|---|
| === | Strictement égal | 2 === 2 | true |
| !== | Non strictement égal | 2 !== "2" | true |
| == | Égal (ou "à peu près égal") | 2 == "2" | true |
| != | Not Equal (Non égal à) | 2 != "3" | true |
| > | Supérieur à | 3 > 2 | true |
| >= | Supérieur ou égal à | 2 >= 2 | true |
| < | Inférieur à | 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 à la valeur booléenne correspondante (par exemple, à l'aide du comparateur "loosely equal"). Un ensemble limité de valeurs est converti en false:
0nullundefinedNaN- Chaîne vide (
"")
Toutes les autres valeurs sont converties en true, y compris toute chaîne contenant un ou plusieurs caractères et tous les nombres non nuls. Ces valeurs sont communément appelées valeurs "vraies" et "fausses".
"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 de deux instructions conditionnelles ou plus:
2 === 3 || 5 === 5;
> true
2 === 2 && 2 === "2"
> false
2 === 2 && !"My string."
> false
Une expression logique NOT (!) inverse la valeur vraie ou fausse d'un opérande, et renvoie 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, force cette valeur à être booléenne et inverse la valeur vraie 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 les données à leur valeur booléenne correspondante:
!!"string"
> true
!!0
> false
Les opérateurs logiques AND et OR n'effectuent aucune coercition par eux-mêmes. Ils 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 cet opérande est évalué à false, et le deuxième opérande dans le cas contraire. Dans les comparaisons qui renvoient des valeurs booléennes, il ne renvoie true que si les opérandes de part et d'autre de l'AND logique renvoient true. Si l'un des côtés renvoie false, la fonction 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é en true, le deuxième opérande est renvoyé sans modification:
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 OR logique (||) ne renvoie le premier de ses deux opérandes que si cet opérande est évalué à true, et le deuxième opérande dans le cas contraire. Dans les comparaisons qui renvoient des valeurs booléennes, cela signifie qu'il renvoie true si l'un des opérandes renvoie true, et si aucun des côtés ne renvoie 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 inchangé s'il peut être forcé en true. Si le premier opérande peut être forcé en false, le deuxième opérande est renvoyé sans modification:
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 coalescence nulle
Introduit dans ES2020, l'opérateur de coalescence nulle (??) 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 OU logique, mais 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. ?? ne renvoie le deuxième opérande que lorsque le premier opérande est strictement égal à null ou undefined, même s'il peut être forcé en 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 vraie ou fausse de cette variable.
L'opérateur d'affectation logique AND (&&=) évalue le deuxième opérande et l'affecte au premier opérande si et seulement si le premier opérande renvoie true. En d'autres termes, "si le premier opérande est vrai, attribuez-lui plutôt la valeur du deuxième opérande:"
let myVariable = false;
myVariable &&= 2 + 2;
> false
myVariable = true;
myVariable &&= 2 + 2;
> 4
La valeur vraie ou fausse du premier opérande détermine si une affectation est effectuée. Toutefois, essayer d'évaluer le premier opérande à l'aide d'un opérateur de comparaison génère une valeur booléenne true ou false, à laquelle aucune valeur ne peut être attribuée:
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 opérande si celui-ci évalue à false. En d'autres termes, "si le premier opérande est faux, attribuez-lui plutôt la valeur du deuxième opérande" :
let myVariable = false;
myVariable ||= 2 + 2;
> 4
myVariable = true;
myVariable ||= 2 + 2;
> true
Vérifier vos connaissances
Quel opérateur indique "strictement égal" ?
======!=