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

    JavaScript

    Булев тип

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

    Время чтения: 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.

    Читайте также