Falsy y Truthy

En Javascript, tenemos un tipo de dato llamado Boolean que sólo puede tener dos valores:

• 1️⃣ true (verdadero)
• 2️⃣ false (falso)

Observa los siguientes ejemplos. Mientras que los primeros son valores directamente, los últimos son expresiones que se evaluan y devuelven un valor booleano:

const positive = true;
const negative = false;
const expression1 = 10 > 5;             // true
const expression2 = "hola" == "adios"   // false

Sin embargo, las cosas no son tan fáciles como parecen, y se pueden complicar un poco.

Conversiones explícitas

En Javascript, podemos forzar que valores de un tipo de dato se conviertan a otro, simplemente escribiendo el tipo de dato como si fuera una función. Por ejemplo, observa este caso donde convertimos un número en un String:

const number = 42;             // 42
number.constructor.name;       // "Number"

const text = String(number);   // "42"
text.constructor.name;         // "String"

Podemos hacer esto con múltiples tipos de datos como por ejemplo Number(), String(), Boolean(), RegExp(), Array() y muchos más, aunque lo más habitual es que, de usarlo, lo hagamos con los tres primeros. Hablaremos de las conversiones de tipos de datos más adelante, pero de momento esto nos sirve para continuar.

Valores Falsy y Truthy

En Javascript, si trabajamos con valores que no son booleanos, y los usamos como booleanos, es más complejo intuir que valor tienen, pudiendo ocurrir cosas inesperadas.

Boolean(true)     // true         (innecesario, ya era true)
Boolean(false)    // false        (innecesario, no es FALSY porque ya era false)
Boolean(5)        // true
Boolean(0)        // false        FALSY!
Boolean(-4)       // true
Boolean("Hola")   // true
Boolean("")       // false        FALSY!

Boolean(true)     // true         (innecesario, no es TRUTHY porque ya era true)
Boolean(false)    // false        (innecesario, ya era false)
Boolean(5)        // true         TRUTHY!
Boolean(0)        // false
Boolean(-4)       // true         TRUTHY!
Boolean("Hola")   // true         TRUTHY!
Boolean("")       // false

Si no lo comprendes bien, o vienes de otro lenguaje y esto te resulta molesto, atiende a esto. JavaScript tiene ciertas reglas específicas para determinar si un valor es truthy o falsy:

• 1️⃣ Cualquier valor false, (obviamente) se considera false.
• 2️⃣ Cualquier valor que sea 0, incluyendo 0.0 o 0n (bigint), se considera false.
• 3️⃣ Cualquier valor que sea una cadena vacía (""), se considera false.
• 4️⃣ Los valores especiales null, undefined y NaN también se consideran false.
• 5️⃣ El resto de valores, se consideran truthy, por lo que serán true.

Esto pasa en muchos lenguajes de programación: un valor numérico que es 0 equivale a false mientras que cualquier otro equivale a true. En Javascript se va más allá, ya que es menos estricto respecto a los tipos de datos.

Observa la siguiente lista de valores, que convertidos a son true (en verde) o false (en rojo):

Conversiones implícitas

Sin embargo, lo complicado llega porque hay situaciones donde esa conversión no se realiza de forma explícita (como hicimos antes), sino que ocurre de forma automática y puede pasar desapercibida.

Veamos estos ejemplos con Number y String:

// Se fuerza un texto a número (de forma explícita)
Number("42");       // 42

// Se fuerza un texto a número (de forma implícita)
+"42"               // 42

// Se concatenan (unen) dos strings ("22" + "22")
"22" + String(22);  // "2222"

// Se convierte el número a texto y se concatena (se une)
"22" + 22           // "2222"

Como puedes ver, los casos donde se realiza la conversión de forma implícita son más difíciles de predecir, por lo que hay que tener mucho cuidado. Observa ahora los siguientes casos que quizás podrían confundirte, ya que son casos engañosos que aparentan cosas distintas a las que son:

// Realmente no es cero, es un string que no es vacío
Boolean("0");           // true

// Realmente no false, es un string que no es vacío
Boolean("false");       // true

// Aunque sea un array vacío, es un elemento que existe
Boolean([]);            // true
Boolean([0]);           // true

// El signo negativo realiza una conversión implícita, evaluando array como número
Boolean(-[]);           // false
Number(-[]);            // 0

Ten mucho cuidado con estas conversiones implícitas, ya que pueden ser engañosos e impredecibles. Una buena práctica es usar siempre el comparador de identidad === en lugar del comparador de igualdad ==. Mientras que el último sólo compara el valor, el primero compara también el tipo de dato. Lo veremos un poco más adelante, en Operadores de comparación.