Comparações

Conhecemos muitos operadores de comparação de matemática.

Em JavaScript eles são escritos assim:

• Mais/mais que: a > b, a < b.
• Mais/mais que ou igual a:: a >= b, a <= b.
• Equaisais: a == b, por favor note o sinal de dupla igualdade == significa o teste de igualdade, enquanto um simples a = b significa uma atribuição.
• Não é igual. Em matemática a notação é ≠, mas em JavaScript está escrito como a != b.

Neste artigo vamos aprender mais sobre diferentes tipos de comparações, como o JavaScript as faz, incluindo importantes peculiaridades.

No final você vai encontrar uma boa receita para evitar problemas relacionados ao “JavaScript quirks”.

Booleano é o resultado

Todos os operadores de comparação retornam um valor booleano:

• true – significa “sim”, “correto” ou “a verdade”.
• false – significa “não”, “errado” ou “não a verdade”.

Por exemplo:

alert( 2 > 1 ); // true (correct)alert( 2 == 1 ); // false (wrong)alert( 2 != 1 ); // true (correct)

let result = 5 > 4; // assign the result of the comparisonalert( result ); // true

alert( 'Z' > 'A' ); // truealert( 'Glow' > 'Glee' ); // truealert( 'Bee' > 'Be' ); // true

alert( '2' > 1 ); // true, string '2' becomes a number 2alert( '01' == 1 ); // true, string '01' becomes a number 1

alert( true == 1 ); // truealert( false == 0 ); // true

let a = 0;alert( Boolean(a) ); // falselet b = "0";alert( Boolean(b) ); // truealert(a == b); // true!

alert( 0 == false ); // true

alert( '' == false ); // true

Isto acontece porque operandos de diferentes tipos são convertidos em números pelo operador de igualdade ==. Uma string vazia, assim como false, torna-se um zero.

O que fazer se quisermos diferenciar 0 de false?

Um operador de igualdade rigoroso === verifica a igualdade sem conversão de tipo.

Em outras palavras, se a e b são de tipos diferentes, então a === b retorna imediatamente false sem uma tentativa de convertê-los.

Vamos tentar:

alert( 0 === false ); // false, because the types are different

Existe também um operador de “estrita não-qualidade” !== análogo a !=.

O operador de igualdade estrita é um pouco mais longo de escrever, mas torna óbvio o que se passa e deixa menos espaço para erros.

Comparação com nulo e indefinido

Existe um comportamento não-intuitivo quando null ou undefined são comparados com outros valores.

Para uma verificação de igualdade rigorosa===

Estes valores são diferentes, porque cada um deles é de um tipo diferente.

alert( null === undefined ); // false

Para uma verificação não restritiva==

Existe uma regra especial. Estes dois são um “casal doce”: eles se igualam (no sentido de ==), mas não qualquer outro valor.

alert( null == undefined ); // true

Para matemática e outras comparações< > <= >=

null/undefined são convertidos em números: null torna-se 0, enquanto undefined torna-se NaN.

Agora vamos ver algumas coisas engraçadas que acontecem quando aplicamos estas regras. E, o que é mais importante, como não cair numa armadilha com elas.

Resultado estranho: nulo vs 0

Vamos comparar null com um zero:

alert( null > 0 ); // (1) falsealert( null == 0 ); // (2) falsealert( null >= 0 ); // (3) true

Matematicamente, isso é estranho. O último resultado diz que “null é maior ou igual a zero”, então em uma das comparações acima deve ser true, mas ambas são falsas.

A razão é que uma verificação de igualdade == e comparações > < >= <= funcionam de forma diferente. As comparações convertem null para um número, tratando-o como 0. É por isso que (3) null >= 0 é verdadeiro e (1) null > 0 é falso.

Por outro lado, a verificação de igualdade == para undefined e null é definida de tal forma que, sem qualquer conversão, eles se igualam e não se igualam a mais nada. É por isso que (2) null == 0 é falso.

Um incomparável indefinido

O valor undefined não deve ser comparado com outros valores:

alert( undefined > 0 ); // false (1)alert( undefined < 0 ); // false (2)alert( undefined == 0 ); // false (3)

Por que é que não gosta tanto de zero? Sempre falso!

Obtemos estes resultados porque:

• Comparações (1) e (2) retorno false porque undefined é convertido para NaN e NaN é um valor numérico especial que retorna false para todas as comparações.
• A verificação de igualdade (3) retorna false porque undefined só é igual a null, undefined, e nenhum outro valor.

Problemas ovóides

Por que revimos estes exemplos? Devemos nos lembrar dessas peculiaridades o tempo todo? Bem, nem por isso. Na verdade, estas coisas complicadas vão-se tornando gradualmente familiares com o tempo, mas há uma forma sólida de evitar problemas com elas:

• Trate qualquer comparação com undefined/null excepto a estrita igualdade === com cuidados excepcionais.
• Não use comparações >= > < <= com uma variável que pode ser null/undefined, a menos que esteja realmente seguro do que está a fazer. Se uma variável pode ter esses valores, verifique por eles separadamente.

Resumo

• Os operadores de comparação retornam um valor booleano.
• Astringas são comparadas letra por letra na ordem do “dicionário”.
• Quando valores de tipos diferentes são comparados, eles são convertidos em números (com a exclusão de uma verificação de igualdade rigorosa).
• Os valores null e undefined iguais == um ao outro e não são iguais a nenhum outro valor.
• Tenha cuidado ao usar comparações como > ou < com variáveis que podem ocasionalmente ser null/undefined. Verificar por null/undefined separadamente é uma boa ideia.