Verifique a igualdade de strings em JavaScript

1. Quando usar um operador para igualdade de strings em JavaScript
2. 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.

1. 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á apenas true, caso contrário, ele retornará false.
2. 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.
3. 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.
4. Diferente (!=): Este é o oposto de Igualdade (==). Ele retorna true 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 ou false, 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.