Verifique a igualdade de strings em JavaScript
- Quando usar um operador para igualdade de strings em JavaScript
- Compreender a igualdade de strings em JavaScript com exemplos
Em JavaScript, existem quatro operadores que você pode usar para verificar a igualdade da string. Esses operadores são chamados de operadores de comparação.
- Estrito igual (
===
): O estrito igual (também conhecido como operador triplo igual) verifica o valor da variável e seu tipo de dados. Se ambas as coisas forem iguais, ele retornará apenastrue
, caso contrário, ele retornaráfalse
. - Estrito diferente (
!==
): Este é o oposto de Estrito igual. Se o valor ou o tipo de dados não corresponder, ele retornarátrue
; caso contrário,false
. - Igual a (
==
): O sinal de igual duplo verifica apenas o valor de uma variável. Se o valor corresponder, ele retornarátrue
, caso contrário, ele retornaráfalse
. Não se preocupa com o tipo de variável. - Diferente (
!=
): Este é o oposto de Igualdade (==
). Ele retornatrue
apenas se os valores dentro das variáveis não corresponderem, independentemente do tipo de dados. Se os valores corresponderem entre si, ele retornaráfalse
.
Esses operadores são usados não apenas para verificar a igualdade da string, mas também para verificar a igualdade de outros tipos de dados. Desses quatro operadores, vamos descobrir o melhor para verificar a igualdade da string, dependendo dos casos de uso.
Você já deve ter visto o terceiro e o quarto operadores, ou seja, ==
e !=
, Que também são bastante comuns em outras linguagens de programação. Mas a maneira como funciona em JavaScript é um pouco diferente de outras linguagens.
Quando usar um operador para igualdade de strings em JavaScript
Em conexão com JavaScript, a seguir estão alguns casos de uso em que você pode usar qualquer um dos operadores ===
ou ==
.
- Se um valor em comparação puder ser um valor
true
oufalse
, use===
e não==
. - Se um valor em comparação puder ser qualquer um desses valores específicos (
0
,""
ou[]
- matriz vazia), use===
em vez de==
. - Em qualquer outro caso, você pode usar
==
com segurança. Não é apenas seguro, mas também simplifica seu código e melhora a legibilidade.
As mesmas regras acima são aplicáveis ao usar os operadores Estrito diferente (!==
) e Diferente (!=
) Também. Para saber mais sobre as regras específicas, você pode ler a seção 11.9.3 da especificação ES5.
Compreender a igualdade de strings em JavaScript com exemplos
Vamos pegar alguns dos exemplos e entender essas coisas em detalhes.
Neste exemplo, pegamos duas variáveis, name_1
e name_2
. Ambos aceitam "adam"
como o valor da string. Agora vamos aplicar cada um dos operadores acima e ver a saída que obtemos.
Aqui, usamos quatro instruções if
e else
, cada uma representando diferentes operadores de comparação. Uma vez que o valor e o tipo de dados são os mesmos para as variáveis name_1
e name_2
, o operador triplo igual ou igual estrito (===
) imprimirá True
como a saída. E o duplo igual ==
também imprimirá True
, uma vez que ambas as variáveis têm os mesmos valores.
let name_1 = "adam";
let name_2 = "adam";
// Strict Equal
if(name_1 === name_2) console.log("True");
else console.log("False");
// Equal
if(name_1 == name_2) console.log("True");
else console.log("False");
// Strict not equal
if(name_1 !== name_2) console.log("True");
else console.log("False");
// Not equal
if(name_1 != name_2) console.log("True");
else console.log("False");
Resultado:
True
True
False
False
Ao usar o operador Estrito diferente (!==
) e diferente (!=
), Ambos imprimirão False
como saída, pois o valor em si é o mesmo em ambas as variáveis.
Abaixo está outro exemplo onde compararemos uma string com um inteiro. Aqui, temos uma variável str
com um valor de "80"
, um valor de string. Temos outra variável, num
, que contém um valor inteiro de "80"
. Como essas duas variáveis têm os mesmos valores com tipos de dados diferentes, vamos ver o que acontece ao usar os vários operadores de comparação nelas.
let str = "80";
let num = 80;
// Strict Equal
if(str === num) console.log("True");
else console.log("False")
// Equal
if(str == num) console.log("True");
else console.log("False")
// Strict not equal
if(str !== num) console.log("True");
else console.log("False")
// Not equal
if(str != num) console.log("True");
else console.log("False")
Resultado:
False
True
True
False
Como no primeiro exemplo, também temos quatro instruções if
e else
, cada uma representando diferentes operadores de comparação.
Quando usamos Strict igual ou triplo igual (===
), obtemos False
como saída. O motivo é que o tipo de dados é diferente, embora os valores sejam os mesmos. Mas quando usamos o duplo igual (==
), obtemos True
como a saída porque duplo igual apenas verifica o valor e não o tipo.
E quando estamos usando Strict not equal (!==
), obtemos True
como a saída porque o valor da string "80"
não é igual ao valor inteiro 80
; portanto, retorna True
.
Por último, o operador diferente (!=
) Apenas compara o valor das duas variáveis. Os valores precisam ser diferentes para imprimir True
. Como os valores são iguais neste caso, ele retorna False
.