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?

toujours Jusqu'à ce que vous compreniez parfaitement les différences et les implications de l'utilisation desopérateurs==et===, utilisez l'===opérateur car il vous évitera des bugs et des WTF obscurs (non évidents). L'==opérateur"régulier"peut avoir des résultats très inattendus en raison de la coercition de type en interne, donc l'utilisation===est toujours l'approche recommandée.

Pour avoir un aperçu de cela, et d'autres parties «bonnes contre mauvaises» de Javascript lisez M. Douglas Crockford et son travail. Il y a un excellent Google Tech Talk où il résume beaucoup de bonnes informations: http://www.youtube.com/watch?v=hQVTIJBZook

Mise à jour:

La série You Don't Know JS de Kyle Simpson est excellente (et gratuite à lire en ligne). La série va dans les domaines souvent mal compris de la langue 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 " Up & Going " comprend une section sur l' égalité , avec ce résumé spécifique de quand utiliser les opérateurs loose ( ==) vs strict ( ===):

Pour résumer un tas de détails en quelques plats à emporter simples, et vous aider à savoir s'il faut utiliser ==ou ===dans diverses situations, voici mes règles simples:

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

Je recommande toujours le discours de Crockford aux développeurs qui ne veulent pas investir du temps pour vraiment comprendre Javascript — c'est un bon conseil pour un développeur qui ne travaille que de manière occasionnelle en Javascript.

Si vous savez qu'il s'agit de chaînes, il n'est pas nécessaire de vérifier le type.

"a" == "b"

Cependant, 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

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'il y ait un espace à gauche et à droite d'une chaîne. Donc, mettez juste 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!

ce qui m'a amené à cette question est le paddingetwhite-spaces

vérifier mon cas

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

et le titre était " LastName"

alors peut-être que vous devez utiliser une trimfonction comme celle-ci

var title = $(this).text().trim();

À moins que vous ne sachiez vraiment comment fonctionne la coercition, vous devez éviter ==et utiliser l'opérateur d'identité à la ===place. Mais vous devriez lire ceci pour comprendre comment cela fonctionne .

Si vous utilisez ==, vous laissez la langue exercer une certaine contrainte de type pour vous, par exemple:

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

Comme l'a dit Douglas Crockford dans son livre:

Il vaut toujours mieux utiliser l'opérateur d'identité.

Il existe en fait deux façons de créer des chaînes en javascript.

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

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

   typeof str // string
typeof obj // object

Ainsi, la meilleure façon de vérifier l'égalité est d'utiliser l' ===opérateur car il vérifie la valeur ainsi que le type des deux opérandes.

Si vous souhaitez vérifier l'égalité entre deux objets, l'utilisation String.prototype.valueOfest la bonne façon.

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

La chaîne Objectspeut être vérifiée à l'aide d'une JSON.stringyfy()astuce.

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

Étant donné que les deux chaînes peuvent être très grandes, il existe deux approches principales bitwise searchetlocaleCompare

Je recommande cette fonction

function compareLargeStrings(a,b){
    if (a.length !== b.length) {
         return false;
    }
    return a.localeCompare(b) === 0;
}

La façon la plus simple de le faire est d'utiliser un opérateur ternaire comme ceci:

 "was" == "was" ? true : false

mais si la chaîne que vous souhaitez comparer est dans un tableau, vous utiliserez le filtre es6

let stringArray  = ["men", "boys", "girls", "sit", "can", "gotten"]
stringArray.filter(I=> I === boys ? 
stringArray.pop(indexOf(I)) : null)

ce qui précède vérifiera votre stringArray et toute chaîne qui lui correspond dans le tableau qui dans notre cas, nous avons choisi "boys"

J'ai trouvé une solution alternative lors des tests. vous pouvez utiliser la fonction sur le prototype de chaîne.

String.prototype.betwenStr = function(one){

return JSON.stringify(new String(this)) === JSON.stringify(new String(one));

}


 //call it
 "hello world".betweenStr("hello world"); //returns boolean 
 //value

fonctionne bien dans les navigateurs chromés