Valori truthy e falsy in JavaScript: l'elenco completo

Ogni valore ha un suo "umore" booleano

JavaScript ti permette di mettere qualsiasi valore dove ci si aspetta un booleano: dentro un if, come condizione di un while, accanto a && o ||. Quando lo fai, il valore viene convertito in true o false. I valori che diventano false si chiamano falsy. Tutti gli altri sono truthy.

if ("ciao") console.log("le stringhe sono truthy");
if (42) console.log("i numeri diversi da zero sono truthy");
if ([]) console.log("gli array vuoti sono truthy");
if ({}) console.log("gli oggetti vuoti sono truthy");

if (!0) console.log("lo zero è falsy");
if (!"") console.log("la stringa vuota è falsy");

Nessuna funzione di conversione, nessun cast esplicito: JavaScript lo fa in automatico. Le regole sono fisse e poche, quindi una volta che conosci l'elenco dei falsy, ogni altro caso viene da sé.

L'elenco completo dei falsy

I valori falsy sono esattamente sette. Tutto il resto del linguaggio è truthy.

const falsyValues = [false, 0, -0, 0n, "", null, undefined, NaN];

for (const v of falsyValues) {
    console.log(v, "->", Boolean(v));
}

Tutto qui. L'elenco:

• false: il booleano stesso.
• 0 e -0: entrambi gli zeri.
• 0n: lo zero BigInt.
• "": la stringa vuota (con apici singoli, doppi o backtick, è lo stesso).
• null: il valore "niente, di proposito".
• undefined: il valore "non impostato".
• NaN: il risultato di calcoli non validi come 0 / 0.

Impara a memoria questi sette. Poi, per qualsiasi valore su cui hai dubbi, chiediti: "è uno di quei sette?" Se no, è truthy.

Le sorprese: "0", [] e {}

Qui è dove chi inizia si scotta. Molti valori sembrano vuoti ma sono truthy:

console.log(Boolean("0"));       // true - è una stringa non vuota
console.log(Boolean("false"));   // true - è comunque una stringa non vuota
console.log(Boolean(" "));       // true - anche uno spazio conta
console.log(Boolean([]));        // true - un array vuoto è un oggetto
console.log(Boolean({}));        // true - un oggetto vuoto è un oggetto
console.log(Boolean(new Date()));// true

Le stringhe sono falsy solo quando hanno zero caratteri. "0" ha un carattere, quindi è truthy. Array e oggetti sono sempre truthy, anche quando sono vuoti, perché JavaScript li tratta come oggetti, e tutti gli oggetti sono truthy a prescindere da cosa contengono.

Se arrivi da Python, è il cambio di mentalità più grande. In Python [] e {} sono falsy. In JavaScript no.

Controllare se qualcosa è "vuoto" nel modo giusto

Dato che [] e {} sono truthy, non puoi usarli direttamente in un if per controllare se sono vuoti. Sii esplicito:

const items = [];
const user = {};

// Sbagliato - viene eseguito sempre:
if (items) console.log("items contiene qualcosa");

// Giusto:
if (items.length === 0) console.log("items è vuoto");
if (Object.keys(user).length === 0) console.log("user non ha campi");

Lo stesso vale per le stringhe, se vuoi considerare vuota una stringa fatta solo di spazi:

const input = "   ";
if (input) console.log("truthy, ma non molto utile");
if (input.trim() === "") console.log("davvero vuota");

Truthy/falsy è una scorciatoia comoda, non un sostituto del ragionare su cosa significa "vuoto" per i tuoi dati.

Convertire in un vero booleano

A volte ti serve un vero true o false, non solo un valore vagamente truthy. Ci sono due modi idiomatici:

const name = "Rosa";

console.log(Boolean(name));  // true
console.log(!!name);         // true

const empty = "";
console.log(Boolean(empty)); // false
console.log(!!empty);        // false

Boolean(x) è la conversione esplicita. !!x è la stessa cosa in forma abbreviata: il primo ! converte in booleano e inverte, il secondo ! inverte di nuovo. Sono comuni entrambi. !! è più breve; Boolean() si legge meglio.

Vedrai spesso !! nelle istruzioni return, quando una funzione deve restituire un booleano pulito:

function hasItems(arr) {
    return !!arr && arr.length > 0;
}

console.log(hasItems([1, 2]));   // true
console.log(hasItems([]));        // false
console.log(hasItems(null));      // false

Truthy e falsy con && e ||

Gli operatori logici non restituiscono true o false: restituiscono uno degli operandi. Quale dei due dipende dalla truthiness:

console.log("a" && "b");       // "b"  - both truthy, returns the last
console.log(0 && "b");         // 0    - short-circuits on the falsy one
console.log("" || "fallback"); // "fallback" - first is falsy, returns the second
console.log("hi" || "fallback");// "hi" - first is truthy, returns it

Ecco perché value || defaultValue è uno schema così diffuso per i valori predefiniti. Ma nasconde una trappola: tratta tutti i valori falsy allo stesso modo, compresi 0 e "", che spesso sono input validi:

function greet(name) {
    const who = name || "sconosciuto";
    console.log("Ciao, " + who);
}

greet("Ada");   // Ciao, Ada
greet("");      // Ciao, sconosciuto - ma forse "" era voluto?
greet(0);       // Ciao, sconosciuto - e 0 potrebbe essere un id valido

Se vuoi ripiegare su un valore predefinito solo con null o undefined, usa invece l'operatore di nullish coalescing ??. Ha una pagina tutta sua.

Promemoria rapido

// Falsy - all seven:
Boolean(false);     // false
Boolean(0);         // false
Boolean(-0);        // false
Boolean(0n);        // false
Boolean("");        // false
Boolean(null);      // false
Boolean(undefined); // false
Boolean(NaN);       // false

// Truthy - everything else:
Boolean("0");       // true
Boolean("false");   // true
Boolean([]);        // true
Boolean({});        // true
Boolean(() => {});  // true
Boolean(Infinity);  // true
Boolean(-Infinity); // true

Stampalo, attaccalo al monitor e vai avanti con la tua vita.

Prossimo passo: iteratori e generatori

Ora che hai in mano condizioni e cicli, il prossimo capitolo mostra come JavaScript permette ai valori di prodursi su richiesta. Iteratori e generatori sono il meccanismo dietro for...of, lo spread e molte API moderne, e sono il prossimo argomento.