Truthy и Falsy в JavaScript: полный список

У каждого значения есть своё «булево настроение»

В JavaScript на месте булева значения можно подставить любое значение — внутри if, в условии while, рядом с && или ||. В этот момент значение приводится к true или false. Те, что превращаются в false, называют falsy (ложными), все остальные — truthy (истинными).

if ("hello") console.log("строки истинны");
if (42) console.log("ненулевые числа истинны");
if ([]) console.log("пустые массивы истинны");
if ({}) console.log("пустые объекты истинны");

if (!0) console.log("ноль ложен");
if (!"") console.log("пустая строка ложна");

Никакой функции-конвертера, никакого явного каста — JavaScript делает всё сам. Правила зафиксированы и их немного, так что достаточно запомнить список falsy-значений — и всё остальное встаёт на свои места.

Полный список falsy-значений в JavaScript

Ровно семь значений считаются falsy. Всё остальное в языке — truthy.

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

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

Вот и весь список:

• false — собственно сам булев false.
• 0 и -0 — оба нуля.
• 0n — BigInt-ноль.
• "" — пустая строка (одинарные, двойные, обратные кавычки — без разницы).
• null — значение «намеренно ничего».
• undefined — значение «не задано».
• NaN — результат некорректной математики вроде 0 / 0.

Запомните эти семь. И дальше, когда сомневаетесь насчёт любого значения, просто спрашивайте себя: «оно входит в эти семь?» Если нет — значит, truthy.

Подводные камни: "0", [] и {}

Вот тут новички чаще всего обжигаются. Куча значений выглядят пустыми, но на самом деле truthy:

console.log(Boolean("0"));       // true — это непустая строка
console.log(Boolean("false"));   // true — всё ещё непустая строка
console.log(Boolean(" "));       // true — пробел тоже считается
console.log(Boolean([]));        // true — пустой массив является объектом
console.log(Boolean({}));        // true — пустой объект является объектом
console.log(Boolean(new Date()));// true

Строка считается falsy только если в ней ноль символов. У "0" один символ — значит, это truthy. А вот массивы и объекты в JavaScript всегда truthy, даже пустые: движок воспринимает их как объекты, а любой объект — truthy, что бы в нём ни лежало (или не лежало).

Если ты пришёл из Python — это, пожалуй, самый непривычный момент. Там [] и {} — falsy. В JavaScript — нет.

Как правильно проверять массив или объект на пустоту

Раз [] и {} — это truthy, напрямую запихнуть их в if для проверки на пустоту не получится. Пиши явно:

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

// Неправильно — выполняется всегда:
if (items) console.log("items has stuff");

// Правильно:
if (items.length === 0) console.log("items is empty");
if (Object.keys(user).length === 0) console.log("user has no fields");

То же самое со строками — если вы хотите считать строку из одних пробелов пустой:

const input = "   ";
if (input) console.log("истинно, но бесполезно");
if (input.trim() === "") console.log("на самом деле пусто");

Truthy и falsy — это удобная сокращённая запись, а не замена размышлениям о том, что именно «пусто» для ваших данных.

Приведение к boolean в JavaScript

Иногда нужно получить настоящее true или false, а не просто «truthy-подобное» значение. Для этого есть два приёма:

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) — это явное приведение к boolean. !!x делает ровно то же самое, только короче: первый ! превращает значение в булево и инвертирует его, а второй ! возвращает исходный смысл. Оба варианта встречаются повсеместно. !! лаконичнее, а Boolean() читается понятнее.

Двойное отрицание !! часто попадается в return, когда функция должна вернуть честный boolean:

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

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

Truthy/Falsy в связке с && и ||

Логические операторы в JavaScript не возвращают true или false — они возвращают один из операндов. А какой именно — зависит от его «правдивости» (truthy/falsy):

console.log("a" && "b");       // "b"  — оба истинны, возвращается последнее
console.log(0 && "b");         // 0    — короткое замыкание на ложном
console.log("" || "fallback"); // "fallback" — первое ложно, возвращается второе
console.log("hi" || "fallback");// "hi" — первое истинно, возвращается оно

Именно поэтому шаблон value || defaultValue так часто встречается для значений по умолчанию. Но тут есть ловушка: он одинаково относится ко всем falsy-значениям, включая 0 и "", а это зачастую вполне валидные входные данные:

function greet(name) {
    const who = name || "stranger";
    console.log("Привет, " + who);
}

greet("Ada");   // Hello, Ada
greet("");      // Hello, stranger — но, возможно, "" было намеренным?
greet(0);       // Hello, stranger — и 0 может быть допустимым id

Если нужно подставить значение по умолчанию только для null или undefined, берите оператор нулевого слияния ??. Про него есть отдельная статья.

Краткая шпаргалка

// Falsy — все семь:
Boolean(false);     // false
Boolean(0);         // false
Boolean(-0);        // false
Boolean(0n);        // false
Boolean("");        // false
Boolean(null);      // false
Boolean(undefined); // false
Boolean(NaN);       // false

// Truthy — всё остальное:
Boolean("0");       // true
Boolean("false");   // true
Boolean([]);        // true
Boolean({});        // true
Boolean(() => {});  // true
Boolean(Infinity);  // true
Boolean(-Infinity); // true

Распечатай, приклей к монитору и живи дальше.

Дальше: итераторы и генераторы

Условные конструкции и циклы уже в кармане — значит, пора разобраться, как в JavaScript значения умеют «выдаваться» по запросу. Итераторы и генераторы — это как раз та механика, которая стоит за for...of, оператором spread и кучей современных API. Про них и поговорим в следующей главе.