Apesar de ser um assunto para iniciantes, sempre achei muito interessante ver as formas de comparação de igualdade e desigualdade em JavaScript, principalmente pelos desafios encontrados pela coerção de valores. Lembro que quando estava no início da minha jornada, sempre usava o sinal duplo de igualdade e desigualdade, e isso por vezes me gerou algum problema.
Fazer comparações entre valores é algo normal do dia a dia de um programador — pelo menos do meu. Por exemplo, se o resultado de um cálculo entre números atingiu um determinado valor, ou ainda se dois textos são iguais, como por exemplo, em uma função que determina se uma palavra é um palíndromo, ou seja, se pode ser lida da mesma forma em ambas as direções. Ao fazer essas comparações, sempre é esperado que o resultado seja true caso seja uma comparação verdadeira, e false caso contrário.
Nesse post vamos falar especificamente de comparação de valores do tipo primitivo.
Existem duas formas de se comparar se dois valores são iguais: com o sinal de igualdade ampla e com o sinal de igualdade estrita.
Igualdade ampla
A igualdade ampla é a que geralmente se aprende primeiro em JavaScript. É a comparação que se usa dois símbolos de igual: ==
Esse duplo sinal indica que estamos comparando apenas os valores, sem levar em consideração o tipo. Com isso, estamos permitindo que o JavaScript faça a coerção de tipos de forma implícita. Isso significa que quando comparamos se o valor 2 do tipo Number é igual de forma ampla com o valor '2' do tipo String, o JavaScript irá converter o tipo String em Number e retornará true. Vale deixar claro que você não é proibido de fazer isso, mas acredito que na maioria absoluta das vezes, você irá preferir não usar a igualdade ampla.
Ao utilizar a comparação ampla — seja de igualdade ou desigualdade — podemos dar de cara com algumas comparações que estranhamento retornarão true, como ao compararmos o valor 1 do tipo Number com o valor true do tipo Boolean, e comparar o valor 0 do tipo Number com o valor false do tipo Boolean. Tudo isso faz sentido em razão da coerção, mas não aprofundaremos nesse tópico ainda.
Veja abaixo alguns exemplos de comparação ampla e seus resultados.
console.log(2 == '2') // true
console.log(2 == 2) // true
console.log(2 == 3) // false
console.log('reviver' == 'reviver') // true
console.log('meg' == 'selina') // false
console.log(1 == true) // true
console.log('1' == true) // true
console.log(0 == false) // true
console.log('0' == false) // true
Igualdade estrita
A igualdade estrita é a comparação que usa três símbolos de igual: ===
O sinal triplo indica que estamos comparando os valores e também os tipos, não permitindo que o JavaScript faça qualquer tipo de coerção que possa nos levar a um resultado fora do esperado. Isso significa que se comparamos o valor 2 do tipo Number com o valor '2' do tipo String, teremos false como resultado. Por mais que possa parecer estranho para quem está começando, na maioria absoluta das vezes, a comparação estrita será a que você irá preferir usar. Dessa forma também evitamos que o valor 1 do tipo Number seja igual ao valor true do tipo Boolean.
Veja abaixo alguns exemplos de comparação estrita e seus resultados.
console.log(2 === '2') // false
console.log(2 === 2) // true
console.log(2 === 3) // false
console.log('reviver' === 'reviver') // true
console.log('meg' === 'selina') // false
console.log(1 === true) // false
console.log('1' === true) // false
console.log(0 === false) // false
console.log('0' === false) // false
Só uma observação: Deu pra perceber que comparação entre duas strings sempre será a mesma coisa né? Incluí mais pra ilustrar. Ao comparar strings, não faz diferença.
Desigualdade ampla
Aqui seguimos exatamente a mesma lógica da igualdade ampla. Utilizamos dois sinais apenas para comparar uma desigualdade: !=
Dessa forma estamos comparando apenas valores, e não seus tipos, permitindo que o JavaScript faça a coerção para te retornar o resultado. Ou seja, se você comparar que o valor 2 do tipo Number é diferente do valor '2' do tipo String, o resultado será false. Isso porque a forma ampla compara apenas os valores — lembre-se da coerção do JavaScript.
Veja abaixo alguns exemplos e seus resultados.
console.log(2 != '2') // false
console.log(2 != 2) // false
console.log(2 != 3) // true
console.log('reviver' != 'reviver') // false
console.log('meg' != 'selina') // true
console.log(1 != true) // false
console.log('1' != true) // false
console.log(0 != false) // false
console.log('0' != false) // false
Desigualdade estrita
Aqui seguimos exatamente a mesma lógica da igualdade estrita. Usamos três sinais para comparar uma desiguldade: !==
Dessa forma estamos comparando os valores e também seus tipos, não permitindo que o JavaScript faça qualquer tipo de coerção. Dessa vez, se você comparar que o valor 2 do tipo Number é diferente do valor '2' do tipo String, o resultado será true! Sim, porque apesar de o valor ser o mesmo, os tipos são diferentes.
Veja abaixo alguns exemplos e seus resultados.
console.log(2 !== '2') // true
console.log(2 !== 2) // false
console.log(2 !== 3) // true
console.log('reviver' !== 'reviver') // false
console.log('meg' !== 'selina') // true
console.log(1 !== true) // true
console.log('1' !== true) // true
console.log(0 !== false) // true
console.log('0' !== false) // true
Existem outros casos peculiares ao comparar valores em JavaScript, por isso será sempre interessante utilizar a comparação estrita — com três símbolos — pois isso te ajuda a evitar cair em pegadinhas da linguagem.
Conclusão
No meu dia a dia eu sempre opto pela comparação de igualdade e desigualdade estrita, mas é claro que você deve se sentir livre para usar a que preferir ou a que for mais conveniente na sua aplicação. Eu sempre prefiro não deixar que o JavaScript decida por mim o que ele fará durante a comparação de dois valores, tornando assim, o meu código mais previsível.
Caso queira debater, corrigir, acrescentar ou tirar alguma dúvida, fique à vontade.
Top comments (0)