Логический тип данных (bool) может иметь одно из двух значений, true (истина) или false (ложь). Булевы операторы используются в программировании для сравнения и для контроля потока процессов программы.

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

Тип данных булевых операторов в Go называется bool, все символы указаны строчными буквами. Значения true и false всегда обозначаются символами t и f в нижнем регистре, поскольку это особые значения в Go.

В этом обучающем руководстве рассказывается об основах, которые помогут вам понять принципы работы типа данных bool, включая сравнение булевых операторов, логические операторы и таблицы истины.

Сравнительные операторы

В программировании сравнительные операторы используются для сравнения значений и оценки значения отдельного булева значения true или false.

В таблице ниже показаны булевы операторы сравнения.

Оператор Значение
== равно
! = не равно
< меньше
> больше
<= меньше или равно
>= больше или равно

Чтобы понять принцип работы этих операторов, присвоим два целочисленных значения двум переменным в программе Go:

x := 5
y := 8

Поскольку в этом примере x имеет значение 5, эта переменная меньше y со значением 8.

Используем эти две переменные и их значения для проверки операторов из предыдущей таблицы. В этой программе вы предписываете Go вывести результат true или false для каждого оператора сравнения. Чтобы лучше понять результат, укажите Go распечатать строку, чтобы показывать, что именно оценивается:

package main

import "fmt"

func main() {
    x := 5
    y := 8

    fmt.Println("x == y:", x == y)
    fmt.Println("x != y:", x != y)
    fmt.Println("x < y:", x < y)
    fmt.Println("x > y:", x > y)
    fmt.Println("x <= y:", x <= y)
    fmt.Println("x >= y:", x >= y)
}
Output
x == y: false x != y: true x < y: true x > y: false x <= y: true x >= y: false

Следуя математической логике, Go оценивает выражения следующим образом:

  • 5 (x) равно 8 (y)? false
  • 5 не равно 8? true
  • 5 меньше 8? true
  • 5 больше 8? false
  • 5 меньше или равно 8? true
  • 5 не меньше или равно 8? false

Хотя здесь использовались целые числа, вы можете заменить их значениями с плавающей точкой.

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

Вы можете посмотреть практический пример сравнения строк:

Sammy := "Sammy"
sammy := "sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)
Output
Sammy == sammy: false

Строка Sammy не равна строке sammy, поскольку они не точно совпадают; одно значение начинается с заглавной S, а другое — с s в нижнем регистре. Однако если вы добавите другую переменную, которой присвоено значение Sammy, они будут равняться:

Sammy := "Sammy"
sammy := "sammy"
alsoSammy := "Sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)
fmt.Println("Sammy == alsoSammy", Sammy == alsoSammy)
Output
Sammy == sammy: false Sammy == alsoSammy true

Также вы можете использовать для сравнения двух строк и другие операторы сравнения, в том числе > и <. Go проводит лексикографическое сравнение строк, используя значения ASCII для символов.

Также вы можете оценить булевы значения с помощью операторов сравнения:

t := true
f := false

fmt.Println("t != f: ", t != f)
Output
t != f: true

Предыдущий блок кода оценил, что true не равняется false.

Обратите внимание на различия между операторами = и ==.

x = y   // Sets x equal to y
x == y  // Evaluates whether x is equal to y

Первый оператор = является оператором присвоения, который задает одно значение равным другому. Второй оператор == является оператором сравнения и оценивает, что два значения будут равны.

Логические операторы

Для сравнения используется два логических оператора. Они оценивают выражения до булевых значений, возвращая true или false. Это операторы &&, || и !, которые определены в следующем списке:

  • && (x && y) является оператором и. Это верно, если оба выражения верны.
  • || (x || y) является оператором или. Это верно, если хотя бы одно выражение является верным.
  • ! (! x) является оператором нет. Это верно, только если выражение является ложным.

Логические операторы обычно используются для оценки истинности двух или более выражений. Например, они могут использоваться для определения того, является ли оценка проходной, и зарегистрирован ли студент на курсе, и если в обоих случаях выражение является истинным, студенту будет присвоена оценка в системе. Еще один пример позволяет определить, что пользователь является действующим активным клиентом интернет-магазина на основании того, имеется ли у него кредит в магазине и совершались ли покупки за последние 6 месяцев.

Чтобы понять принцип работы логических операторов, оценим три выражения:

fmt.Println((9 > 7) && (2 < 4))   // Both original expressions are true
fmt.Println((8 == 8) || (6 != 6)) // One original expression is true
fmt.Println(!(3 <= 1))            // The original expression is false
Output
true true true

В первом случае fmt.Println((9 > 7) && (2 < 4)) оба выражения 9 > 7 и 2 < 4 должны быть оценены как истинные, поскольку использовался оператор и.

Во втором случае fmt.Println((8 == 8) || (6 ! = 6)), поскольку 8 == 8 оценивается как истина, не имеет значения, что 6 ! = 6 оценивается как ложь, поскольку использовался оператор или. Если бы вы использовали оператор и, результат был бы ложным.

В третьем случае, fmt.Println(!( 3 <= 1)), оператор нет аннулирует ложное значение, возвращаемое выражением 3 <=1.

Заменим целые числа числами с плавающей точкой и рассмотрим ложные оценки:

fmt.Println((-0.2 > 1.4) && (0.8 < 3.1))  // One original expression is false
fmt.Println((7.5 == 8.9) || (9.2 != 9.2)) // Both original expressions are false
fmt.Println(!(-5.7 <= 0.3))               // The original expression is true

В этом примере:

  • и требует, чтобы хотя бы одно выражение оценивалось как ложное.
  • или требует, чтобы оба выражения оценивались как ложные.
  • ! внутреннее выражение должно быть истинным, чтобы новое выражение оценивалось как ложное.

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

Также вы можете создавать комплексные выражения, используя операторы &&, || и !:

!((-0.2 > 1.4) && ((0.8 < 3.1) || (0.1 == 0.1)))

Вначале рассмотрим внутреннее выражение: (0.8 < 3.1) || (0.1 == 0.1). Это выражение оценивается как истинное (true), поскольку оба математических выражения истинные.

Затем Go берет возвращаемое значение true и сочетает его со следующим внутренним выражением: (-0.2 > 1.4) && (true). В этом примере возвращается значение false, поскольку математическое выражение -0.2 > 1.4 является ложным, а сочетание (false) и (true) возвращает результат false.

В заключение идет внешнее выражение: !( false), которое оценивается как true, так что окончательное возвращаемое при печати этого выражения значение выглядит так:

Output
true

Логические операторы &&, || и ! оценивают выражения и возвращают булевы значения.

Таблицы истины

Математическая логика — непростая дисциплина, но вы можете выборочно изучать ее для совершенствования своего алгоритмического мышления при программировании.

Далее приведены таблицы истины для оператора сравнения ==, а также каждого из логических операторов &&, || и !. Хотя возможно вы и не будете их использовать, запомнить их полезно, потому что это упростит процесс принятия решений при программировании.

== (равно) Таблица истины

x == y возвращает
true == true true
true == false false
false == true false
false == false true

&& (и) Таблица истины

x и y возвращает
true и true true
true и false false
false и true false
false и false false

|| (или) Таблица истины

x или y возвращает
true или true true
true или false true
false или true true
false или false false

! (нет) Таблица истины

нет x возвращает
нет true false
нет false true

Таблицы истины — это обычные математические таблицы, используемые в логике. Их полезно помнить при построении алгоритмов (инструкций) в компьютерном программмировании.

Использование булевых операторов для управления потоком

Для управления потоком операций и выводом программы в форме выражений управления потоком вы можете использовать условие, за которым идет оператор.

Условие производит оценку до булева значения true или false и представляет собой точку принятия решения в программе. Это означает, что условие позволяет оценить истинность.

Оператор — это блок кода, который идет за условием и определяет результат выполнения программы. Он показывает, что нужно сделать, в конструкции «если x = true, нужно сделать это».

В блоке кода ниже приведен пример совместной работы операторов сравнения и условных выражений для управления потоком в программе Go:

if grade >= 65 {                 // Condition
    fmt.Println("Passing grade") // Clause
} else {
    fmt.Println("Failing grade")
}

Программа оценивает результат каждого ученика как проходной или непроходной. Для ученика с оценкой 83 первое выражение имеет значение true и активирует вывод выражения Passing grade. Для ученика с оценкой 59 первое выражение имеет значение false, и программа переходит к выражению вывода, связанному с выражением else: Failing grade.

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

Заключение

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

0 Comments

Creative Commons License