Go语言的操作符

操作符

虽然变量用于存储应用程序中的数据，但当你开始使用它们构建软件逻辑时，它们才真正发挥作用。操作符是你用来处理软件数据的工具。使用操作符，你可以将数据与其他数据进行比较——例如，你可以检查在交易应用程序中一个价格是否过低或过高。你还可以使用操作符来操作数据。例如，你可以使用操作符将购物车中所有商品的费用相加，得到总价格。

以下是操作符的几种主要类型：

• 算术操作符：用于数学相关的任务，如加法、减法和乘法。
• 比较操作符：用于比较两个值，例如它们是否相等、不相等、是否小于或大于彼此。
• 逻辑操作符：用于布尔值，以检查它们是否都为真、是否仅有一个为真，或布尔值是否为假。
• 地址操作符：我们将很快详细介绍这些操作符，当我们讨论指针时会涉及到。它们用于处理指针。
• 接收操作符：这些操作符用于处理 Go 渠道。我们将在后面的章节中讨论这些操作符。

练习 1.09 – 使用操作符处理数字

在本练习中，我们将模拟一个餐厅账单。为了完成这项模拟，我们需要使用数学和比较操作符。我们将从探讨操作符的主要用途开始。

在我们的模拟中，我们将计算总账单并根据百分比计算小费。接着，我们会使用比较操作符来判断顾客是否可以获得奖励。开始吧：

1. 创建一个新文件夹，并在其中添加一个 main.go 文件。
2. 在 main.go 文件的顶部，添加 main 包名：

   package main
   

3. 导入所需的包：

   import "fmt"
   

4. 创建 main() 函数：

   func main() {
   

5. 创建一个变量来保存总金额。假设顾客购买了两个价格为 13 美元的主菜。我们需要使用 * 进行乘法计算，然后打印出小计：

     // 主菜
     var total float64 = 2 * 13
     fmt.Println("Sub :", total)
   

6. 顾客还购买了四个价格为 2.25 美元的饮料。我们需要使用乘法计算这些饮料的总金额，然后用 + 将其加到之前的总额中，并将结果重新赋值给 total：

     // 饮料
     total = total + (4 * 2.25)
     fmt.Println("Sub :", total)
   

7. 顾客获得了 5 美元的折扣。我们需要使用 - 从总金额中减去 5 美元：

     // 折扣
     total = total - 5
     fmt.Println("Sub :", total)
   

8. 计算 10% 的小费，需要使用乘法：

     // 10% 小费
     tip := total * 0.1
     fmt.Println("Tip :", tip)
   

9. 最后，将小费加到总金额中：

     total = total + tip
     fmt.Println("Total:", total)
   

10. 账单将由两人分摊。使用 / 将总金额分成两部分：

      // 分摊账单
      split := total / 2
      fmt.Println("Split:", split)
    

11. 计算顾客是否可以获得奖励。首先，设置 visitCount 变量，然后将 1 美元加到该访问中：

      // 每第五次访问获得奖励
      visitCount := 24
      visitCount = visitCount + 1
    

12. 使用 % 计算 visitCount 除以 5 的余数：

      remainder := visitCount % 5
    

13. 顾客每第五次访问会获得奖励。如果余数为 0，则说明这是奖励访问。使用 == 操作符检查余数是否为 0：

      if remainder == 0 {
    

14. 如果是，打印出获得奖励的消息：

        fmt.Println("With this visit, you've earned a reward.")
      }
    }
    

15. 保存文件。在新文件夹中，运行以下命令：

    go run .
    

通过本练习，我们演示了如何使用操作符进行各种数学运算和比较。注意保持代码的可读性，如果在实际编程中使用一行语句处理多个变量导致代码难以理解，建议使用更多的代码行以提高可读性。

使用运算符进行字符串操作

除了处理数字，某些运算符还可以用于处理字符串。例如，除了对数字进行加法运算，+ 运算符还可以用于连接字符串。以下是一个示例：

package main
import "fmt"
func main() {
  givenName := "John"
  familyName := "Smith"
  fullName := givenName + " " + familyName
  fmt.Println("Hello,", fullName)
}

输出结果为：

Hello, John Smith

位运算符

Go 支持所有常见的位运算符。如果你了解位运算符，那么这部分不会感到陌生。如果你对位运算符不熟悉，也不用担心——它们在实际代码中并不常见。

简写运算符

当你想对一个现有值执行运算时，可以使用一些简写的赋值运算符：

• –：将数字减少 1
• ++：将数字增加 1
• +=：加法并赋值
• -=：减法并赋值

这些简写运算符可以让代码更加简洁。

练习 1.10 – 使用简写运算符

在本练习中，我们将通过一些运算符简写的示例来展示它们如何使代码更加简洁和易于编写。我们将创建一些变量，并使用简写运算符来修改它们，然后逐步打印结果。开始吧：

1. 创建一个新文件夹，并在其中添加一个 main.go 文件。
2. 在 main.go 文件的顶部，添加 main 包名：

   package main
   

3. 导入所需的包：

   import "fmt"
   

4. 创建 main() 函数：

   func main() {
   

5. 创建一个初始值的变量：

     count := 5
   

6. 使用简写运算符 += 将其增加 5，并将结果赋值给自己，然后打印结果：

     count += 5
     fmt.Println(count)
   

7. 使用 ++ 运算符将值增加 1，并打印结果：

     count++
     fmt.Println(count)
   

8. 使用 – 运算符将值减少 1，并打印结果：

     count--
     fmt.Println(count)
   

9. 使用简写运算符 -= 减去 5 并将结果赋值给自己，然后打印新的值：

     count -= 5
     fmt.Println(count)
   

10. 对字符串也可以使用简写运算符。定义一个字符串变量：

      name := "John"
    

11. 使用 += 将另一个字符串附加到当前字符串的末尾，并打印结果：

      name += " Smith"
      fmt.Println("Hello,", name)
    

12. 关闭 main() 函数：

    }
    

13. 保存文件，然后在新文件夹中运行以下命令：

    go run .
    

在本练习中，我们使用了几种简写运算符。一组简写运算符用于修改并赋值，这类操作很常见，使用这些快捷方式使编码更加高效。另一组运算符用于递增和递减，这些运算符在循环中逐步处理数据时非常有用。运算符的简写可以让代码的意图更加明确，使代码更容易理解。

接下来，我们将详细探讨如何比较值。

比较值

在应用程序中，逻辑决策是通过比较变量的值与定义的规则来实现的。这些规则以比较操作符的形式出现。比较的结果总是布尔值（true 或 false）。通常，我们需要进行多个比较操作才能做出一个决策。为此，我们使用逻辑运算符来帮助实现。

逻辑运算符大多数情况下处理两个值，并且总是返回布尔值。逻辑运算符只能用于布尔值。我们来详细看看比较运算符和逻辑运算符。

比较运算符：

• ==：当两个值相同时为真
• !=：当两个值不同时为真
• <：当左边的值小于右边的值时为真
• <=：当左边的值小于或等于右边的值时为真
• >：当左边的值大于右边的值时为真
• >=：当左边的值大于或等于右边的值时为真

逻辑运算符：

• &&：当左右两个值都为真时为真
• ||：当左右两个值中至少一个为真时为真
• !：对单个值取反，如果该值为假，则结果为真

练习 1.11 – 比较值

在本练习中，我们将使用比较运算符和逻辑运算符来测试不同条件下的布尔结果。我们要根据用户的访问次数确定他们的会员等级。

我们的会员等级如下：

• 银牌：10 次到 20 次访问（含 10 和 20 次）
• 金牌：21 次到 30 次访问（含 21 和 30 次）
• 铂金：超过 30 次访问

开始吧：

1. 创建一个新文件夹，并在其中添加一个 main.go 文件。
2. 在 main.go 文件的顶部，添加 main 包名：

   package main
   

3. 导入所需的包：

   import "fmt"
   

4. 创建 main() 函数：

   func main() {
   

5. 定义一个 visits 变量，并初始化一个值：

     visits := 15
   

6. 使用等于运算符检查这是否是他们的第一次访问，并将结果打印到控制台：

     fmt.Println("First visit   :", visits == 1)
   

7. 使用不等于运算符检查他们是否是回访用户，并打印结果：

     fmt.Println("Return visit  :", visits != 1)
   

8. 使用逻辑运算符检查他们是否是银牌会员：

     fmt.Println("Silver member :", visits >= 10 && visits < 21)
   

9. 使用逻辑运算符检查他们是否是金牌会员：

     fmt.Println("Gold member   :", visits > 20 && visits <= 30)
   

10. 使用逻辑运算符检查他们是否是铂金会员：

      fmt.Println("Platinum member :", visits > 30)
    

11. 关闭 main() 函数：

    }
    

12. 保存文件，然后在新文件夹中运行以下命令：

    go run .
    

在本练习中，我们使用了比较和逻辑运算符来对数据做出决策。你可以以无限种方式组合这些运算符来表达软件需要的几乎所有逻辑。

接下来，我们将讨论当你不给变量赋初始值时会发生什么。

零值

变量的零值是该变量类型的默认或空值。在 Go 语言中，有一套规则规定了所有核心类型的零值。

虽然还有其他类型，但它们都是从这些核心类型派生的，因此相同的规则仍然适用。

我们将在接下来的练习中查看一些类型的零值。

练习 1.12 – 零值

在这个练习中，我们将定义一些没有初始值的变量，然后打印它们的值。我们将使用 fmt.Printf 来帮助我们，因为它可以提供有关变量类型的更多细节。fmt.Printf 使用一种模板语言，允许我们转换传递的值。我们使用的替换符是 %#v。这种转换是显示变量值和类型的有用工具。

使用 fmt.Printf 时，你需要自行添加换行符。你可以通过在字符串末尾添加 \n 来实现。开始吧：

1. 创建一个新文件夹，并在其中添加一个 main.go 文件。
2. 在 main.go 文件的顶部，添加 main 包名：

   package main
   

3. 导入所需的包：

   import (
     "fmt"
     "time"
   )
   

4. 创建 main() 函数：

   func main() {
   

5. 声明并打印一个整数：

     var count int
     fmt.Printf("Count  : %#v \n", count)
   

6. 声明并打印一个 float 值：

     var discount float64
     fmt.Printf("Discount : %#v \n", discount)
   

7. 声明并打印一个 bool 值：

     var debug bool
     fmt.Printf("Debug  : %#v \n", debug)
   

8. 声明并打印一个 string 值：

     var message string
     fmt.Printf("Message : %#v \n", message)
   

9. 声明并打印一个字符串切片（collection）：

     var emails []string
     fmt.Printf("Emails : %#v \n", emails)
   

10. 声明并打印一个结构体（一个由其他类型组成的类型，我们将在本书后面讲解）：

      var startTime time.Time
      fmt.Printf("Start  : %#v \n", startTime)
    

11. 关闭 main() 函数：

    }
    

12. 保存文件。然后，在新文件夹中运行以下命令：

    go run .
    

以下是输出结果：

在这个练习中，我们定义了各种没有初始值的变量类型。然后，我们使用 fmt.Printf 打印它们的值，以揭示更多关于这些值的细节。了解零值及 Go 如何控制这些零值，能帮助你避免错误并编写简洁的代码。

接下来，我们将探讨指针是什么以及它们如何帮助你编写高效的软件。