Operadores de Comparação Javascript

Tempo de leitura: 3 minutos

Operadores de Comparação Javascript: Em qualquer linguagem de programação, a capacidade de comparar valores é o que permite que o código tome decisões. Em JavaScript, isso é feito por meio dos Operadores de Comparação, que avaliam uma relação e retornam um valor Booleano (true ou false).

O maior desafio em JS reside na distinção entre igualdade fraca e estrita, que é o ponto focal de bugs para iniciantes.

1. Igualdade: Estrita (`===`) vs. Fraca (`==`)

Esta é a distinção mais importante em JavaScript. Ela define se o comparador deve tentar converter os tipos de dados antes de avaliar a igualdade.

Operador	Nome	Função	Coerção de Tipo?	Uso Recomendado
`===`	Igualdade Estrita	Compara Valor E Tipo.	Não	SEMPRE Preferido.
`!==`	Desigualdade Estrita	Retorna `true` se Valor OU Tipo forem diferentes.	Não	SEMPRE Preferido.
`==`	Igualdade Fraca	Compara Valor após Coerção de tipo.	Sim	Evitar!
`!=`	Desigualdade Fraca	Diferente em Valor após Coerção.	Sim	Evitar!

🚨 Regra de Ouro: Use `===` e `!==`

O uso dos operadores estritos previne bugs de coerção:

JavaScript

let numero = 10;
let texto = "10";

console.log(numero == texto);  // true (O JS converte a String "10" para Number 10)
console.log(numero === texto); // false (Tipos são diferentes: Number vs String)

2. Operadores Relacionais

Estes operadores comparam a magnitude ou ordem dos valores, sendo diretos em comparações numéricas.

Operador	Significado	Exemplo
`>`	Maior que	`5 > 3` é `true`
`<`	Menor que	`5 < 3` é `false`
`>=`	Maior ou igual a	`5 >= 5` é `true`
`<=`	Menor ou igual a	`5 <= 5` é `true`

Strings: Ao comparar strings, a comparação é lexicográfica (alfabética) baseada na ordem Unicode. Ex: "a" < "b" é true.

3. Comparações Especiais e Referências

O comportamento de comparação em JavaScript tem nuances importantes para Objetos e valores especiais.

A. Objetos, Arrays e Funções (Referências)

Ao comparar dois objetos (incluindo Arrays e Funções), o JS não compara o conteúdo deles, mas sim se eles apontam para a mesma referência na memória.

JavaScript

let obj1 = { valor: 1 };
let obj2 = { valor: 1 };
let obj3 = obj1; // obj3 aponta para o mesmo objeto que obj1

console.log(obj1 === obj2); // false (Referências diferentes)
console.log(obj1 === obj3); // true (Mesma referência)

B. `null`, `undefined` e `NaN`

Comparação	Resultado (==)	Resultado (===)	Explicação
`null == undefined`	`true`	`false`	A igualdade fraca tem uma regra especial para eles.
`null === undefined`	`false`	`false`	Tipos diferentes (`null` é considerado um tipo object histórico).
`NaN == NaN`	`false`	`false`	NaN (Not a Number) não é igual a nada, nem a si mesmo.

Para verificar se um valor é NaN, use a função global isNaN().

4. Coerção de Tipos em Comparações Fracas (`==`)

A igualdade fraca pode converter booleanos, strings e números de formas inesperadas:

Expressão	Resultado	Explicação da Coerção
`true == 1`	`true`	`true` é convertido para o número `1`.
`false == 0`	`true`	`false` é convertido para o número `0`.
`0 == ""`	`true`	O JS tenta converter a string vazia para `0`.

✅ Conclusão Operadores de Comparação Javascript

Os operadores de comparação são o alicerce das decisões lógicas. O desenvolvedor JavaScript deve internalizar o uso exclusivo de igualdade estrita (===) e entender que a comparação de objetos funciona por referência, não por valor. Esse rigor é o que garante a precisão e a confiabilidade do seu código.

Toda jornada tem um início, e o início para se tornar um desenvolvedor web é dominar as seguintes tecnologias, que você encontra aqui mesmo: