Quelle est la différence entre === et == en JavaScript?


Réponse 1:

En JavaScript == et === les deux sont utilisés pour comparer deux valeurs.

La question qui se pose ici est que si l'opérateur == était déjà là pour comparer les valeurs, alors quel est le besoin d'introduire l'opérateur === dans JavaScript. La raison est assez intéressante.

Dans tous les langages de programmation, l'opérateur == est utilisé pour comparer deux valeurs et il en est de même pour le JavaScript, mais parfois l'opérateur == se comporte très bizarrement et peut donner le mauvais résultat. C'est à cause d'un concept en JavaScript, c'est-à-dire la COERCION DE TYPE. Maintenant, c'est quoi ce TYPE COERCION?

TYPE COERCION est un concept dans lequel tout compilateur ou interprète de langage de programmation convertit une valeur d'un type de données en une valeur d'un autre type de données. Par exemple, prenez un code JavaScript,

var a = 123; (type de données entier)

var b = "4"; (Type de données String)

alors a + b =?

La valeur de a + b sera "1234".

Ici, l'interpréteur JavaScript effectue la conversion automatique du type de données de la variable. 'a' de entier à String. L'interpréteur JavaScript prend la valeur entière de 'a' c'est-à-dire 123 et la convertit automatiquement en String puis concatène avec la valeur de 'b'. Par conséquent, le résultat final sera une chaîne «1234».

L'opérateur == effectue également la même conversion de type si deux valeurs de type de données différent sont comparées en JavaScript. Mais cela va créer un problème.

Comprenons cela avec un exemple. Supposons qu'il y ait deux variables déclarées en JavaScript comme indiqué ci-dessous, alors quelle sera la sortie.

Var a = 5;

Var b = 5;

si (a == b) {

Console.log («BONJOUR JS»);

}

C'est assez simple, l'interpréteur JavaScript vérifiera la valeur des variables 'a' et 'b'. Étant donné que les deux sont identiques, il retournera TRUE et affichera la valeur HELLO JS.

Regardez maintenant cet exemple et devinez la sortie:

var a = 5;

var b = "5";

si (a == b) {

Console.log («BONJOUR JS»);

}

La sortie est: HELLO JS,

Oui, vous l'avez bien lu. La condition if renverra TRUE ici. Mais il devrait retourner FAUX correctement parce que 'a' est un entier et 'b' est une chaîne mais pourquoi il retourne VRAI et l'instruction à l'intérieur si le bloc est exécuté?

La réponse est la contrainte de type, oui, l'interpréteur JavaScript effectue à nouveau la conversion de type. La valeur de «a» est d'abord convertie en chaîne, puis comparée avec «b». Donc, dans ce type de cas, l'opérateur == donne un mauvais résultat en JavaScript. Par conséquent, pour surmonter ce problème, l'équipe de développeurs JavaScript a introduit l'opérateur ===. L'opérateur === n'effectue aucune conversion de type et traite les variables comme leur même type de données lors de la comparaison et donne le bon résultat.

Donc, le même exemple avec l'opérateur ===:

var a = 5;

var b = "5";

si (a === b) {

Console.log («BONJOUR JS»);

}

Cette fois, il n'imprimera pas la valeur car la condition if renverra FALSE et l'instruction à l'intérieur si le bloc ne sera pas exécuté.

J'espère que vous avez répondu à votre question. Mais la chose surprenante ici est que lorsque l'opérateur == se porte plutôt bien dans d'autres langues, alors pourquoi donne-t-il un mauvais résultat en JavaScript? Mon hypothèse est que lorsque JavaScript a été créé, son créateur voulait qu'il soit assez simple et convivial, de sorte qu'ils conçoivent l'interpréteur JavaScript de manière à ignorer les petites erreurs humaines. Pour qu'il puisse donner une meilleure expérience utilisateur. Par conséquent, lorsque nous comparons deux valeurs comme l'entier 5 avec la chaîne 5, l'interpréteur JavaScript suppose que le programmeur souhaite comparer les deux valeurs de chaîne 5 et 5, mais par erreur, il a déclaré l'une d'entre elles comme entier, il l'a donc corrigée en la convertissant en chaîne. puis comparez et retournez VRAI.

Merci pour la lecture. Si vous comprenez la réponse et que vous l'aimez, veuillez la voter. C'est ma première réponse sur Quora.


Réponse 2:

En JavaScript, vous ne déclarez pas le type de données, vous déclarez simplement des variables et cela suppose le type.

En Java, nous avons:

int x = 2;
Chaîne y = "2";

En JavaScript, les mêmes déclarations sont:

var x = 2;
var y = "2";

La différence est que JavaScript suppose les types de x et y. Cela devient un problème lorsque vous souhaitez comparer deux variables de deux types différents, par exemple un entier et une chaîne. C’est pourquoi nous utilisons l’opérateur === pour garantir que les deux types ET la valeur sont les mêmes.

Dans le code suivant, notez que x est un entier alors que y est une chaîne.

var x = 2; // entier
var y = "2"; // chaîne

si (x == y) {// vrai
  // ..
}

if (x === y) {// false
  // ..
}

En comparant x et y, nous obtenons:

  1. if (x == y) -> truethe == L'opérateur a converti y en un entier, ce qui fait que notre instruction if ressemble à 'if (2 == 2)', donc c'est vrai. si (x === y) -> falsethe === L'opérateur ne fait pas de conversions, il compare les types puis les valeurs. Puisque x est un entier et y est une chaîne, nous avons deux types différents et donc ils sont incomparables, donc c'est faux.

En général, vous ne voulez pas utiliser == à moins que vous ne sachiez exactement à quels types de données vous avez affaire.


Réponse 3:

En JavaScript, vous ne déclarez pas le type de données, vous déclarez simplement des variables et cela suppose le type.

En Java, nous avons:

int x = 2;
Chaîne y = "2";

En JavaScript, les mêmes déclarations sont:

var x = 2;
var y = "2";

La différence est que JavaScript suppose les types de x et y. Cela devient un problème lorsque vous souhaitez comparer deux variables de deux types différents, par exemple un entier et une chaîne. C’est pourquoi nous utilisons l’opérateur === pour garantir que les deux types ET la valeur sont les mêmes.

Dans le code suivant, notez que x est un entier alors que y est une chaîne.

var x = 2; // entier
var y = "2"; // chaîne

si (x == y) {// vrai
  // ..
}

if (x === y) {// false
  // ..
}

En comparant x et y, nous obtenons:

  1. if (x == y) -> truethe == L'opérateur a converti y en un entier, ce qui fait que notre instruction if ressemble à 'if (2 == 2)', donc c'est vrai. si (x === y) -> falsethe === L'opérateur ne fait pas de conversions, il compare les types puis les valeurs. Puisque x est un entier et y est une chaîne, nous avons deux types différents et donc ils sont incomparables, donc c'est faux.

En général, vous ne voulez pas utiliser == à moins que vous ne sachiez exactement à quels types de données vous avez affaire.