Основы работы с логическими данными в Go

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

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

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

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

Операторы сравнения

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

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

Оператор Действие
== Равно
!= Не равно
< Меньше, чем
> Больше, чем
<= Меньше или равно
>= Больше или равно

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

x := 5
y := 8

В этом примере x имеет значение 5, потому он меньше y, который имеет значение 8.

Используя эти две переменные и связанные с ними значения, мы можем посмотреть, как работают операторы из предыдущей таблицы. Эта программа Go выведет на экран, как каждый оператор оценивает соотношение этих двух переменных. Чтобы лучше понять вывод, вы можете попросить 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)
}
x == y: false
x != y: true
x < y: true
x > y: false
x <= y: true
x >= y: false

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

5 (х) равно 8 (у)? 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)
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)
Sammy == sammy:  false
Sammy == alsoSammy true

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

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

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

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

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

x = y   // приравнивает x к y
x == y  // оценивает, равны ли x и y

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

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

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

  • && (x && y) является оператором and. Он истинный, если оба утверждения true .
  • || (x || y) является оператором or. Он истинный, если хотя бы одно утверждение true.
  • ! (! x) является оператором not. Он истинный, только если утверждение false.

Логические операторы обычно используются для оценки того, являются ли два или более выражения истинными или нет. Например, они могут оценить баллы студента и то, зарегистрирован ли он на курс – если оба условия истинны, то студенту будет выставлена оценка в системе. Или же, например, они могут определить, является ли пользователь действительным и активным клиентом интернет-магазина, на основании того, есть ли у него кредит магазина и совершал ли он покупку за последние 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
true
true
true

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

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

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

Давайте заменим целые числа числами с плавающей точкой и попробуем получить результат false:

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

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

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

Если эти результаты кажутся вам непонятными, просмотрите таблицы истинности (в следующем разделе).

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

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

Сначала взглянем на внутреннее выражение: (0,8 <3,1) || (0,1 == 0,1). Это выражение оценивается как истинное, потому что оба математических утверждения верны.

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

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

true

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

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

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

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

Оператор ==
x == y Вывод
true == true true
true == false false
false == true false
false == false true

 

Оператор &&
x and y Вывод
true and true true
true and false false
false and true false
false and false false

 

Оператор ||
x or y Вывод
true or true true
true or false true
false or true true
false or false false

 

Оператор !
not x Вывод
not true false
not false true

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

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

Чтобы управлять потоками и результатами программы с помощью операторов, вы можете использовать условие, за которым следует выражение.

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

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

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

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

Эта программа будет оценивать успехи каждого ученика. В случае ученика с 83 баллами первое утверждение будет оценено как истинное, а на экране появится сообщение Passing grade. В случае ученика с 59 баллами первое утверждение будет оценено как ложное, поэтому программа перейдет к выполнению выражения print, связанного с выражением else: Failing grade.

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

Заключение

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

Tags: ,