Тут парень, потеет и вытирает лоб, потому что перед ним выбор из двух кнопок: true и false — и он не знает, что нажать
Иллюстрация: Кира Кустова

Булев тип

На некоторые вопросы нужно отвечать только «да» или «нет». Булев тип как раз про это.

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

Кратко

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

Логический или булев тип boolean может принимать лишь истинное (true) и ложное (false) значения. Назван он так в честь Джорджа Буля, одного из основателей математической логики.

Значения этого типа используются в условных выражениях.

Как пишется

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

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

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

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

        
        
          
        
      

Второй способ — использовать метод Boolean:

        
          
          const truthyValue = Boolean(1) // «Истина»const falsyValue = Boolean('') // «Ложь»
          const truthyValue = Boolean(1) // «Истина»
const falsyValue = Boolean('') // «Ложь»

        
        
          
        
      

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

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

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

        
          
          const truthyValue = Boolean(4 < 5)const anotherTruthy = 4 < 5console.log(truthyValue)// trueconsole.log(anotherTruthy)// true
          const truthyValue = Boolean(4 < 5)
const anotherTruthy = 4 < 5

console.log(truthyValue)
// true
console.log(anotherTruthy)
// true

        
        
          
        
      

Следующие два — ложны, потому что 2 * 2 === 4:

        
          
          const falsyValue = Boolean(2 * 2 === 5)const anotherFalsy = 2 * 2 === 5console.log(falsyValue)// falseconsole.log(anotherFalsy)// false
          const falsyValue = Boolean(2 * 2 === 5)
const anotherFalsy = 2 * 2 === 5

console.log(falsyValue)
// false
console.log(anotherFalsy)
// false

        
        
          
        
      

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

        
          
          const isCorrect = trueif (isCorrect) {  // Выполнится эта ветка кода,  // потому что оператор if проверяет,  // истинно ли выражение в скобках,  // и если да, то выполняет этот код.} else {  // Эта ветка не выполнится.}const isWrong = falseif (isWrong) {  // Теперь не выполнится эта ветка,  // потому что выражение в скобках ложно.} else {  // А вот эта — выполнится.}
          const isCorrect = true
if (isCorrect) {
  // Выполнится эта ветка кода,
  // потому что оператор if проверяет,
  // истинно ли выражение в скобках,
  // и если да, то выполняет этот код.
} else {
  // Эта ветка не выполнится.
}

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

        
        
          
        
      

Как понять

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

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

Это понимание позволяет придумывать более подходящие названия для булевых переменных.

Плохое название для логического значения не помогает понять, на какой вопрос отвечает переменная. Например, waitResponse — не очень хорошее название.

А вот переменная с именем shouldWaitForResponse отвечает на более чёткий вопрос «Должен ли процесс подождать ответа за запрос?». А переменная isWaitingForResponse — на вопрос «Ждёт ли процесс ответа прямо сейчас?»

Обычно логическим переменным дают названия, начинающиеся с английских глаголов is, should, does, can и подобных.

Выражения

Секция статьи "Выражения"

Выше мы говорили о выражениях, которые можно привести к логическим значениям. В 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 попытается преобразовать строку в число. Если это получается, то мы сравниваем числа 5 и 4, а если нет, то 5 и NaN (число, любое сравнение с которым всегда false).

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

Отрицание

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

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

        
          
          const truthy = trueconst falsy = !truthyconsole.log(falsy)// false
          const truthy = true
const falsy = !truthy

console.log(falsy)
// false

        
        
          
        
      

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

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

if (!isSleeping) {
  goToBed()
}

        
        
          
        
      

На практике

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

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

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

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

        
          
          const sum = 2 + 2const truthy = !!sumconsole.log(truthy)// true
          const sum = 2 + 2
const truthy = !!sum

console.log(truthy)
// true

        
        
          
        
      

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

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