理解Go中的布尔逻辑

布尔数据类型 (bool) 可以是 true 或 false 这两个值之一。 布尔值在编程中用于进行比较和控制程序的流程。

布尔值表示与数学逻辑分支相关的真值，它为计算机科学中的算法提供信息。 Boolean 这个词以数学家 George Boole 命名，总是以大写的 B 开头。

Go for Boolean 中的数据类型是 bool，全小写。 值 true 和 false 将始终分别使用小写的 t 和 f，因为它们是 Go 中的特殊值。

本教程将涵盖了解 bool 数据类型如何工作所需的基础知识，包括布尔比较、逻辑运算符和真值表。

比较运算符

在编程中， 比较运算符 用于比较值并评估为单个布尔值，即真或假。

下表显示了布尔比较运算符。

操作员	这是什么意思
==	等于
!=	不等于
<	少于
>	比...更棒
<=	小于或等于
>=	大于或等于

为了理解这些运算符的工作原理，让我们将两个整数分配给 Go 程序中的两个变量：

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)
}

Outputx == y: false
x != y: true
x < y: true
x > y: false
x <= y: true
x >= y: false

按照数学逻辑，Go 从表达式中评估了以下内容：

• 5 (x) 是否等于 8 (y)？ 假
• 5不等于8吗？ 真
• 5 小于 8 吗？ 真
• 5大于8吗？ 假
• 5 是否小于或等于 8？ 真
• 5不小于等于8吗？ 假

尽管此处使用了整数，但您可以将它们替换为浮点值。

字符串也可以与布尔运算符一起使用。 除非您使用其他字符串方法，否则它们区分大小写。

您可以查看在实践中如何比较字符串：

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

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

OutputSammy == 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)

OutputSammy == sammy:  false
Sammy == alsoSammy true

您还可以使用其他比较运算符，包括 > 和 < 来比较两个字符串。 Go 将使用字符的 ASCII 值按字典顺序比较这些字符串。

您还可以使用比较运算符评估布尔值：

t := true
f := false

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

Outputt != f:  true

前面的代码块评估 true 不等于 false。

请注意两个运算符 = 和 == 之间的区别。

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

第一个 = 是赋值运算符，它将一个值设置为另一个值。 第二个，==，是一个比较运算符，将评估两个值是否相等。

逻辑运算符

有两个逻辑运算符用于比较值。 它们将表达式计算为布尔值，返回 true 或 false。 这些运算符是 &&、|| 和 !，并在下面的列表中定义：

• && (x && y ） 是个and操作员。 如果两个陈述都为真，则为真。
• || (x || y) 是 or 运算符。 如果至少有一个陈述是正确的，那么它就是正确的。
• ! (!x) 是 not 运算符。 只有当陈述为假时，它才是真的。

逻辑运算符通常用于评估两个或多个表达式是否为真。 例如，它们可用于确定成绩是否通过以及学生是否已在课程中注册，如果这两种情况都为真，则系统将为学生分配一个成绩。 另一个示例是根据用户在过去 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

Outputtrue
true
true

在第一种情况下，fmt.Println((9 > 7) && (2 < 4))，由于使用了 and 运算符，因此 9 > 7 和 2 < 4 都需要计算为真。

在第二种情况下，fmt.Println((8 == 8) || (6 != 6))，由于 8 == 8 评估为 true，因此 6 != 6 评估为 false 并没有什么不同，因为使用了 or 运算符. 如果您使用了 and 运算符，这将评估为 false。

在第三种情况下，fmt.Println(!(3 <= 1))，not 运算符否定 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

在这个例子中：

• and 必须至少有一个假表达式评估为假。
• or 必须让两个表达式都计算为假。
• ! 的内部表达式必须为真，新表达式才能计算为假。

如果这些结果对您来说似乎不清楚，请查看一些 真值表 以进一步澄清。

您还可以使用 &&、|| 和 ! 编写复合语句：

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

先看最里面的表达式：(0.8 < 3.1) || (0.1 == 0.1)。 该表达式的计算结果为 true，因为两个数学语句都是 true。

接下来，Go 获取返回值 true 并将其与下一个内部表达式组合：(-0.2 > 1.4) && (true)。 此示例返回 false，因为数学语句 -0.2 > 1.4 为假，并且 (false) 和 (true) 返回 false。

最后，我们有外部表达式：!(false)，其计算结果为 true，因此如果我们打印此语句，最终返回值为：

Outputtrue

逻辑运算符 &&、|| 和 ! 计算表达式并返回布尔值。

真值表

数学的逻辑分支有很多需要学习的地方，但是你可以有选择地学习其中的一些来提高你在编程时的算法思维。

以下是比较运算符 == 和逻辑运算符 &&、|| 和 ! 的真值表。 虽然您可以推理出它们，但记住它们也很有帮助，因为这可以使您的编程决策过程更快。

==（相等）真值表

x	==	y	退货
真的	==	真的	真的
真的	==	错误的	错误的
错误的	==	真的	错误的
错误的	==	错误的	真的

&&（和）真值表

x	和	y	退货
真的	和	真的	真的
真的	和	错误的	错误的
错误的	和	真的	错误的
错误的	和	错误的	错误的

||（或）真值表

x	或者	y	退货
真的	或者	真的	真的
真的	或者	错误的	真的
错误的	或者	真的	真的
错误的	或者	错误的	错误的

!（非）真值表

| 不是| x | 退货 | | — | — | — | — | | 不是| 真实 | 假 | | 不是| 假 | 真实 |

真值表是逻辑中常用的数学表，在构建计算机编程中的算法（指令）时要牢记在心。

使用布尔运算符进行流控制

要以流控制语句的形式控制程序的流和结果，可以使用 条件 后跟 子句。

condition 计算结果为布尔值 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。

布尔运算符提供的条件可用于通过流控制语句来决定程序的最终结果。

结论

本教程介绍了属于布尔类型的比较和逻辑运算符，以及真值表并使用布尔值进行程序流控制。