Da trilha de JavaScript Este conceito ainda não saiu como card do dia. ir para o card de hoje

JavaScript Fundamentos Básico

Igualdade e coerção

Em JavaScript, a igualdade é um conceito central e muitas vezes confuso por causa da coerção de tipos. O operador == (igualdade frouxa) converte os operandos para o mesmo tipo antes de comparar, enquanto === (igualdade estrita) não faz conversão: se os tipos forem diferentes, o resultado é false. Entender essa diferença evita bugs sutis.

Além disso, valores são classificados como truthy (verdadeiros) ou falsy (falsos) quando usados em contextos booleanos, como em if ou &&. A lista de valores falsy é curta: false, 0, -0, 0n (BigInt zero), '' (string vazia), null, undefined e NaN. Todo o resto é truthy, incluindo '0', [] e {}.

A coerção implícita acontece em operações como +, -, *, comparações e na própria igualdade frouxa. Por exemplo, '5' - 1 resulta em 4 (número), enquanto '5' + 1 resulta em '51' (string). Já Object.is é uma terceira forma de comparar, que se comporta como === exceto para NaN e -0: Object.is(NaN, NaN) é true e Object.is(-0, 0) é false.

Neste card, você vai praticar esses quatro tópicos com exemplos e exercícios que mostram como evitar armadilhas comuns e escolher o operador certo para cada situação.

Pontos-chave

  • == compara após coerção de tipos; === compara sem coerção e é o recomendado na maioria dos casos.
  • Valores falsy: false, 0, -0, 0n, '', null, undefined, NaN. Todo o resto é truthy.
  • A coerção implícita ocorre em operações aritméticas, comparações e na igualdade frouxa.
  • Object.is é como ===, mas trata NaN como igual a si mesmo e diferencia -0 de 0.
  • Prefira === e Object.is para evitar surpresas; use == apenas quando souber exatamente o que está fazendo.
igualdade.js
// Igualdade e coerção em JavaScript

// == faz coerção de tipos antes de comparar
console.log(1 == '1');        // true
console.log(0 == false);      // true
console.log(null == undefined); // true

// === não faz coerção: tipos diferentes => false
console.log(1 === '1');       // false
console.log(0 === false);     // false
console.log(null === undefined); // false

// Truthy e falsy
if ('') {
  console.log('string vazia é truthy');
} else {
  console.log('string vazia é falsy'); // executa
}

if ([]) {
  console.log('array vazio é truthy'); // executa
}

// Coerção implícita em operações
console.log('5' - 1); // 4 (string convertida para número)
console.log('5' + 1); // '51' (número convertido para string)
console.log(+'42');   // 42 (conversão explícita para número)

// Object.is: comparação mais precisa
console.log(Object.is(NaN, NaN)); // true
console.log(NaN === NaN);         // false
console.log(Object.is(-0, 0));    // false
console.log(-0 === 0);            // true

Exercícios

  1. 1
    Fácil

    Comparando com === e ===

    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.

    Resolver
  2. 2
    Médio

    Verificando truthy e falsy

    Escreva uma função classificar(valor) que retorna 'truthy' se o valor for considerado verdadeiro em um contexto booleano, e 'falsy' caso contrário. Teste com os valores: 0, '', '0', [], {}, null, undefined, NaN, false e true.

    Resolver
  3. 3
    Desafio

    Comparação com Object.is e coerção

    Crie uma função comparar(a, b) que retorna um objeto com três propriedades: frouxa (resultado de a == b), estrita (resultado de a === b) e objectIs (resultado de Object.is(a, b)). Teste com pares de valores que evidenciem as diferenças: NaN e NaN, -0 e 0, '1' e 1, null e undefined, [] e [].

    Resolver

Continue estudando

← Anterior na trilhaTipos primitivos Próximo na trilha →Strings e template literals Trilha completaTodos os conceitos de JavaScript Qualquer linguagem🎲 Sortear outro conceito