Go 语言运算符（保姆级教程）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
• 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在编程的世界中，运算符就像是搭建程序的“积木块”，它们通过简洁的符号和规则，帮助开发者快速实现数据的计算、比较和逻辑判断。对于 Go 语言开发者而言，掌握运算符的使用方法是编写高效、清晰代码的基础。本文将系统性地解析 Go 语言中的各类运算符，从基础到进阶，结合实际案例深入浅出地讲解其应用场景和操作逻辑。无论是编程新手还是有一定经验的开发者，都能通过本文巩固或拓展对 Go 语言运算符的认知，为后续复杂编程任务打下扎实基础。

一、算术运算符：程序中的“数学工具箱”

算术运算符是 Go 语言中最基础且使用频率最高的运算符，它们直接对应数学中的加、减、乘、除等操作。通过这些运算符，开发者可以对数值型数据进行快速计算。

1.1 基础算术运算符

Go 语言支持以下基础算术运算符：
| 运算符 | 描述 | 示例 |
|--------|--------------------|---------------|
| + | 加法 | a + b |
| - | 减法 | a - b |
| * | 乘法 | a * b |
| / | 除法 | a / b |
| % | 取模（求余数） | a % b |

示例代码：

package main  

import "fmt"  

func main() {  
    a := 10  
    b := 3  
    fmt.Println("加法:", a + b)      // 输出: 13  
    fmt.Println("减法:", a - b)      // 输出: 7  
    fmt.Println("乘法:", a * b)      // 输出: 30  
    fmt.Println("除法:", a / b)      // 输出: 3（整数除法，小数部分被截断）  
    fmt.Println("取模:", a % b)      // 输出: 1（10除以3的余数）  
}  

注意：在 Go 语言中，除法 / 和取模 % 运算符对负数的处理遵循“向下取整”规则。例如：-10 / 3 的结果为 -4，而 -10 % 3 的结果为 2。

1.2 复合赋值运算符

为了简化代码，Go 语言还提供了复合赋值运算符，例如 +=、-= 等。这类运算符将运算和赋值操作合并为一步，提升代码的可读性和简洁性。

示例代码：

package main  

import "fmt"  

func main() {  
    var a int = 5  
    a += 3  // 等效于 a = a + 3  
    fmt.Println("a:", a) // 输出: 8  
    a *= 2  // 等效于 a = a * 2  
    fmt.Println("a:", a) // 输出: 16  
}  

二、比较运算符：程序中的“裁判”

比较运算符用于比较两个操作数的大小或相等性，并返回布尔值 true 或 false。它们是条件判断（如 if 语句）的核心工具。

示例代码：

package main  

import "fmt"  

func main() {  
    a := 5  
    b := 3  
    fmt.Println("a == b:", a == b)  // 输出: false  
    fmt.Println("a != b:", a != b)  // 输出: true  
    fmt.Println("a > b:", a > b)    // 输出: true  
    fmt.Println("a < b:", a < b)    // 输出: false  
    fmt.Println("a >= b:", a >= b)  // 输出: true  
}  

比喻：将比较运算符想象成“天平”——当两边的值相等时（==），天平平衡；当一边更重时（> 或 <），天平向重的一侧倾斜。

三、逻辑运算符：程序中的“决策树”

逻辑运算符用于组合或反转布尔表达式的结果，常用于复杂条件的判断。Go 语言支持以下逻辑运算符：

3.1 逻辑与（&&）

只有当两个操作数都为 true 时，结果才为 true。例如：

if (age >= 18) && (isStudent) {  
    // 允许进入学生专属区域  
}  

3.2 逻辑或（||）

只要有一个操作数为 true，结果即为 true。例如：

if (username == "admin") || (isAdmin) {  
    // 允许执行管理员操作  
}  

3.3 逻辑非（!）

反转操作数的布尔值。例如：

if !isAvailable {  
    // 当资源不可用时，触发告警  
}  

示例代码：

package main  

import "fmt"  

func main() {  
    x := 5  
    y := 3  
    fmt.Println("x > 0 && y < 5:", x > 0 && y < 5)  // 输出: true  
    fmt.Println("x == 5 || y == 4:", x == 5 || y == 4) // 输出: true  
    fmt.Println("! (x == y):", !(x == y))           // 输出: true  
}  

四、位运算符：二进制世界的“魔术师”

位运算符直接操作操作数的二进制位，适用于需要底层控制的场景（如网络协议解析、性能优化）。Go 语言支持以下位运算符：

4.1 基本位运算符

按位与（&）

两个二进制位同时为 1 时，结果为 1，否则为 0。例如：

二进制：  1010 (十进制10)  
          & 1100 (十进制12)  
          = 1000 (十进制8)  

按位或（|）

只要有一个二进制位为 1，结果即为 1。例如：

二进制：  1010 (十进制10)  
          | 1100 (十进制12)  
          = 1110 (十进制14)  

按位异或（^）

两个二进制位不同时，结果为 1。例如：

二进制：  1010 (十进制10)  
          ^ 1100 (十进制12)  
          = 0110 (十进制6)  

移位运算符

• 左移（<<）：将二进制位向左移动指定位数，高位丢弃，低位补 0。例如：8 << 1 等效于 16。
• 右移（>>）：将二进制位向右移动指定位数，低位丢弃，高位补符号位（有符号数）或 0（无符号数）。例如：8 >> 1 等效于 4。

示例代码：

package main  

import "fmt"  

func main() {  
    a := 10 // 二进制：1010  
    b := 12 // 二进制：1100  
    fmt.Printf("a & b = %d (二进制: %b)\n", a&b, a&b) // 输出: 8 (1000)  
    fmt.Printf("a | b = %d (二进制: %b)\n", a|b, a|b) // 输出: 14 (1110)  
    fmt.Printf("a ^ b = %d (二进制: %b)\n", a^b, a^b) // 输出: 6 (0110)  
    fmt.Printf("a << 1 = %d (二进制: %b)\n", a<<1, a<<1) // 输出: 20 (10100)  
}  

五、其他运算符：进阶技巧与特殊场景

5.1 指针运算符

Go 语言通过 &（取地址）和 *（解引用）操作符直接操作指针：

var num int = 10  
ptr := &num // 取 num 的地址，ptr 是指针  
fmt.Println(*ptr) // 输出: 10（解引用指针获取值）  

5.2 类型转换运算符

通过 T(x) 的形式将表达式 x 转换为类型 T：

var a int8 = 100  
b := int32(a) // 显式转换为 int32 类型  

5.3 三元运算符

三元运算符 condition ? expr1 : expr2 根据条件返回不同的值：

max := a > b ? a : b // 等效于：if a > b { max = a } else { max = b }  

六、运算符优先级与结合性：程序的“执行顺序指南”

运算符优先级决定了表达式中操作的执行顺序。若优先级相同，则按结合性（左结合或右结合）决定顺序。

优先级从高到低示例：

1. !、-（一元运算符）
2. *、/、%
3. +、-
4. <<、>>
5. &、^、|
6. ==、!=、<、> 等比较运算符
7. &&、||
8. 三元运算符 ?:

示例代码：

package main  

import "fmt"  

func main() {  
    result := 10 + 5*2 // 先计算乘法，结果为 20  
    fmt.Println(result) // 输出: 20  
    result2 := (10 + 5) * 2 // 强制先计算加法，结果为 30  
    fmt.Println(result2) // 输出: 30  
}  

Go 语言运算符是构建程序逻辑的基石，它们通过简洁的符号和规则，帮助开发者高效地完成数据操作、条件判断和底层控制。从基础的算术运算到进阶的位操作，每类运算符都有其独特的作用场景和使用技巧。掌握这些运算符不仅能提升代码的可读性，还能在性能优化、算法实现等场景中发挥重要作用。建议读者通过实际编写代码练习运算符的组合使用，并结合项目需求灵活应用，逐步成为 Go 语言运算符的“行家”。

通过本文的系统性讲解，读者应能全面理解 Go 语言运算符的核心概念和实践方法。运算符的学习并非一蹴而就，但通过持续练习和项目实践，开发者终将熟练运用这些工具，编写出高效、优雅的 Go 语言程序。