Fácil JavaScript

Comparando com === e ===

Enunciado

Crie um programa que compare os valores 0, '0', false e null usando == e ===, e imprima o resultado de cada comparação. Use console.log para mostrar se são iguais ou não.

Requisitos

  • Imprima o resultado de 0 == '0' e 0 === '0'.
  • Imprima o resultado de false == 0 e false === 0.
  • Imprima o resultado de null == undefined e null === undefined.

Código inicial

// Compare os valores usando == e ===
// e imprima os resultados

Saída esperada

0 == '0': true
0 === '0': false
false == 0: true
false === 0: false
null == undefined: true
null === undefined: false
Ver dica

Lembre-se: == converte tipos antes de comparar; === não converte. Use template strings para formatar a saída.

Mostrar solução 
// Comparações com == e ===
console.log(`0 == '0': ${0 == '0'}`);       // true
console.log(`0 === '0': ${0 === '0'}`);     // false
console.log(`false == 0: ${false == 0}`);   // true
console.log(`false === 0: ${false === 0}`); // false
console.log(`null == undefined: ${null == undefined}`);   // true
console.log(`null === undefined: ${null === undefined}`); // false

Passo a passo

  1. Usamos console.log com template strings para imprimir cada comparação de forma legível.
  2. 0 == '0' é true porque o operador == converte a string '0' para o número 0 antes de comparar.
  3. 0 === '0' é false porque === exige que os tipos sejam iguais; número e string são diferentes.
  4. false == 0 é true porque false é convertido para 0 na comparação frouxa.
  5. false === 0 é false porque os tipos boolean e number são diferentes.
  6. null == undefined é true por definição da linguagem: eles são considerados iguais na comparação frouxa.
  7. null === undefined é false porque são tipos diferentes (null e undefined).

Por que funciona

A igualdade frouxa (==) segue regras de coerção definidas na especificação ECMAScript. Quando os tipos diferem, o JavaScript tenta convertê-los para um tipo comum (geralmente número) antes de comparar. Já a igualdade estrita (===) compara tipo e valor sem conversão. Por isso, 0 == '0' é true, mas 0 === '0' é false.

Erros comuns

  • Achar que null == undefined é false. Na verdade, é true por definição. Se quiser diferenciar, use ===.
  • Usar == sem saber as regras de coerção. Por exemplo, [] == false é true porque ambos são convertidos para 0. Prefira ===.
  • Esquecer que NaN não é igual a nada, nem a si mesmo: NaN == NaN e NaN === NaN são false. Use Object.is(NaN, NaN) ou Number.isNaN().

Outra forma de resolver

Você pode usar Object.is para comparações mais previsíveis, mas ele não é equivalente a == ou === em todos os casos. Para este exercício, === é o mais indicado.

Saída esperada

0 == '0': true
0 === '0': false
false == 0: true
false === 0: false
null == undefined: true
null === undefined: false