Em JavaScript, nem todo valor é estritamente um booleano (true / false), mas a linguagem frequentemente precisa interpretar valores como verdadeiros ou falsos em contextos como condicionais (if), loops e operadores lógicos. Entender quais valores são considerados falsy (equivalentes a false) e truthy (equivalentes a true) é fundamental para escrever código previsível e evitar erros comuns.

Nesta aula, vamos detalhar a lista oficial de valores falsy, métodos para converter explicitamente valores para booleano, o mecanismo de curto-circuito nos operadores &&, || e ??, e boas práticas para usar esses conceitos de forma segura.

Valores falsy

Em JavaScript, um valor é considerado falsy quando, ao ser convertido para booleano, resulta em false. Existem exatamente 6 valores falsy no JavaScript moderno (ES6+):

  • false — o próprio booleano falso.
  • 0 (zero) — incluindo -0 e 0n (BigInt zero).
  • '' (string vazia) — aspas simples, duplas ou template literals vazios.
  • null — ausência intencional de valor.
  • undefined — valor não atribuído.
  • NaN — Not a Number, resultado de operações inválidas.

Todos os demais valores são truthy, incluindo objetos vazios ({}), arrays vazios ([]), strings não vazias ('false'), números diferentes de zero, funções, etc. É importante memorizar essa lista, pois qualquer outro valor será interpretado como true em contextos booleanos.

// Exemplos de valores falsy em um if
if (false) console.log('não executa');
if (0) console.log('não executa');
if ('') console.log('não executa');
if (null) console.log('não executa');
if (undefined) console.log('não executa');
if (NaN) console.log('não executa');

// Exemplos de valores truthy
if ({}) console.log('objeto vazio é truthy');
if ([]) console.log('array vazio é truthy');
if ('false') console.log('string "false" é truthy');
if (42) console.log('número diferente de zero é truthy');

Conversão para booleano

Você pode converter explicitamente qualquer valor para booleano usando a função Boolean() ou o operador de dupla negação !! (lê-se bang bang). Ambos seguem as mesmas regras de truthy/falsy. A escolha entre eles é questão de estilo, mas !! é mais conciso e comum em código profissional.

console.log(Boolean(0));          // false
console.log(Boolean(''));         // false
console.log(Boolean('hello'));    // true
console.log(Boolean({}));         // true

// Usando !!
console.log(!!0);                 // false
console.log(!!'hello');           // true
console.log(!!null);              // false
console.log(!!NaN);               // false
console.log(!![]);                // true

Além disso, o operador de negação simples (!) também converte o valor para booleano e depois o inverte. Por isso, !! é duas negações que anulam a inversão, resultando no booleano original.

Curto-circuito

Os operadores lógicos && (AND), || (OR) e ?? (nullish coalescing) não retornam necessariamente um booleano. Eles avaliam seus operandos da esquerda para a direita e param assim que o resultado é determinado, retornando o valor do último operando avaliado. Esse comportamento é chamado de curto-circuito (short-circuit evaluation).

  • AND (&&): retorna o primeiro operando falsy, ou o último operando se todos forem truthy.
  • OR (||): retorna o primeiro operando truthy, ou o último operando se todos forem falsy.
  • Nullish coalescing (??): retorna o primeiro operando que não for null nem undefined; caso contrário, retorna o segundo operando.
// Exemplos com &&
console.log(0 && 'nunca');       // 0 (primeiro falsy)
console.log(1 && 2 && 3);         // 3 (todos truthy, retorna o último)

// Exemplos com ||
console.log('' || 'fallback');    // 'fallback' (primeiro truthy)
console.log(null || undefined || 0 || 'ok'); // 'ok'

// Exemplos com ??
console.log(null ?? 'padrão');    // 'padrão'
console.log(0 ?? 'padrão');       // 0 (0 não é null/undefined)
console.log('' ?? 'padrão');      // '' (string vazia não é null/undefined)

Boas práticas

Ao trabalhar com truthy/falsy e curto-circuito, siga estas recomendações para evitar bugs:

  • Evite usar || para valores que podem ser 0 ou '' válidos: prefira ?? quando quiser tratar apenas null/undefined como ausência. Exemplo: const nome = usuario.nome ?? 'Visitante'; em vez de usuario.nome || 'Visitante', que substituiria uma string vazia.
  • Não confie em truthy/falsy para verificar a existência de propriedades: use in ou hasOwnProperty. Exemplo: if ('prop' in obj) em vez de if (obj.prop), que falha se o valor for falsy.
  • Use !! para converter explicitamente: em APIs ou retornos de funções que exigem booleano, !!valor torna a intenção clara.
  • Cuidado com && em JSX/React: ao usar cond && <Component />, lembre-se de que se cond for 0 ou NaN, o componente não será renderizado, mas o valor 0 ou NaN pode aparecer na tela. Prefira cond ? <Component /> : null.
  • Documente intenções: ao usar curto-circuito para atribuição, comente por que a escolha é segura, especialmente se o código for revisado por outros.

Referências

Exercícios

  1. Qual dos seguintes valores é considerado falsy em JavaScript? [], '0', 0, {}, false, 'false'.

    ✓ Resposta: Os valores falsy são 0 e false. [] (array vazio) e {} (objeto vazio) são truthy. '0' e 'false' são strings não vazias, portanto truthy.

  2. Escreva uma expressão usando !! que converta o valor null para booleano. Qual será o resultado?

    ✓ Resposta: !!null retorna false, pois null é falsy.

  3. Dado o código const valor = 0 || 'padrão';, qual será o valor de valor? Explique por quê.

    ✓ Resposta: valor será 'padrão'. O operador || retorna o primeiro operando truthy. 0 é falsy, então ele avalia o segundo operando 'padrão', que é truthy, e o retorna.

  4. O que o seguinte código imprime? console.log(1 && 2 && null && 3);

    ✓ Resposta: Imprime null. O operador && retorna o primeiro valor falsy encontrado. 1 e 2 são truthy, então ele continua até null, que é falsy, e o retorna. O 3 não é avaliado.

  5. Reescreva a atribuição abaixo usando o operador de coalescência nula (??) para que o valor padrão seja aplicado apenas se nome for null ou undefined, e não para outros valores falsy: const nome = nomeUsuario || 'Visitante';.

    ✓ Resposta: const nome = nomeUsuario ?? 'Visitante';. Isso garante que se nomeUsuario for '' (string vazia) ou 0, o valor original será mantido, e o padrão só será usado se for null ou undefined.