== vs === em JavaScript: diferenças e como evitar erros no código

Introdução: por que essa pergunta atormenta milhares de desenvolvedores

Se você já escreveu código em JavaScript, com certeza já passou por uma situação em que seu código não funcionou como esperado, e o culpado eram os operadores de comparação == e ===. A pergunta "Which equals operator (== vs ===) should be used in JavaScript comparisons?" está entre as mais populares no Stack Overflow — já foi vista por milhões de desenvolvedores. E não é por acaso.

A diferença entre a igualdade não estrita (==) e a igualdade estrita (===) é uma das primeiras armadilhas que pegam iniciantes. Mas até programadores experientes às vezes esquecem dos detalhes. Neste artigo, vamos explorar todas as pegadinhas, mostrar exemplos reais de como evitar erros comuns e dar regras claras sobre quando usar cada um.

Pronto? Vamos nessa!

1. O básico: o que são == e === em JavaScript

Ambos os operadores são usados para comparar valores. Mas há uma diferença fundamental:

\n
• == (igualdade não estrita) — compara valores com coerção de tipo. Se os tipos forem diferentes, o JavaScript tenta converter um valor para o tipo do outro antes de comparar.
\n
• === (igualdade estrita) — compara tanto o valor quanto o tipo de dado, sem qualquer conversão. Se os tipos forem diferentes, o resultado é false na hora.
\n

Parece simples? Mas o diabo, como sempre, está nos detalhes.

Exemplo para aquecer

console.log(5 == "5");   // true (o número 5 é convertido para a string "5")\nconsole.log(5 === "5");  // false (tipos diferentes: number vs string)

O primeiro caso é uma armadilha clássica: você espera false, mas recebe true. E isso é só o começo.

2. Como o JavaScript faz a coerção de tipos: pontos pouco óbvios

Ao usar ==, o interpretador executa algoritmos complexos de conversão. Veja alguns exemplos que podem surpreender:

Strings e números

console.log(0 == false);   // true (false → 0)\nconsole.log("" == false);  // true ("" → 0)\nconsole.log(null == undefined); // true (regra especial)\nconsole.log(null === undefined); // false

O null e o undefined são especialmente perigosos: com ==, eles são iguais entre si, mas não são iguais a mais nada (nem a false ou 0).

Arrays e objetos

console.log([] == false);   // true (array vazio → "" → 0)\nconsole.log([1] == true);   // true ([1] → "1" → 1)\nconsole.log([1,2] == "1,2"); // true (array → string)

Aqui já fica difícil acompanhar a lógica. É por causa dessas "surpresas" que muitos desenvolvedores simplesmente evitam o ==.

3. Erros reais da prática: quando o == quebra a lógica

Vamos analisar algumas situações que podem gerar bugs em produção.

Erro 1: Verificação de valor vazio

function isEmpty(value) {\n    return value == false; // ruim!\n}\n\nconsole.log(isEmpty(0));      // true\nconsole.log(isEmpty(""));     // true\nconsole.log(isEmpty(null));   // true? Não, null == false → false\nconsole.log(isEmpty([]));     // true? Sim, [] == false → true\nconsole.log(isEmpty("texto")); // false\n

Parece que funciona, mas na verdade null não é igual a false com == — dá false. E um array vazio é considerado true? Não, ele é convertido para 0. Confusão total. O correto é usar uma verificação estrita ou condições explícitas.

Erro 2: Comparação com undefined

let usuario = { nome: "Alice" };\nif (usuario.idade == undefined) { // ok, mas melhor usar ===\n    console.log("Idade não informada");\n}\n// Mas e se idade = null?\nusuario.idade = null;\nconsole.log(usuario.idade == undefined); // true! E deveria ser false