赋值运算符 #

一、运算符概述 #

Go语言支持以下赋值运算符：

运算符	说明	示例
=	赋值	a = b
+=	加后赋值	a += b
-=	减后赋值	a -= b
*=	乘后赋值	a *= b
/=	除后赋值	a /= b
%=	取余后赋值	a %= b
&=	按位与后赋值	a &= b
\|=	按位或后赋值	a \|= b
^=	按位异或后赋值	a ^= b
<<=	左移后赋值	a <<= n
>>=	右移后赋值	a >>= n

二、基本赋值 #

2.1 单变量赋值 #

var a int
a = 10

b := 20  // 短声明赋值

2.2 多变量赋值 #

var a, b int
a, b = 1, 2

x, y := 10, 20

2.3 交换变量 #

a, b := 1, 2
a, b = b, a
fmt.Println(a, b)  // 2 1

2.4 函数返回多值 #

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

quotient, remainder := divmod(10, 3)
fmt.Println(quotient, remainder)  // 3 1

三、复合赋值运算符 #

3.1 算术复合赋值 #

a := 10

a += 5   // a = a + 5   → 15
a -= 3   // a = a - 3   → 12
a *= 2   // a = a * 2   → 24
a /= 4   // a = a / 4   → 6
a %= 4   // a = a % 4   → 2

3.2 位运算复合赋值 #

a := 12  // 1100

a &= 10  // a = a & 10   → 8 (1000)
a |= 3   // a = a | 3    → 11 (1011)
a ^= 6   // a = a ^ 6    → 13 (1101)
a <<= 2  // a = a << 2   → 52 (110100)
a >>= 1  // a = a >> 1   → 26 (11010)

3.3 清除位复合赋值 #

a := 15  // 1111
a &^= 6  // 清除 110 位 → 9 (1001)

四、赋值表达式 #

4.1 赋值是语句 #

Go中赋值是语句，不是表达式：

a := 10

// 错误：赋值不能作为表达式
if a = 20; a > 0 {  // 这是合法的，但不是赋值表达式
    fmt.Println(a)
}

// 错误
b := a = 30  // 编译错误

4.2 自增自减 #

Go的自增自减是语句：

a := 10

a++  // 正确
a--  // 正确

// 错误
b := a++  // 编译错误

五、实际应用 #

5.1 累加器 #

sum := 0
for i := 1; i <= 10; i++ {
    sum += i
}
fmt.Println(sum)  // 55

5.2 字符串拼接 #

result := ""
for i := 0; i < 5; i++ {
    result += fmt.Sprintf("%d ", i)
}
fmt.Println(result)  // 0 1 2 3 4

// 更高效的方式
var builder strings.Builder
for i := 0; i < 5; i++ {
    builder.WriteString(fmt.Sprintf("%d ", i))
}
fmt.Println(builder.String())

5.3 权限管理 #

const (
    Read    = 1 << iota  // 1
    Write                // 2
    Execute              // 4
)

perm := 0
perm |= Read    // 添加读权限
perm |= Write   // 添加写权限
perm &^= Write  // 移除写权限

5.4 计数器 #

count := 0
count += 1
count += 1
fmt.Println(count)  // 2

六、多变量赋值应用 #

6.1 交换值 #

a, b := 1, 2
a, b = b, a

6.2 函数返回值 #

func getUser() (string, int) {
    return "Tom", 25
}

name, age := getUser()

6.3 忽略返回值 #

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

quotient, _ := divmod(10, 3)  // 忽略余数

6.4 错误处理 #

data, err := readFile("test.txt")
if err != nil {
    return err
}

七、常见错误 #

7.1 类型不匹配 #

var a int = 10
var b int32 = 20
a = b  // 错误：类型不匹配

a = int(b)  // 正确

7.2 未声明变量 #

a = 10  // 错误：a未声明

var a int
a = 10  // 正确

7.3 短声明重复 #

a := 10
a := 20  // 错误：a已声明

a = 20   // 正确：赋值

7.4 赋值表达式 #

// 错误：Go不支持赋值表达式
if err = doSomething(); err != nil {
    // 这是合法的，但不是赋值表达式
}

八、最佳实践 #

8.1 使用有意义的变量名 #

totalPrice := 0
for _, item := range items {
    totalPrice += item.Price
}

8.2 避免链式赋值 #

// 不推荐
a, b, c = 1, 1, 1

// 推荐
a = 1
b = 1
c = 1

// 或者
a, b, c = 1, 1, 1  // 如果确实相同

8.3 及时处理错误 #

data, err := readFile("test.txt")
if err != nil {
    return err
}
// 使用data

九、总结 #

赋值运算符要点：

运算符	说明	等价形式
=	赋值	a = b
+=	加后赋值	a = a + b
-=	减后赋值	a = a - b
*=	乘后赋值	a = a * b
/=	除后赋值	a = a / b
%=	取余后赋值	a = a % b
&=	按位与后赋值	a = a & b
\|=	按位或后赋值	a = a \| b
^=	按位异或后赋值	a = a ^ b
<<=	左移后赋值	a = a << n
>>=	右移后赋值	a = a >> n

关键点：

赋值是语句：不是表达式
多变量赋值：支持同时赋值多个变量
复合赋值：简化运算和赋值操作
类型匹配：赋值时类型必须匹配