Qual è il modo corretto per verificare l'uguaglianza delle stringhe in JavaScript?

Qual è il modo corretto per verificare la parità tra le stringhe in JavaScript?

sempre Fino a quando non comprendi appieno le differenze e le implicazioni dell'uso deglioperatori==e===, usa l'===operatore poiché ti salverà da bug e WTF oscuri (non ovvi). L'==operatore"normale"può avere risultati molto inaspettati a causa della coercizione del tipo internamente, quindi l'utilizzo===è sempre l'approccio raccomandato.

Per avere un'idea di ciò, e altre parti "buone contro cattive" di Javascript hanno letto il signor Douglas Crockford e il suo lavoro. C'è un ottimo discorso tecnico su Google in cui riassume molte buone informazioni: http://www.youtube.com/watch?v=hQVTIJBZook

Aggiornare:

La serie You Don't Know JS di Kyle Simpson è eccellente (e gratuita da leggere online). La serie va nelle aree del linguaggio comunemente fraintese e spiega le "parti cattive" che Crockford suggerisce di evitare. Comprendendoli puoi usarli correttamente ed evitare le insidie.

Il libro " Up & Going " include una sezione sull'uguaglianza , con questo riepilogo specifico di quando utilizzare gli operatori loose ( ==) vs strict ( ===):

Per ridurre tutti i dettagli in pochi semplici passaggi e aiutarti a sapere se utilizzare ==o ===in varie situazioni, ecco le mie semplici regole:

• Se uno dei due valori (alias lato) in un confronto potrebbe essere il valore trueo false, evitare ==e utilizzare ===.
• Se entrambi i valori in un confronto potrebbe essere di questi valori specifici ( 0, ""o []- array vuoto), evitare ==di usare ===.
• In tutti gli altri casi, sei sicuro da usare ==. Non solo è sicuro, ma in molti casi semplifica il codice in modo da migliorare la leggibilità.

Consiglio ancora il discorso di Crockford per gli sviluppatori che non vogliono investire il tempo per capire davvero Javascript: è un buon consiglio per uno sviluppatore che lavora solo occasionalmente in Javascript.

Se sai che sono stringhe, non è necessario controllare il tipo.

"a" == "b"

Tuttavia, si noti che gli oggetti stringa non saranno uguali.

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

restituirà false.

Chiama il metodo valueOf () per convertirlo in una primitiva per oggetti String,

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

tornerà vero

Solo un'aggiunta alle risposte: se tutti questi metodi restituiscono false, anche se le stringhe sembrano uguali, è possibile che ci sia uno spazio bianco a sinistra o a destra di una stringa. Quindi, basta inserire un .trim()alla fine delle stringhe prima di confrontare:

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

Ho perso ore a cercare di capire cosa c'è che non va. Spero che questo possa aiutare qualcuno!

ciò che mi ha portato a questa domanda è il paddingewhite-spaces

controlla il mio caso

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

e il titolo era " LastName"

quindi forse devi usare la trimfunzione in questo modo

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

A meno che tu non sappia davvero come funziona la coercizione, dovresti invece evitare ==e utilizzare l'operatore di identità ===. Ma dovresti leggere questo per capire come funziona .

Se lo usi ==, lasci che la lingua faccia qualche tipo di coercizione per te, quindi ad esempio:

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

Come ha detto Douglas Crockford nel suo libro:

È sempre meglio usare l'operatore di identità.

Esistono due modi in cui è possibile creare stringhe in javascript.

1. var str = 'Javascript'; Questo crea un valore di stringa primitivo.

2. var obj = new String('Javascript');Questo crea un oggetto wrapper di tipo String.

   typeof str // string
typeof obj // object

Quindi il modo migliore per verificare l'uguaglianza è usare il === operatore perché controlla sia il valore che il tipo di entrambi gli operandi.

Se si desidera verificare l'uguaglianza tra due oggetti, l'utilizzo String.prototype.valueOfè corretto.

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

La stringa Objectspuò essere controllata usando il JSON.stringyfy()trucco.

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

Considerando che entrambe le stringhe possono essere molto grandi, ci sono 2 approcci principali bitwise searchelocaleCompare

Ho raccomandato questa funzione

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

Il modo più semplice per farlo è usare un operatore ternario in questo modo:

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

ma se la stringa che desideri confrontare si trova in un array, utilizzerai il filtro es6

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

quanto sopra controllerà il tuo stringArray e qualunque stringa che lo corrisponda dall'array che nel nostro caso abbiamo scelto "ragazzi"

Ho trovato una soluzione alternativa durante i test. è possibile utilizzare la funzione sul prototipo di stringa.

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

funziona bene nei browser Chrome