Les opérateurs de comparaison comparent les valeurs de deux opérandes et évaluent si le
qu'ils forment est true
ou false
. L'exemple suivant utilise la classe
l'opérateur stricte égalité (===
) pour comparer deux opérandes: l'expression ;
2 + 2
et la valeur 4
. Comme le résultat de l'expression et le nombre
4
sont identiques, cette expression renvoie true
:
2 + 2 === 4
> true
Taper coercition et égalité
Deux des opérateurs de comparaison les plus fréquemment utilisés sont ==
pour les égalités faibles
et ===
pour une égalité stricte. ==
effectue une comparaison vague entre deux
valeurs en forçant les opérandes à correspondre aux types de données, si possible. Pour
Par exemple, 2 == "2"
renvoie true
, même si la comparaison est en cours
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 renvoie true
uniquement si les opérandes étant
comparés ne sont pas vaguement égaux.
2 != 3
> true
2 != "2"
> false
Les comparaisons strictes à l'aide de ===
ou !==
n'effectuent pas de coercition de type. Pour une
une comparaison stricte pour évaluer la valeur true
, les valeurs comparées doivent avoir le
même type de données. C'est pourquoi 2 == "2"
renvoie true
, mais 2 === "2"
.
renvoie false
:
2 === 3
> false
2 === "2"
> false
Pour éliminer toute ambiguïté pouvant résulter de la coercition automatique, utilisez ===
chaque fois que
possible.
Opérateur | Description | Utilisation | Résultat |
---|---|---|---|
=== | Strictement égal | 2 === 2 | true |
!== | Pas strictement égal | 2 !== "2" | true |
== | É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
Dans JavaScript, toutes les valeurs sont implicitement true
ou false
, et peuvent être forcées
la valeur booléenne correspondante, par exemple en utilisant la chaîne
un comparateur de prix. Forcer l'utilisation d'un ensemble limité de valeurs sur false
:
0
null
undefined
NaN
- Une chaîne vide (
""
)
Toutes les autres valeurs sont converties par coercition en true
, y compris toute chaîne contenant une ou plusieurs
et tous les nombres non nuls. Ceux-ci sont communément
appelés « vérité » et
"falsifié" valeurs.
"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 falsifiée d'un opérande, dont l'évaluation donne true
si l'opérande renvoie la valeur false
, et false
si l'évaluation de l'opérande est true
:
true
> true
!true
> false
!false
> true
Utiliser l'opérateur logique NOT (!
) devant un autre type de données, comme un
un nombre ou une chaîne, convertit cette valeur en valeur booléenne et inverse la valeur
valeur erronée 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 dans leur valeur booléenne correspondante:
!!"string"
> true
!!0
> false
Les opérateurs logiques AND et OR n'effectuent pas de coercition seuls. Ils renvoie la valeur de l'un des deux opérandes en cours d'évaluation, avec le nombre déterminé par cette évaluation.
L'opérateur logique AND (&&
) ne renvoie le premier de ses deux opérandes que si cet opérande
prend la valeur false
, et le deuxième opérande dans le cas contraire. Pour comparer
sur des valeurs booléennes, la fonction renvoie true
uniquement si les opérandes des deux côtés
de l'opérateur logique AND valent true
. Si l'un des côtés prend la valeur false
,
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é.
inchangée s'il peut être forcé à 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 OR (||
) ne renvoie le premier de ses deux opérandes que si cet opérande
prend la valeur true
, et le deuxième opérande dans le cas contraire. Pour comparer
est évaluée sur des valeurs booléennes, ce qui signifie qu'elle renvoie true
si l'un des opérandes
prend la valeur true
. Si aucun des deux côtés ne prend la valeur true
, la fonction renvoie
false
:
true || false
> true
false || true
> true
true || true
> true
false || false
> false
Lorsque vous utilisez ||
avec deux opérandes non booléens, le premier opérande est renvoyé.
inchangée s'il peut être forcé à 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 fusion de valeurs nulles
Introduit en ES2020,
l'opérateur "coalescing nulliste" (??
) ne renvoie le premier opérande que si cette
L'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 OU, mais 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é vers false
, y compris undefined
et null
. ??
renvoie la seconde
opérande lorsque le premier opérande est autre que null
ou undefined
, même s'il
peut être contraint à 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
. L'exemple le plus courant est un signe égal unique (=
), utilisé pour
attribuer une valeur à une variable déclarée ;
Utiliser des opérateurs d'affectation logique pour attribuer une valeur à une variable de manière conditionnelle en fonction de la valeur véridique ou falsifiée de cette variable.
L'opérateur logique d'attribution AND (&&=
) évalue le deuxième opérande et
attribue au premier opérande si uniquement si le premier opérande est évalué comme suit :
true
: en effet, "si le premier opérande est vrai, attribuez-lui la valeur de
le deuxième opérande : »
let myVariable = false;
myVariable &&= 2 + 2;
> false
myVariable = true;
myVariable &&= 2 + 2;
> 4
La valeur vérité ou fausse du premier opérande détermine si une attribution
est effectuée. Toutefois, en essayant d'évaluer le premier opérande à l'aide d'une comparaison
renvoie une valeur booléenne true
ou false
, qui ne peut pas se voir attribuer un
:
let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment
L'opérateur d'affectation logique OU (||=
) évalue le deuxième opérande et
attribuer au premier opérande si le premier opérande prend la valeur false
:
« 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" ?
!=
=
==
===