Qual é a maneira correta de verificar a igualdade de strings no JavaScript?

Qual é a maneira correta de verificar a igualdade entre Strings em JavaScript?

sempre Até você entender completamente as diferenças e implicações do uso dosoperadores==e===, use o===operador, pois ele evitará erros e WTFs obscuros (não óbvios). O==operador"regular"pode ter resultados muito inesperados devido à coerção do tipo internamente, portanto, o uso===é sempre a abordagem recomendada.

Para ter uma idéia disso, e outras partes "boas versus más" do Javascript, leia sobre Douglas Crockford e seu trabalho. Há um ótimo Google Tech Talk, onde ele resume muitas informações boas: http://www.youtube.com/watch?v=hQVTIJBZook

Atualizar:

A série Você Não Sabe JS , de Kyle Simpson, é excelente (e é gratuita para leitura on-line). A série aborda as áreas geralmente incompreendidas da linguagem e explica as "partes ruins" que Crockford sugere que você evite. Ao entendê-los, você pode fazer uso adequado deles e evitar as armadilhas.

O livro " Up & Going " inclui uma seção sobre Igualdade , com este resumo específico de quando usar os operadores loose ( ==) vs strict ( ===):

Para resumir muitos detalhes em algumas sugestões simples e ajudá-lo a saber se deve usar ==ou ===em várias situações, aqui estão minhas regras simples:

• Se um dos valores (lado aka) em uma comparação puder ser o valor trueou false, evite ==e use ===.
• Se ambos os valores em uma comparação pode ser de estes valores específicos ( 0, "", ou []- matriz vazia), evite ==e uso ===.
• Em todos os outros casos, você é seguro de usar ==. Não é apenas seguro, mas em muitos casos, simplifica seu código de maneira a melhorar a legibilidade.

Eu ainda recomendo a palestra de Crockford para desenvolvedores que não querem investir tempo para realmente entender o Javascript - é um bom conselho para um desenvolvedor que ocasionalmente trabalha em Javascript.

Se você sabe que são strings, não há necessidade de verificar o tipo.

"a" == "b"

No entanto, observe que os objetos de sequência não serão iguais.

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

retornará falso.

Chame o método valueOf () para convertê-lo em uma primitiva para objetos String,

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

retornará verdadeiro

Apenas uma adição às respostas: se todos esses métodos retornarem falsos, mesmo que as strings pareçam iguais, é possível que exista um espaço em branco à esquerda e ou à direita de uma string. Então, basta colocar um .trim()no final das strings antes de comparar:

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

Perdi horas tentando descobrir o que está errado. Espero que isso ajude alguém!

o que me levou a essa pergunta é paddingaewhite-spaces

verifique meu caso

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

e o título era " LastName"

então talvez você precise usar trimfunções como esta

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

A menos que você realmente saiba como a coerção funciona, evite ==e use o operador de identidade ===. Mas você deve ler isso para entender como funciona .

Se você usar ==, deixe o idioma fazer algum tipo de coerção para você, por exemplo:

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

Como Douglas Crockford disse em seu livro:

É sempre melhor usar o operador de identidade.

Na verdade, existem duas maneiras pelas quais as strings podem ser criadas em javascript.

1. var str = 'Javascript'; Isso cria um valor de cadeia primitiva.

2. var obj = new String('Javascript');Isso cria um objeto do tipo wrapper String.

   typeof str // string
typeof obj // object

Portanto, a melhor maneira de verificar a igualdade é usar o ===operador, pois ele verifica o valor e o tipo dos dois operandos.

Se você deseja verificar a igualdade entre dois objetos, usar String.prototype.valueOfé o caminho correto.

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

A sequência Objectspode ser verificada usando o JSON.stringyfy()truque.

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

Considerando que ambas as cadeias podem ser muito grandes, existem 2 abordagens principais bitwise searchelocaleCompare

Eu recomendei esta função

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

A maneira mais fácil de fazer isso é usar um operador ternário da seguinte forma:

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

mas se a string que você deseja comparar estiver em uma matriz, você usará o filtro es6

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

o acima irá verificar seu stringArray e qualquer string que corresponda a ela da matriz que, no nosso caso, escolhemos "boys"

Eu vim com uma solução alternativa durante o teste. você pode usar a função no protótipo de string.

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

funciona bem em navegadores Chrome