Comparação em

Sobre Comparação

Comparar números

Em JavaScript, os números podem ser comparados com os seguintes operadores relacionais e de igualdade.

O resultado da comparação é sempre um valor Boolean, ou seja, true ou false.

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

Comparar strings

Em JavaScript, também podes usar os operadores de comparação acima para comparar strings. Nesse caso, é aplicada uma ordem lexicográfica (de dicionário). Podes encontrar uma lista com a ordem exata de todos os carateres aqui.

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

Tens de ter cuidado quando comparas duas variáveis que parecem conter valores numéricos mas são do tipo string. Por causa da ordem lexicográfica, o resultado não será o mesmo que comparar valores do tipo Number.

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

Outra forma de comparar strings é o método localeCompare. Permite definir várias opções para ajustar a forma como as strings são comparadas.

Igualdade estrita

Talvez te perguntes por que razão se usam três sinais de igual para verificar a igualdade em JavaScript. O === representa a verificação de igualdade estrita, o que significa que não é realizada qualquer conversão de tipos e que valores de tipos diferentes são sempre desiguais.

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

Usar === e !== é a forma recomendada de verificar a igualdade em JavaScript.

Evitar a conversão implícita de tipos

Existem também o == e o !=, que representam a verificação de igualdade não estrita. Deves evitá-los, porque aplicam uma conversão implícita de tipos antes de realizarem a comparação. Os resultados nestes casos são difíceis de prever e, por vezes, não são o que esperarias. Podes ler mais sobre isto aqui.

0 == false;
// => true

Em teoria, também podes comparar valores de tipos diferentes (por exemplo, "1" < 2). Nesse caso, os valores são convertidos implicitamente para determinar se o resultado é verdadeiro ou falso. Tal como na verificação de igualdade não estrita, isto também não é recomendado, pelo mesmo motivo referido acima.

E o que deves fazer em vez disso? Podes aplicar a conversão explícita de tipos. Assim, podes garantir que os valores têm o tipo correto antes de realizares a comparação. O teu código fica mais fácil de entender e menos propenso a erros.