cs-note/hzh/GolangStar/Go语言基础/Go语言运算符.md

---
tags: [go, golang, go基础语法, 运算符]
create time: 2026-06-07 15:00
---

# Go 语言运算符

## 概述

Go 的运算符体系简洁而一致：算术、关系、逻辑、位运算、赋值和取地址。本文聚焦**与 C/Java 不同的设计决策**，以及实际开发中的常见用法。

## 正文

### Go 运算符有哪些"不一样"？

先思考：**"Go 有没有 `++` 和 `--` 作为表达式？"**

答案是：**没有。** `a++` 是语句而非表达式，不能出现在赋值或函数参数中：

```go
a := 5
a++          // ✅ 语句
b := a++     // ❌ 编译错误：syntax error: unexpected ++
```

这是 Go 刻意的设计——避免 `i++ + i++` 这类歧义代码。

### 算术运算符

| 运算符 | 说明 | 示例 |
|--------|------|------|
| `+ - *` | 加减乘 | `3 + 5 → 8` |
| `/` | 整除（整数类型） | `7 / 2 → 3` |
| `%` | 取余 | `7 % 2 → 1` |
| `++ --` | 自增/自减（**仅语句**） | `a++` |

> [!warning] ⚠️ 整数除法截断
> `7 / 2` 结果是 `3` 而非 `3.5`。需要浮点除法时，至少一个操作数必须是浮点类型：`float64(7) / 2 → 3.5`。

### 关系运算符

返回 `bool` 类型：

| 运算符 | 说明 |
|--------|------|
| `== !=` | 相等 / 不等 |
| `< <= > >=` | 大小比较 |

> [!tip] 💡 Go 没有三元运算符
> `a > b ? a : b` 在 Go 中不合法。改用 if：
> ```go
> max := a
> if b > max {
>     max = b
> }
> ```

### 逻辑运算符

短路求值——右侧只在必要时求值：

| 运算符 | 说明 |
|--------|------|
| `&&` | 逻辑与（左为 false 时不eval右） |
| `\|\|` | 逻辑或（左为 true 时不eval右） |
| `!` | 逻辑非 |

```go
if ptr != nil && ptr.IsValid() {
    // 只有 ptr 不为 nil 时才调用 IsValid()
}
```

### 位运算符

对整数类型的二进制位进行操作：

| 运算符 | 说明 | 示例 (60 & 13) |
|--------|------|---------------|
| `&` | 按位与 | `12` |
| `\|` | 按位或 | `61` |
| `^` | 按位异或 | `49` |
| `<< >>` | 左移 / 右移 | `60 << 2 = 240` |

> [!note] 📝 异或的性质
> `x ^ x = 0`，这个性质可用于无额外变量的交换、简单的校验码计算等场景。

> [!info] ℹ️ `&^` 按位清空
> Go 独有运算符 `a &^ b`：将 `b` 中为 1 的位，把 `a` 对应位清零。常用于标志位操作。

### 赋值运算符

复合赋值运算符与多数语言一致：

```go
a += 5   // 等价于 a = a + 5
a <<= 2  // 等价于 a = a << 2
```

### 取地址 & 指针运算符

| 运算符 | 说明 |
|--------|------|
| `&` | 取变量地址 |
| `*` | 解引用指针 |

```go
x := 42
ptr := &x      // ptr 类型为 *int，指向 x
fmt.Println(*ptr)  // 输出 42，读取指针所指向的值
*ptr = 100     // 通过指针修改 x 的值
fmt.Println(x)     // 输出 100
```

> [!question] ❓ 思考
> `&` 既可以取地址又可以用于位与运算，Go 如何区分这两种用途？（提示：看上下文和空格）

### 运算符优先级

从大到小排列（同级从左到右）：

```
* / % << >> &    （最高）
&^
+ - ^
== != < <= > >=
&&
||              （最低）
```

不确定时，用括号明确优先级——**可读性优先**。

> [!tip] 💡 实用技巧
> 不要依赖优先级记忆。`(a + b) * c` 比 `a + b * c` 更清晰，哪怕后者在语义上等价于你期望的结果。