Falsy y Truthy

En Javascript, tenemos un tipo de dato llamado Boolean que sólo puede tener dos valores: true (verdadero) o false (falso). Sin embargo, las cosas no son tan fáciles como parecen, y se pueden complicar un poco.

Conversiones de tipo de dato

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 nos sirve con esto para continuar.

Valores Falsy y Truthy

En Javascript, cuando trabajamos con valores es fácil predecir cuando un valor es verdadero o falso. Sin embargo, cuando trabajamos con valores que no son booleanos, y los utilizamos como booleanos, es más complejo determinar que valor tienen, pudiendo ocurrir cosas inesperadas.

Se le llama Falsy a un valor que aunque realmente no es un booleano false se comporta como tal. Por el lado opuesto, los valores Truthy son valores que aunque no sean booleanos, se comportan como un booleano true. JavaScript tiene reglas específicas para determinar si un valor es truthy o falsy:

• Cualquier valor false, obviamente, se considera false.
• Cualquier valor que sea 0, incluyendo 0.0 o 0n (bigint).
• Cualquier valor que sea una cadena vacía ("").
• Los valores especiales null, undefined y NaN también se consideran false.
• El resto de valores, se consideran truthy.

Observa el siguiente ejemplo, donde estamos forzando números para convertirlos en booleanos y comprobar el valor que devuelve:

Boolean(42);    // true (número positivo)
Boolean(0);     // false (cero)
Boolean(-42);   // true (número negativo)

Como puedes ver, y como 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 este ejemplo se puede ver claramente, porque estamos realizando la conversión de forma explícita.

Sin embargo, hay situaciones donde esa conversión no se realiza de forma explícita, y puede que no se aprecie bien. 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

En Javascript hay que tener mucho cuidado con estas conversiones implícitas, ya que pueden generar resultados engañosos e impredecibles. Una buena práctica es utilizar siempre el comparador de identidad === en lugar del comparador de igualdad ==, ya que el primero compara también el tipo de dato, y por lo tanto evita muchos errores, pero esto lo veremos un poco más adelante, en el apartado de Operadores de comparación.