web-dev-qa-db-fra.com

Quelle est la bonne façon de vérifier l’égalité des chaînes en JavaScript?

Quelle est la bonne façon de vérifier l’égalité entre les chaînes en JavaScript?

javascriptstring
767
JSS

toujours  Jusqu'à ce que vous compreniez pleinement les différences et les implications de l'utilisation des opérateurs == et ===, utilisez l'opérateur === car il vous évitera des bogues obscurs (non évidents) et des WTF. L'opérateur "normal" == peut avoir des résultats très inattendus en raison de la coercition de types en interne. Il est donc recommandé d'utiliser ===.

Pour en savoir plus sur ce sujet et sur d’autres parties "bonnes ou mauvaises" de Javascript, lisez M. Douglas Crockford et son travail. Il y a une excellente conférence technique sur Google où il résume de nombreuses informations utiles: http://www.youtube.com/watch?v=hQVTIJBZook

Mise à jour:

La série Vous ne savez pas JS de Kyle Simpson est excellente (et gratuite à lire en ligne). La série se situe dans les zones de langage couramment mal comprises et explique les "mauvaises parties" que Crockford vous suggère d'éviter. En les comprenant, vous pouvez les utiliser correctement et éviter les pièges.

Le livre " p & Going " comprend une section sur Equality , avec ce résumé spécifique sur le moment d'utiliser le vrac (==) vs strict (===) les opérateurs:

Pour résumer une foule de détails à quelques suggestions simples et vous aider à savoir s'il faut utiliser == ou === dans diverses situations, voici mes règles simples:

  • Si l'une ou l'autre des valeurs de la comparaison peut être la valeur true ou false, évitez == et utilisez ===.
  • Si l'une des valeurs d'une comparaison peut correspondre à ces valeurs spécifiques (0, "" ou [] - tableau vide), évitez == et utilisez ===. .
  • Dans tous les autres cas, vous pouvez utiliser == en toute sécurité. Non seulement cela est sûr, mais dans de nombreux cas, cela simplifie votre code de manière à améliorer la lisibilité.

Je recommande tout de même le discours de Crockford aux développeurs qui ne veulent pas investir le temps nécessaire pour bien comprendre le langage Javascript. C'est un bon conseil pour un développeur qui ne travaille que de temps en temps en Javascript.

577
STW

Si vous savez que ce sont des chaînes, inutile de vérifier le type.

"a" == "b"

Toutefois, notez que les objets chaîne ne seront pas égaux.

new String("a") == new String("a")

retournera faux.

Appelez la méthode valueOf () pour la convertir en primitive pour les objets String.

new String("a").valueOf() == new String("a").valueOf()

reviendra vrai

184
Anurag

Un seul ajout aux réponses: si toutes ces méthodes retournent false, même si les chaînes semblent être égales, il est possible qu’un espace soit placé à gauche et à droite d’une chaîne. Donc, il suffit de mettre un .trim() à la fin des chaînes avant de comparer:

if(s1.trim() === s2.trim())
{
    // your code
}

J'ai perdu des heures à essayer de comprendre ce qui ne va pas. J'espère que cela aidera à quelqu'un!

49
akelec

ce qui m'a amené à cette question est le padding et white-spaces

vérifier mon cas

 if (title === "LastName")
      doSomething();

et le titre était " LastName"

enter image description here

alors peut-être que vous devez utiliser la fonction trim comme ça

var title = $(this).text().trim();
18
Basheer AL-MOMANI

Si vous ne savez pas vraiment comment fonctionne la contrainte, évitez == et utilisez plutôt l'opérateur d'identité ===. Mais vous devriez - lisez ceci pour comprendre comment ça marche .

Si vous utilisez ==, vous laissez le langage faire une sorte de coercition pour vous, par exemple:

"1" == 1 // true
"0" == false // true
[] == false // true

Comme Douglas Crockford l'a dit dans son livre:

Il est toujours préférable d’utiliser l’opérateur d’identité.

13
ludico8

En réalité, les chaînes peuvent être créées en javascript de deux manières.

  1. var str = 'Javascript'; Ceci crée une valeur de chaîne primitive.

  2. var obj = new String('Javascript'); Ceci crée un objet wrapper de type String.

    typeof str // string
    typeof obj // object

Le meilleur moyen de vérifier l’égalité consiste donc à utiliser l’opérateur === car il vérifie la valeur ainsi que le type des deux opérandes.

Si vous voulez vérifier l’égalité entre deux objets, utilisez String.prototype.valueOf comme il convient.

new String('javascript').valueOf() == new String('javascript').valueOf()
11
Abhishek

La chaîne Objects peut être vérifiée à l'aide de l'astuce JSON.stringyfy().

var me = new String("me");
var you = new String("me");
var isEquel = JSON.stringify(me) === JSON.stringify(you);
console.log(isEquel);
5
Muhammad Usman