JavaScript === contre ==

1. L’opérateur d’égalité lâche (==) en JavaScript
2. Opérateur d’égalité stricte (===) en JavaScript

Les opérateurs de comparaison nous aident à déterminer si deux variables sont égales ou suivent un critère spécifié. Si les résultats de la comparaison sont favorables, il renvoie true ; sinon, il renvoie false. Ce tutoriel explique le sujet le plus déroutant parmi les opérateurs de comparaison et enseigne quand utiliser ce qui est égal à l’opérateur (== ou ==).

Un simple égal = est assez différent du double égal == et du triple égal === car il s’agit d’une opération d’affectation et ce sont des opérateurs de comparaison. Par conséquent, la confusion est généralement entre == et ===.

L’opérateur d’égalité lâche (==) en JavaScript

L’opérateur == ou opérateur d’égalité est également appelé opérateur de comparaison abstraite. Elle est dite abstraite car elle ne concerne que la valeur et non le type de la variable. L’opérateur == effectue la conversion des valeurs des variables vers le même type (type coercition) avant de les comparer entre elles et renvoie vrai si les opérandes convertis sont égaux. Étant donné que l’opérateur doit effectuer la conversion de type, il a tendance à être un peu plus lent que l’opérateur ===.

Maintenant, pour comprendre quand utiliser quel opérateur, nous devons d’abord comprendre un peu la coercition de type. Il est de deux types :

1. Coercition explicite : Elle est effectuée explicitement par le biais de code utilisant des méthodes intégrées. Par exemple : Pour convertir une chaîne "42" en un nombre, nous devons écrire Number("42"). De cette façon, nous utilisons la méthode de conversion explicite de type Number() pour convertir une chaîne en un nombre.
2. Coercition implicite : Elle est faite implicitement par le langage. Elle est généralement effectuée lorsque nous utilisons deux types différents d’opérande avec un opérateur. Par exemple : Si nous effectuons 1 + "". Il y a un nombre et une chaîne qui ne peuvent pas être ajoutés directement, donc le type JavaScript convertit le nombre en chaîne car c’est la seule façon de les ajouter et renvoie une chaîne "1".

23 == '23'         // returns true
true + false == 1  // returns true
undefined ==
    null         // returns true
        [] == 0  // returns true

Opérateur d’égalité stricte (===) en JavaScript

L’opérateur === ou opérateur d’identité est également appelé opérateur de comparaison stricte. Il est appelé strict car il ne renvoie true que lorsque le type et la valeur des deux opérandes sont identiques. Il n’effectue aucun type de conversion ; par conséquent, il a tendance à être plus rapide que l’opérateur ==.

true === true  // returns true
true === 1     // returns false

Par conséquent, la décision de choisir l’opérateur == ou === repose sur le besoin de coercition de type. Si l’on n’est pas familier avec la coercition de type, alors il devrait s’en tenir à l’opérateur d’égalité stricte.