Булевый тип

Время чтения: 5 мин

Кратко

Секция статьи "Кратко"

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

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

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

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

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

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

        
        
          
        
      

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

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

        
        
          
        
      

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

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

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

Следующие два выражения истинны, потому что 4 действительно меньше 5.

        
          
          const truthyValue = new Boolean(4 < 5)const anotherTruthy = 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
          const falsyValue = new Boolean(2 * 2 === 5)
const anotherFalsy = 2 * 2 === 5

        
        
          
        
      

Как пишется

Секция статьи "Как пишется"

С помощью явного присвоения логических значений:

        
          
          const truthyValue = trueconst falsyValue = false
          const truthyValue = true
const falsyValue = false

        
        
          
        
      

С помощью конструктора Boolean. Способ устарел, и лучше его не использовать.

        
          
          const truthyValue = new Boolean(true)const falsyValue = new Boolean(false)
          const truthyValue = new Boolean(true)
const falsyValue = new Boolean(false)

        
        
          
        
      

С помощью приведения выражений к логическим значениям через функцию Boolean:

        
          
          const truthyValue = Boolean(4 < 5)const anotherTruthy = 4 < 5const falsyValue = Boolean(2 * 2 === 5)const anotherFalsy = 2 * 2 === 5
          const truthyValue = Boolean(4 < 5)
const anotherTruthy = 4 < 5

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

        
        
          
        
      

Булевы значения можно использовать в if условиях.

        
          
          const truthyValue = trueif (truthyValue) {  // Выполнится эта ветка кода,  // потому что оператор if проверяет,  // истинно ли выражение в скобках,  // и если да, то выполняет этот код.} else {  // Эта ветка не выполнится.}const falsyValue = falseif (falsyValue) {  // Теперь не выполнится эта ветка,  // потому что выражение в скобках ложно.} else {  // А вот эта — выполнится.}
          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)
          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({})
          const truthy1 = Boolean(true),
  truthy2 = Boolean("true"),
  truthy3 = Boolean("false"),
  truthy4 = Boolean("Су Лин"),
  truthy5 = Boolean([]),
  truthy6 = Boolean({})

        
        
          
        
      

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

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

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

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

Секция статьи "Сравнить строку с числом"

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

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

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

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

        
        
          
        
      

При этом:

        
          
          5 > "4 ."// false
          5 > "4 ."
// false

        
        
          
        
      

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

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

Отрицание

Секция статьи "Отрицание"

Чтобы инвертировать значение логического типа, можно использовать логическое отрицание. Логическое отрицание в JS записывается через унарный оператор !:

        
          
          const truthy = trueconst falsy = !truthy// false
          const truthy = true
const falsy = !truthy
// false

        
        
          
        
      

Оно также используется, чтобы проверять обратные условия. Функция goToBed выполнится, если isSleeping === false.

        
          
          const isSleeping = falseif (!isSleeping) {  goToBed()}
          const isSleeping = false

if (!isSleeping) {
  goToBed()
}

        
        
          
        
      

На практике

Секция статьи "На практике"

Саша Беспоясов

Секция статьи "Саша Беспоясов"

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

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

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

        
        
          
        
      

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

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

        
        
          
        
      

Работает это так:

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