/ ↲
    Расширенный поиск

    JavaScript

    Булевый тип

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

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

    1. Кратко
    2. Как понять
      1. Выражения
      2. Сравнить строку с числом
      3. Отрицание
    3. На практике
      1. bespoyasov

    Кратко

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

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

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

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

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

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

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

            
          
          const truthyValue = Boolean(true) // также «Истина»const falsyValue = Boolean(false) // также «Ложь»
          const truthyValue = Boolean(true) // также «Истина»
const falsyValue = 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

    Булевы значения можно использовать в 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()
}

    На практике

    bespoyasov

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

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

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

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