Opérateurs de comparaison

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" ?

===
==
!=
=