运算符决定计算规则，表达式决定求值逻辑。
在 Go 语言中，操作符体系设计简洁、强类型、无隐式转换，是语言安全性与可读性的核心保障。
一、什么是表达式？
在 Go 中：
表达式（Expression）是可以计算并产生值的语法结构。
例如：
a + b
x > 10
a && b
1 << 3
表达式可以用于：
变量赋值
条件判断
函数参数
返回值计算
package main
import "fmt"
// add 是一个函数表达式示例
func add(a, b int) int {
return a + b
}
func main() {
a := 8
b := 3
c := 2
fmt.Println("=== 算术表达式 ===")
fmt.Println("a + b =", a+b)
fmt.Println("a - b =", a-b)
fmt.Println("a * b =", a*b)
fmt.Println("a / b =", a/b)
fmt.Println("a % b =", a%b)
fmt.Println("\n=== 关系表达式 ===")
fmt.Println("a > b =", a > b)
fmt.Println("a == b =", a == b)
fmt.Println("a != b =", a != b)
fmt.Println("\n=== 逻辑表达式 ===")
fmt.Println("(a > b) && (b > c) =", (a > b) && (b > c))
fmt.Println("(a > b) || (b > c) =", (a > b) || (b > c))
fmt.Println("!(a > b) =", !(a > b))
fmt.Println("\n=== 位表达式 ===")
fmt.Println("a & b =", a&b)
fmt.Println("a | b =", a|b)
fmt.Println("a ^ b =", a^b)
fmt.Println("a << 1 =", a<<1)
fmt.Println("a >> 1 =", a>>1)
fmt.Println("\n=== 复合表达式 ===")
result := (a + b) * c
fmt.Println("(a + b) * c =", result)
fmt.Println("\n=== 函数调用表达式 ===")
fmt.Println("add(a, b) =", add(a, b))
}
二、Go 操作符分类总览
Go 的操作符主要分为六类：
算术操作符
关系操作符
逻辑操作符
位操作符
赋值操作符
其他特殊操作符三、算术操作符
适用于数值类型。
示例：
package main
import "fmt"
func main() {
a := 8
b := 3
fmt.Println("=== 整数算术运算 ===")
fmt.Println("a + b =", a+b) // 加法
fmt.Println("a - b =", a-b) // 减法
fmt.Println("a * b =", a*b) // 乘法
fmt.Println("a / b =", a/b) // 整数除法
fmt.Println("a % b =", a%b) // 取余
fmt.Println("\n=== 浮点算术运算 ===")
x := 8.0
y := 3.0
fmt.Println("x / y =", x/y) // 浮点除法
}⚠ 注意：
整数除法不会产生小数
%仅适用于整数类型
四、关系操作符
比较两个值，返回布尔值。
示例：
package main
import "fmt"
func main() {
a := 8
b := 3
c := 8
fmt.Println("=== 关系运算符示例 ===")
fmt.Println("a > b =", a > b) // 大于
fmt.Println("a < b =", a < b) // 小于
fmt.Println("a >= b =", a >= b) // 大于等于
fmt.Println("a <= b =", a <= b) // 小于等于
fmt.Println("a == b =", a == b) // 等于
fmt.Println("a != b =", a != b) // 不等于
fmt.Println("\n=== 相同值比较 ===")
fmt.Println("a == c =", a == c)
fmt.Println("a != c =", a != c)
}
五、逻辑操作符
用于布尔表达式。
示例：
package main
import "fmt"
func main() {
a := 8
b := 3
fmt.Println("=== 逻辑运算符示例 ===")
// 逻辑与 &&
fmt.Println("a > b && b > 0 =", a > b && b > 0)
// 逻辑或 ||
fmt.Println("a < b || b > 0 =", a < b || b > 0)
// 逻辑非 !
fmt.Println("!(a > b) =", !(a > b))
fmt.Println("\n=== 短路机制演示 ===")
// && 短路示例
fmt.Println(false && test()) // test() 不会执行
// || 短路示例
fmt.Println(true || test()) // test() 不会执行
}
// test 用于观察是否执行
func test() bool {
fmt.Println("test() 被调用")
return true
}
短路特性（重要）
&&：左侧为 false，右侧不再执行||：左侧为 true，右侧不再执行
六、位操作符
适用于整数类型。
示例：
package main
import "fmt"
func main() {
a := 8 // 二进制：00001000
b := 3 // 二进制：00000011
fmt.Println("=== 位运算示例 ===")
fmt.Printf("a = %08b (%d)\n", a, a)
fmt.Printf("b = %08b (%d)\n", b, b)
// 按位与 &
fmt.Printf("a & b = %08b (%d)\n", a&b, a&b)
// 按位或 |
fmt.Printf("a | b = %08b (%d)\n", a|b, a|b)
// 按位异或 ^
fmt.Printf("a ^ b = %08b (%d)\n", a^b, a^b)
// 左移 <<
fmt.Printf("a << 1 = %08b (%d)\n", a<<1, a<<1)
// 右移 >>
fmt.Printf("a >> 1 = %08b (%d)\n", a>>1, a>>1)
// 按位取反（单目 ^）
fmt.Printf("^a = %08b (%d)\n", ^a, ^a)
}右移规则
正数右移 → 高位补 0
负数右移 → 高位补 1（算术右移）
Go 不支持无符号右移 >>>。
七、赋值操作符
基本赋值
package main
import "fmt"
func main() {
fmt.Println("=== 赋值运算符示例 ===")
var a, b int = 8, 3
// += 等价于 a = a + b
a = 8
a += b
fmt.Println("a += b →", a)
// -= 等价于 a = a - b
a = 8
a -= b
fmt.Println("a -= b →", a)
// *= 等价于 a = a * b
a = 8
a *= b
fmt.Println("a *= b →", a)
// /= 等价于 a = a / b
a = 8
a /= b
fmt.Println("a /= b →", a)
// %= 等价于 a = a % b
a = 8
a %= b
fmt.Println("a %= b →", a)
// <<= 等价于 a = a << b
a = 8
a <<= b
fmt.Println("a <<= b →", a)
// >>= 等价于 a = a >> b
a = 8
a >>= b
fmt.Println("a >>= b →", a)
// &= 等价于 a = a & b
a = 8
a &= b
fmt.Println("a &= b →", a)
// |= 等价于 a = a | b
a = 8
a |= b
fmt.Println("a |= b →", a)
// ^= 等价于 a = a ^ b
a = 8
a ^= b
fmt.Println("a ^= b →", a)
}复合赋值
八、其他特殊操作符
示例：
package main
import (
"fmt"
)
func main() {
fmt.Println("=== & 取地址 与 * 解引用 ===")
x := 10 // := 短变量声明
p := &x // & 取地址
fmt.Println("x 的值:", x)
fmt.Println("x 的地址:", p)
fmt.Println("通过指针访问:", *p) // * 解引用
// 修改指针指向的值
*p = 20
fmt.Println("修改后的 x:", x)
fmt.Println("\n=== <- channel 收发 ===")
ch := make(chan int)
// 启动 goroutine 发送数据
go func() {
ch <- 100 // 向 channel 发送数据
}()
value := <-ch // 从 channel 接收数据
fmt.Println("接收到的值:", value)
}
九、操作符优先级
运算符具有优先级。
例如：
a + b * c等价于：
a + (b * c)
常见优先级（高 → 低）：
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
建议：
使用括号提升可读性，而非依赖优先级记忆。
package main
import "fmt"
func main() {
fmt.Println("=== 算术优先级 ===")
a := 2 + 3*4
fmt.Println("2 + 3*4 =", a) // 先算 3*4
b := (2 + 3) * 4
fmt.Println("(2 + 3) * 4 =", b)
fmt.Println("\n=== 位移优先级 ===")
c := 1 + 2<<2
fmt.Println("1 + 2<<2 =", c) // 先算 2<<2，再加 1
d := (1 + 2) << 2
fmt.Println("(1 + 2) << 2 =", d)
fmt.Println("\n=== 比较优先级 ===")
e := 5 > 3 && 2 < 4
fmt.Println("5 > 3 && 2 < 4 =", e)
fmt.Println("\n=== 位运算优先级 ===")
f := 6 & 3 | 1
fmt.Println("6 & 3 | 1 =", f) // 先算 & 再算 |
g := 6 & (3 | 1)
fmt.Println("6 & (3 | 1) =", g)
fmt.Println("\n=== 逻辑优先级 ===")
h := true || false && false
fmt.Println("true || false && false =", h) // 先算 &&
i := (true || false) && false
fmt.Println("(true || false) && false =", i)
}
十、类型系统与表达式
Go 是强类型语言。
错误示例：
var a int = 10
var b int64 = 20
a + b // ❌ 类型不匹配
必须显式转换：
int64(a) + bpackage main
import "fmt"
func main() {
var a int = 10
var b int64 = 20
// ❌ 错误写法（取消注释会报错）
// fmt.Println(a + b)
// ✅ 正确写法：显式类型转换
result := int64(a) + b
fmt.Println("int64(a) + b =", result)
// 反向转换
result2 := a + int(b)
fmt.Println("a + int(b) =", result2)
fmt.Println("\n=== 表达式类型示例 ===")
x := 5
y := 2
fmt.Println("x / y =", x/y) // int
fmt.Println("float64(x)/float64(y) =", float64(x)/float64(y))
}
十一、Go 表达式设计特点
Go 表达式体系具有：
无隐式类型转换
无运算符重载
强类型约束
语义清晰
可读性优先
相比 C++ 更简洁，
相比 Java 更严格。
总结
Go 的操作符体系简洁、严谨、强类型。
表达式求值规则清晰，无隐式转换，提升了代码安全性与可维护性。
掌握操作符与表达式，是理解 Go 语法、并发模型与内存模型的基础。