Truthy e Falsy in JavaScript: controllare la presenza di dati con precisione

Introduzione

In JavaScript, ogni valore può essere valutato come true o false in un contesto booleano, anche se non è esplicitamente un booleano. Questo comportamento si basa sul concetto di truthy e falsy. Un valore truthy viene trattato come vero, mentre un valore falsy viene trattato come falso.

Questo tutorial si concentra su un sotto-argomento molto pratico: come usare truthy e falsy per verificare se una proprietà esiste davvero in un oggetto o in una struttura dati. È un caso comune quando lavori con dati provenienti da API, form utente o configurazioni. Sapere distinguere tra “valore assente” e “valore presente ma vuoto” ti aiuta a scrivere codice più robusto e meno ambiguo.

Per esempio, non sempre basta controllare se una variabile è “veramente valorizzata”: a volte un valore come 0 o "" è perfettamente valido, ma in JavaScript viene considerato falsy. Qui nasce il problema: se usi un controllo ingenuo, rischi di scartare dati corretti.

Codice completo

// Esempio pratico: gestione di un profilo utente ricevuto da API
// Alcuni campi possono essere assenti, altri possono avere valori falsy ma validi.

const profilo = {
  nome: "Luca",
  eta: 0,              // valore valido, ma falsy
  email: "",           // stringa vuota: può essere un valore intenzionale
  newsletter: false,   // booleano valido, ma falsy
  telefono: null        // valore assente
};

// FUNZIONE 1: controllo ingenuo
function mostraDatiIngenuo(user) {
  if (user.eta) {
    console.log("Età:", user.eta);
  } else {
    console.log("Età non disponibile");
  }

  if (user.email) {
    console.log("Email:", user.email);
  } else {
    console.log("Email non disponibile");
  }

  if (user.newsletter) {
    console.log("Iscritto alla newsletter");
  } else {
    console.log("Non iscritto alla newsletter");
  }
}

// FUNZIONE 2: controllo più preciso
function mostraDatiPreciso(user) {
  if (user.eta !== undefined && user.eta !== null) {
    console.log("Età:", user.eta);
  } else {
    console.log("Età non disponibile");
  }

  if (user.email !== undefined && user.email !== null) {
    console.log("Email:", user.email);
  } else {
    console.log("Email non disponibile");
  }

  if (user.newsletter === true) {
    console.log("Iscritto alla newsletter");
  } else if (user.newsletter === false) {
    console.log("Non iscritto alla newsletter");
  } else {
    console.log("Stato newsletter non definito");
  }
}

console.log("=== Controllo ingenuo ===");
mostraDatiIngenuo(profilo);

console.log("=== Controllo preciso ===");
mostraDatiPreciso(profilo);

// FUNZIONE 3: verifica di una proprietà presente nell´oggetto
function haProprieta(obj, key) {
  // Controlla se la proprietà esiste davvero nell´oggetto
  return Object.prototype.hasOwnProperty.call(obj, key);
}

console.log("Nome presente?", haProprieta(profilo, "nome"));       // true
console.log("Telefono presente?", haProprieta(profilo, "telefono")); // true
console.log("Indirizzo presente?", haProprieta(profilo, "indirizzo")); // false

// FUNZIONE 4: differenza tra valore assente e valore falsy
function leggiCampo(obj, key) {
  if (haProprieta(obj, key)) {
    return obj[key];
  }
  return "campo assente";
}

console.log("Telefono:", leggiCampo(profilo, "telefono")); // null
console.log("Nome:", leggiCampo(profilo, "nome"));         // Luca
console.log("CAP:", leggiCampo(profilo, "cap"));           // campo assente

Spiegazione

Il primo blocco mostra un approccio molto comune ma insidioso: usare direttamente un valore in un if. In JavaScript, questo significa affidarsi alla conversione implicita in booleano. Il problema è che alcuni valori validi risultano falsy:

0
"" (stringa vuota)
false
null
undefined
NaN

Nel nostro esempio, eta: 0 è un dato corretto, ma il controllo if (user.eta) fallisce e stampa “Età non disponibile”. Questo è un errore logico, non sintattico: il codice funziona, ma interpreta male il significato del dato.

La soluzione è distinguere tra:

valore assente → tipicamente null o undefined
valore presente ma falsy → come 0, false o ""

Per questo nel secondo esempio usiamo controlli espliciti come !== undefined e !== null. In questo modo accettiamo valori falsy validi, ma rifiutiamo solo l’assenza reale del dato.

Un altro punto importante è la funzione hasOwnProperty, usata per verificare se una proprietà esiste davvero nell’oggetto. Questo è utile quando vuoi sapere se un campo è stato fornito, indipendentemente dal suo valore. Ad esempio, telefono: null significa che la proprietà esiste ma non contiene un numero; invece indirizzo assente significa che il campo non è stato proprio inviato.

Questa distinzione è fondamentale quando lavori con:

payload JSON ricevuti da API;
form con campi opzionali;
configurazioni utente;
oggetti di stato in applicazioni frontend.

Best practice

Quando usi truthy e falsy in modo pratico, segui alcune regole semplici ma molto efficaci.

Non usare controlli impliciti se il valore può essere 0, false o "". In questi casi, un if (valore) può portare a falsi negativi.
Controlla esplicitamente null e undefined quando vuoi verificare la presenza di un dato.
Usa hasOwnProperty per sapere se una proprietà appartiene davvero all’oggetto, soprattutto con dati esterni.
Separa presenza e contenuto: prima chiediti se il campo esiste, poi se il suo valore è accettabile.
Documenta il significato dei valori falsy nel tuo codice. Per esempio, un booleano false può significare “opzione disattivata”, non “dato mancante”.

Un errore frequente è scrivere logiche come questa:

if (user.isActive) {
  // utente attivo
}

Se isActive è un booleano, va bene. Ma se il campo può essere undefined perché non ancora caricato, forse conviene distinguere tra:

true = attivo
false = inattivo
undefined = stato non ancora noto

Questa chiarezza evita bug sottili e rende il codice più leggibile per chi lo manterrà in futuro.

Riepilogo

Truthy e falsy sono un meccanismo molto utile in JavaScript, ma vanno usati con attenzione. Il punto chiave di questo tutorial è che non sempre un valore falsy significa “dato mancante”. In particolare, 0, false e "" possono essere valori legittimi.

Quando devi verificare la presenza di una proprietà in un oggetto:

evita controlli troppo generici con if (valore);
preferisci controlli espliciti su null e undefined;
usa hasOwnProperty se vuoi sapere se la chiave esiste davvero;
separa il concetto di “esistenza del campo” da quello di “validità del contenuto”.

Questa mentalità ti aiuta a scrivere codice più affidabile, soprattutto quando gestisci dati dinamici o provenienti dall’esterno.

Approfondisci con risorse ufficiali

MDN Web Docs - Truthy: documentazione utile per capire come JavaScript converte i valori in contesti booleani.
MDN Web Docs - Falsy: elenco e spiegazione dei valori considerati falsy.
MDN Web Docs - Object.prototype.hasOwnProperty(): riferimento ufficiale per verificare la presenza di proprietà in un oggetto.
MDN Web Docs - Boolean: approfondimento sulla conversione a booleano e sul comportamento dei valori primitivi.

Add as preferred source on Google