skip to main content

Boolean

js

Кратко 🔗

Boolean — это логический тип в JavaScript. Его значение может быть либо истинным, либо ложным. На основе этого типа в программах составляют логические условия.

Значения такого типа часто называют булевыми, в честь Джорджа Буля, одного из основателей математической логики.

Значением логического типа может быть либо «истина», либо «ложь». Из-за этого логический тип также часто называют бинарным.

Создать булево значение можно несколькими способами.

Первый — явно указать значение используя ключевые слова:

const truthyValue = true // «Истина»
const falsyValue = false // «Ложь»

Второй способ — использовать конструктор Boolean:

const truthyValue = new Boolean(true) // также «Истина»
const falsyValue = new Boolean(false) // также «Ложь»

Этот способ считается устаревшим; не используйте его.

Используйте примитив вместо типа Boolean.

Третий — использовать выражение, которое можно свести к «истине» либо «лжи». (Мы поговорим о таких выражениях подробнее ниже.)

// Следующие два выражения истинны,
// потому что 4 действительно меньше 5.
const truthyValue = new Boolean(4 < 5)
const anotherTruthy = 4 < 5

// Следующие два — ложны,
// потому что 2 * 2 === 4.
const falsyValue = new Boolean(2 * 2 === 5)
const anotherFalsy = 2 * 2 === 5

Как пишется 🔗

Повторим 🙂

// 1. С помощью явного присвоения логических значений:
const truthyValue = true
const falsyValue = false

// 2. С помощью конструктора Boolean.
// (Способ устарел, и лучше его не использовать.)
const truthyValue = new Boolean(true)
const falsyValue = new Boolean(false)

// 3. С помощью приведения выражений к логическим значениям
// через функцию `Boolean`:
const truthyValue = Boolean(4 < 5)
const anotherTruthy = 4 < 5

const falsyValue = Boolean(2 * 2 === 5)
const anotherFalsy = 2 * 2 === 5

Дальше их можно использовать в if условиях:

const truthyValue = true

if (truthyValue) {
// Выполнится эта ветку кода,
// потому что оператор if проверяет,
// истинно ли выражение в скобках,
// и если да, то выполняет этот код.
} else {
// Эта ветка не выполнится.
}

// Однако:
const falsyValue = false

if (falsyValue) {
// Теперь не выполнится эта ветка,
// потому что выражение в скобках ложно.
} else {
// А вот эта — выполнится.
}

Как понять 🔗

Логические значения можно воспринимать, как ответ на закрытый вопрос — на который можно ответить только «Да» или «Нет».

Это же правило позволяет придумывать более подходящие названия для переменных, которые несут в себе логические значения.

const waitResponse = false
// Это плохое название для логического значения.
// Из него мы не можем понять,
// на какой вопрос отвечает эта переменная.

const shouldWaitForResponse = false
// Это хорошее название.
// Из него понятно, что оно отвечает на вопрос
// «Должен ли процесс подождать ответа за запрос?».

const isWaitingForResponse = false
// Тоже хорошее название.
// Оно отвечает на вопрос,
// «Ждёт ли процесс ответа прямо сейчас?».

Выражения 🔗

Выше мы говорили о выражениях, которые можно привести к логическим значениям. В JavaScript такими выражениями часто пользуются, чтобы построить условия.

Булевым выражением в JavaScript может быть что угодно.

Хитрость в том, чтобы знать, какое выражение в какое значение в итоге будет преобразовано. Например:

// Все эти выражения трансформируются в false.
const falsy1 = Boolean(),
falsy2 = Boolean(0),
falsy3 = Boolean(null),
falsy4 = Boolean(""),
falsy5 = Boolean(false)

// Все эти — в true.
const truthy1 = Boolean(true),
truthy2 = Boolean("true"),
truthy3 = Boolean("false"),
truthy4 = Boolean("Су Лин"),
truthy5 = Boolean([]),
truthy6 = Boolean({})

Обратите внимание, что строка 'false' преобразуется в логическое true. Так происходит потому, что непустая строка в JavaScript считается trhuthy значением — то есть таким, которое приводится к true.

То же и с пустыми массивом [] и объектом {}. Они считаются truthy значениями, поэтому приводятся к true.

Обратите внимание на списки truthy и falsy значений в JavaScript.

Сравнить строку с числом 🔗

В JavaScript интерпретатор может сам приводить типы, из-за чего мы можем сравнивать разные типы данных друг с другом.

JavaScript многие за это не любят, потому что сравнивая число со строкой, можно наделать ошибок.

Например, если мы сравним:

5 > "4" // true
5 > "4 " // true
5 > " 4 " // true
5 > "4." // true

При этом:

5 > "4 ." // false

Здесь всё дело в том, что именно JavaScript будет приводить (преобразование типов) и к какому типу.

Поэтому надо быть аккуратными со сравнениями, когда мы их используем как выражения для логических переменных.

Отрицание 🔗

Чтобы инвертировать значение логического типа, можно использовать логическое отрицание.

// Логическое отрицание в JS
// записывается через унарный оператор `!`
const truthy = true
const falsy = !truthy // false

Оно также используется, чтобы проверять обратные условия:

// Функция goToBed() выполнится,
// если isSleeping === false.
const isSleeping = false

if (!isSleeping) {
goToBed()
}

В работе 🔗

Всегда лучше использовать примитив или функцию Boolean. Конструктор new Boolean лучше не использовать.

🛠 Если вызывать Boolean как функцию, то она приводит переданный аргумент к логическому типу.

const falsy = Boolean("")
const truthy = Boolean(2 * 2 > 2)

🛠 Если вызвать двойное отрицание, можно быстро привести любое выражение к логическому типу.

const sum = 2 + 2
const truthy = !!sum // true

/**
Работает это так:
1. Первое отрицание приводит значение
к отрицательному логическому значению:
!sum -> false;
2. Второе отрицание инвертирует значение:
!false -> true;
*/