Булев тип

Логический или булев тип 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

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать