Boolean() - функция для преобразования в логическое значение в JavaScript

Boolean() преобразует значение в true или false.

Это стандартный и явный способ получить логическое значение из строки, числа, null, undefined, массива, объекта или другого значения.

Обычно Boolean() используют, когда нужно не просто проверить условие, а именно получить результат типа boolean.

Синтаксис

Boolean(value)

value может быть почти любым значением.

Если вызвать Boolean() без аргумента, результатом будет false.

console.log(Boolean()); // false

Что делает Boolean()

Boolean() приводит значение к логическому типу.

console.log(Boolean(1));       // true
console.log(Boolean(0));       // false
console.log(Boolean("hello")); // true
console.log(Boolean(""));      // false

Результат всегда имеет тип boolean.

const result = Boolean("JavaScript");

console.log(result);        // true
console.log(typeof result); // "boolean"

Falsy-значения

В JavaScript есть несколько значений, которые после приведения становятся false. Их называют falsy.

false
0 и -0
0n
""
null
undefined
NaN

Все остальные значения становятся true.

console.log(Boolean(false));     // false
console.log(Boolean(0));         // false
console.log(Boolean(""));        // false
console.log(Boolean(null));      // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN));       // false

Строки

Для строк правило простое: пустая строка даёт false, любая непустая строка даёт true.

console.log(Boolean(""));       // false
console.log(Boolean("hello"));  // true
console.log(Boolean("0"));      // true
console.log(Boolean("false"));  // true
console.log(Boolean(" "));      // true

Это важный момент: строка "0" и строка "false" не считаются ложными, потому что они не пустые.

Числа и BigInt

Для чисел false дают только 0, -0 и NaN. Остальные числа становятся true.

console.log(Boolean(0));      // false
console.log(Boolean(-0));     // false
console.log(Boolean(NaN));    // false
console.log(Boolean(10));     // true
console.log(Boolean(-5));     // true
console.log(Boolean(3.14));   // true

С BigInt логика такая же:

console.log(Boolean(0n));   // false
console.log(Boolean(10n));  // true

null и undefined

Оба значения при приведении дают false.

console.log(Boolean(null));      // false
console.log(Boolean(undefined)); // false

Именно поэтому проверки вроде if (value) часто отсекают и null, и undefined.

Массивы и объекты

Пустой массив и пустой объект многим кажутся “пустыми”, но для JavaScript это всё равно объекты, а объекты считаются truthy.

console.log(Boolean([]));      // true
console.log(Boolean({}));      // true
console.log(Boolean([0]));     // true
console.log(Boolean({ a: 1 })); // true

Из-за этого Boolean([]) и Boolean({}) не подходят для проверки “есть ли элементы” или “есть ли свойства”.

Если нужен именно такой смысл, проверяют уже не сам объект, а его содержимое:

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

console.log(items.length > 0);         // false
console.log(Object.keys(user).length > 0); // false

Boolean() и условия

В if, while, тернарном операторе и логических выражениях JavaScript и так приводит значение к boolean.

const value = "hello";

if (value) {
  console.log("Условие выполнится");
}

Поэтому if (value) и if (Boolean(value)) в простых условиях обычно означают одно и то же.

Boolean() полезнее там, где нужно сохранить результат именно как true или false:

const input = "   text   ";
const hasText = Boolean(input.trim());

console.log(hasText); // true

Boolean() и двойное отрицание `!!`

Сокращение !!value делает то же самое, что и Boolean(value).

console.log(Boolean("JS")); // true
console.log(!!"JS");        // true

console.log(Boolean(0));    // false
console.log(!!0);           // false

Оба варианта корректны, но Boolean(value) обычно читается понятнее, особенно для начинающих.

Boolean() и filter(Boolean)

Иногда Boolean передают как колбэк в filter(), чтобы убрать falsy-значения.

const values = ["JavaScript", "", null, "DOM", undefined];
const result = values.filter(Boolean);

console.log(result); // ["JavaScript", "DOM"]

Это удобно, но важно понимать смысл: такой код удалит не только null и undefined, но и 0, false, NaN и пустые строки.

const values = [0, 1, 2, "", "text"];

console.log(values.filter(Boolean)); // [1, 2, "text"]

Если 0 или false для вас валидные значения, лучше написать более точную проверку.

Boolean() и new Boolean()

Это очень важное различие.

const a = Boolean(false);
const b = new Boolean(false);

console.log(typeof a); // "boolean"
console.log(typeof b); // "object"

Boolean() без new возвращает обычное логическое значение.

new Boolean() создаёт объект-обёртку, и в обычном коде это почти никогда не нужно.

Почему new Boolean() обычно не используют

Объект-обёртка ведёт себя не так, как обычный boolean.

const value = new Boolean(false);

if (value) {
  console.log("Условие выполнится");
}

Хотя внутри лежит false, сам объект считается truthy.

Из-за этого new Boolean() легко создаёт путаницу и странные баги в условиях.

Когда это полезно

Boolean() удобно использовать, когда:

нужно явно получить true или false
результат потом будет сохранён в переменную, возвращён из функции или отправлен дальше
хочется сделать приведение типа явным, а не полагаться на неявную логику условия

Пример:

function hasAccess(userRole) {
  return Boolean(userRole);
}

console.log(hasAccess("admin")); // true
console.log(hasAccess(""));      // false

Частые ошибки

Думать, что строка `"false"` даёт `false`

console.log(Boolean("false")); // true

Это строка, а не логическое значение. Она непустая, значит результат будет true.

Думать, что пустой массив или объект дают `false`

console.log(Boolean([])); // true
console.log(Boolean({})); // true

Для проверки пустоты массива или объекта нужны отдельные проверки.

Использовать new Boolean()

const value = new Boolean(false);

В обычном коде почти всегда лучше так:

const value = Boolean(false);

Слишком полагаться на truthy/falsy там, где нужна точность

const value = 0;

if (!value) {
  console.log("Сработает");
}

Если 0 - это допустимое значение, такая проверка может быть ошибкой. В таких местах лучше писать более точное условие.

Быстрая памятка

Boolean(value) преобразует значение в true или false
результат всегда имеет тип boolean
falsy-значений немного, всё остальное становится truthy
Boolean([]) и Boolean({}) дают true
Boolean(value) и !!value дают одинаковый результат
new Boolean() создаёт объект и обычно не нужен

Коротко

Boolean() - это стандартный способ явно преобразовать значение в логический тип в JavaScript. Главное, что стоит запомнить: пустая строка, 0, null, undefined и NaN дают false, но непустые строки, массивы и объекты дают true, а new Boolean() почти всегда лучше избегать.