Go 语言运算符（详细教程）

Go 语言运算符：从基础到实战的完整指南

在学习 Go 语言的过程中，你很快就会发现，运算符是构建逻辑与表达式的核心工具。无论是简单的加减乘除，还是复杂的位操作和逻辑判断，都离不开运算符的支持。掌握 Go 语言运算符，就像是掌握了编程的“语法钥匙”——它能帮你打开数据处理的大门。

作为一门现代系统编程语言，Go 的运算符设计简洁、明确，避免了冗余和歧义。对于初学者来说，理解每种运算符的行为和优先级，是写出正确、高效代码的第一步。而对于中级开发者，深入掌握运算符的细节，有助于写出更优雅、更安全的代码。

本文将带你系统性地学习 Go 语言运算符，从基础算术运算，到复合赋值、比较、逻辑、位运算，再到特殊的短路求值和运算符优先级，层层递进，结合真实案例，助你彻底掌握这一核心概念。

算术运算符：最基础的数学表达

算术运算符是 Go 语言中最基础、最常用的运算符，它们用于执行加、减、乘、除、取余等数学操作。这些运算符与我们在数学课上学到的符号基本一致，但 Go 语言对类型的要求更严格。

package main

import "fmt"

func main() {
    a := 10
    b := 3

    // 加法：两个整数相加
    add := a + b // 结果是 13
    fmt.Println("加法结果：", add)

    // 减法：从 a 中减去 b
    subtract := a - b // 结果是 7
    fmt.Println("减法结果：", subtract)

    // 乘法：a 乘以 b
    multiply := a * b // 结果是 30
    fmt.Println("乘法结果：", multiply)

    // 除法：a 除以 b，结果是浮点数
    divide := a / b // 结果是 3（整数除法，小数部分被截断）
    fmt.Println("整数除法结果：", divide)

    // 取余：求 a 除以 b 的余数
    remainder := a % b // 结果是 1
    fmt.Println("取余结果：", remainder)
}

注意：Go 语言中，/ 运算符在两个整数之间执行的是整数除法，结果会自动向下取整。如果需要浮点数除法，必须将操作数转换为 float64 类型。

为什么整数除法会截断小数？

这就像用整数尺子量东西：你不能说“量了 3.33 个单位”，只能说是“3 个单位”。Go 语言的设计哲学是明确性优先，它不允许隐式类型转换导致意外结果，因此强制要求开发者显式处理类型转换。

赋值与复合赋值运算符：简化代码的利器

在编程中，我们经常需要对变量进行“更新”操作，比如 x = x + 1。这种重复模式非常常见，于是 Go 语言提供了复合赋值运算符，让代码更简洁、更易读。

package main

import "fmt"

func main() {
    num := 5

    // 复合赋值：先加 3，再赋值给 num
    num += 3 // 等价于 num = num + 3
    fmt.Println("加法赋值后：", num) // 输出：8

    num -= 2 // 等价于 num = num - 2
    fmt.Println("减法赋值后：", num) // 输出：6

    num *= 4 // 等价于 num = num * 4
    fmt.Println("乘法赋值后：", num) // 输出：24

    num /= 3 // 等价于 num = num / 3
    fmt.Println("除法赋值后：", num) // 输出：8

    num %= 5 // 等价于 num = num % 5
    fmt.Println("取余赋值后：", num) // 输出：3
}

复合赋值的实用场景

在循环中，复合赋值特别有用。比如在统计累计值时：

total := 0
for i := 1; i <= 10; i++ {
    total += i // 每次累加 i，相当于 total = total + i
}
fmt.Println("1 到 10 的和是：", total) // 输出：55

这种写法不仅更短，而且语义清晰，让代码意图一目了然。

比较运算符：判断“相等”与“大小”

比较运算符用于比较两个值之间的关系，结果是一个布尔值（true 或 false）。它们是条件语句（如 if、for）的基础。

package main

import "fmt"

func main() {
    x := 10
    y := 20

    fmt.Println("x == y:", x == y) // false，10 不等于 20
    fmt.Println("x != y:", x != y) // true，10 不等于 20
    fmt.Println("x < y:", x < y)   // true，10 小于 20
    fmt.Println("x > y:", x > y)   // false，10 不大于 20
    fmt.Println("x <= y:", x <= y) // true，10 小于等于 20
    fmt.Println("x >= y:", x >= y) // false，10 不大于等于 20
}

字符串比较：按字典序

Go 语言支持对字符串进行比较，比较规则是字典序（lexicographical order），即按字符的 Unicode 码点逐个比较。

fmt.Println("apple < banana:", "apple" < "banana") // true
fmt.Println("zebra > apple:", "zebra" > "apple")   // true

这就像查字典：apple 在 banana 前面，所以 apple < banana 为 true。

逻辑运算符：构建复杂判断条件

逻辑运算符用于组合多个布尔表达式，形成更复杂的判断条件。Go 语言支持 &&（逻辑与）、||（逻辑或）和 !（逻辑非）。

package main

import "fmt"

func main() {
    age := 18
    hasLicense := true

    // 逻辑与：两个条件都为真时，结果为真
    canDrive := age >= 18 && hasLicense
    fmt.Println("可以开车吗？", canDrive) // true

    // 逻辑或：只要有一个为真，结果就为真
    hasAccess := age >= 18 || hasLicense
    fmt.Println("有访问权限吗？", hasAccess) // true

    // 逻辑非：取反
    notEligible := !hasLicense
    fmt.Println("是否不符合条件？", notEligible) // false
}

短路求值：性能与安全的双重保障

Go 语言的逻辑运算符支持短路求值（short-circuit evaluation），即在确定最终结果后，不再计算后续表达式。

func check() bool {
    fmt.Println("函数被调用")
    return true
}

func main() {
    // 由于第一个条件为 false，第二个条件不会执行
    if false && check() {
        fmt.Println("这行不会执行")
    }

    // 由于第一个条件为 true，第二个条件不会执行
    if true || check() {
        fmt.Println("这行会执行")
    }
}

输出：

函数被调用
这行会执行

这个特性在避免空指针错误时特别有用，比如 if obj != nil && obj.IsValid()，只有在 obj 不为空时才会调用 IsValid()。

位运算符：底层操作的利器

位运算符作用于整数的二进制表示，是系统编程中常用的工具。虽然日常开发中使用较少，但在性能敏感场景（如加密、压缩、网络协议）中非常关键。

package main

import "fmt"

func main() {
    a := 6   // 二进制：110
    b := 3   // 二进制：011

    fmt.Println("a & b (按位与)：", a&b)   // 2（二进制：010）
    fmt.Println("a | b (按位或)：", a|b)   // 7（二进制：111）
    fmt.Println("a ^ b (按位异或)：", a^b) // 5（二进制：101）
    fmt.Println("a << 1 (左移 1 位)：", a<<1) // 12（二进制：1100）
    fmt.Println("a >> 1 (右移 1 位)：", a>>1) // 3（二进制：011）
}

左移与右移的数学意义

• 左移 n 位：相当于乘以 2^n
• 右移 n 位：相当于除以 2^n（整数除法）

比如 a << 1 就是 6 * 2 = 12，a >> 1 就是 6 / 2 = 3。

运算符优先级：避免“计算顺序”陷阱

Go 语言运算符有明确的优先级规则，高优先级的运算符先执行。如果不了解优先级，容易写出逻辑错误的代码。

建议：复杂表达式中，使用括号明确优先级，提高可读性。

// 不推荐：依赖优先级
result := 10 + 5 * 2 // 结果是 20

// 推荐：使用括号，明确意图
result := (10 + 5) * 2 // 结果是 30

总结：掌握 Go 语言运算符，迈向更高阶编程

Go 语言运算符虽然种类不多，但功能强大、设计严谨。从基础的算术运算，到复合赋值、逻辑判断、位操作，每一种都服务于特定的编程场景。理解它们的语义、优先级和使用场景，是你写出可靠、高效 Go 代码的重要基石。

对于初学者，建议从算术和比较运算符入手，逐步掌握复合赋值和逻辑运算。对于中级开发者，深入理解位运算和短路求值，能让你在处理性能瓶颈或复杂条件判断时游刃有余。

记住：编程的本质是表达逻辑，而运算符就是你表达逻辑的“语言工具”。掌握 Go 语言运算符，就是掌握表达复杂逻辑的能力。