PHP小码农

Appearance

赋值运算符 ​

1. 概述 ​

赋值运算符是 Go 语言中用于给变量赋值的运算符，它们将右侧表达式的值赋给左侧的变量。赋值运算符在编程中非常常用，是变量初始化和更新的基础。

本章节将详细介绍 Go 语言中赋值运算符的种类、使用方法、优先级以及相关的最佳实践，帮助学习者掌握赋值运算符的核心概念和使用技巧。

2. 学习建议 ​

  • 学习时间：建议分配 1-2 小时学习赋值运算符的基本概念和使用方法
  • 学习方法：理论学习与实践相结合，每学习一个运算符后立即编写代码验证
  • 学习重点：各种赋值运算符的使用方法、复合赋值运算符的应用
  • 学习难点：复合赋值运算符的优先级、赋值表达式的返回值

3. 前置知识要求 ​

  • 基础编程概念
  • 计算机基础知识
  • 了解基本的数据类型
  • 了解变量的声明和使用

4. 学习目标 ​

  • 掌握 Go 语言中赋值运算符的种类和使用方法
  • 理解赋值运算符的工作原理
  • 能够正确使用赋值运算符给变量赋值
  • 了解赋值运算中的常见错误和避免方法
  • 掌握赋值运算符的最佳实践

5. 基本概念 ​

5.1 语法 ​

5.1.1 基本赋值运算符 ​

Go 语言中提供了以下基本赋值运算符：

运算符描述示例
=简单赋值x = y
+=加法赋值x += y
-=减法赋值x -= y
*=乘法赋值x *= y
/=除法赋值x /= y
%=取模赋值x %= y
<<=左移赋值x <<= y
>>=右移赋值x >>= y
&=按位与赋值x &= y
^=按位异或赋值x ^= y
|=按位或赋值x |= y

示例代码：

go
func main() {
    // 简单赋值
    x := 10
    fmt.Println("x =", x) // 输出: x = 10
    
    // 加法赋值
    x += 5
    fmt.Println("x += 5 =", x) // 输出: x += 5 = 15
    
    // 减法赋值
    x -= 3
    fmt.Println("x -= 3 =", x) // 输出: x -= 3 = 12
    
    // 乘法赋值
    x *= 2
    fmt.Println("x *= 2 =", x) // 输出: x *= 2 = 24
    
    // 除法赋值
    x /= 4
    fmt.Println("x /= 4 =", x) // 输出: x /= 4 = 6
    
    // 取模赋值
    x %= 5
    fmt.Println("x %= 5 =", x) // 输出: x %= 5 = 1
}

5.2 语义 ​

  • 简单赋值运算符：将右侧表达式的值赋给左侧的变量
  • 复合赋值运算符：先对左侧变量和右侧表达式执行相应的运算，然后将结果赋给左侧变量

5.3 规范 ​

  • 运算符优先级：赋值运算符的优先级较低，低于算术运算符、关系运算符和逻辑运算符
  • 结合性：赋值运算符的结合性是从右到左
  • 左侧操作数：赋值运算符的左侧操作数必须是可修改的左值，如变量、数组元素、结构体字段等
  • 右侧操作数：赋值运算符的右侧操作数可以是任意表达式

6. 原理深度解析 ​

6.1 赋值运算的实现原理 ​

Go 语言中的赋值运算由编译器转换为相应的机器指令来实现。具体来说：

  1. 简单赋值：编译器会生成相应的存储指令，将右侧表达式的值存储到左侧变量的内存地址
  2. 复合赋值：编译器会生成相应的运算指令和存储指令，先执行运算，然后存储结果

示例代码：

go
func main() {
    // 赋值运算的实现原理
    x := 10
    fmt.Println("x =", x) // 输出: x = 10
    
    // 复合赋值
    x += 5 // 等价于 x = x + 5
    fmt.Println("x += 5 =", x) // 输出: x += 5 = 15
    
    // 多个赋值
    a, b := 1, 2
    fmt.Println("a =", a, "b =", b) // 输出: a = 1 b = 2
    
    // 交换变量
    a, b = b, a
    fmt.Println("交换后: a =", a, "b =", b) // 输出: 交换后: a = 2 b = 1
}

6.2 复合赋值运算符的应用 ​

复合赋值运算符是一种简洁的写法，它们等价于先执行运算，然后将结果赋给左侧变量。例如：

  • x += y 等价于 x = x + y
  • x -= y 等价于 x = x - y
  • x *= y 等价于 x = x * y

复合赋值运算符的优点是代码更简洁，而且在某些情况下，编译器可以对复合赋值运算符进行优化，提高代码的执行效率。

示例代码：

go
func main() {
    // 复合赋值运算符的应用
    x := 10
    
    // 等价于 x = x + 5
    x += 5
    fmt.Println("x += 5 =", x) // 输出: x += 5 = 15
    
    // 等价于 x = x - 3
    x -= 3
    fmt.Println("x -= 3 =", x) // 输出: x -= 3 = 12
    
    // 等价于 x = x * 2
    x *= 2
    fmt.Println("x *= 2 =", x) // 输出: x *= 2 = 24
    
    // 等价于 x = x / 4
    x /= 4
    fmt.Println("x /= 4 =", x) // 输出: x /= 4 = 6
}

6.3 多重赋值 ​

Go 语言支持多重赋值，即一次给多个变量赋值。多重赋值的语法是：

go
var1, var2, ..., varn = expr1, expr2, ..., exprn

多重赋值在以下场景中非常有用：

  1. 变量交换：不使用临时变量交换两个变量的值
  2. 函数返回多个值：接收函数返回的多个值
  3. 并行赋值：同时给多个变量赋值

示例代码：

go
func main() {
    // 多重赋值
    
    // 1. 变量交换
    a, b := 1, 2
    fmt.Println("交换前: a =", a, "b =", b) // 输出: 交换前: a = 1 b = 2
    a, b = b, a
    fmt.Println("交换后: a =", a, "b =", b) // 输出: 交换后: a = 2 b = 1
    
    // 2. 接收函数返回多个值
    x, y := swap(3, 4)
    fmt.Println("函数返回: x =", x, "y =", y) // 输出: 函数返回: x = 4 y = 3
    
    // 3. 并行赋值
    c, d, e := 5, 6, 7
    fmt.Println("并行赋值: c =", c, "d =", d, "e =", e) // 输出: 并行赋值: c = 5 d = 6 e = 7
}

func swap(x, y int) (int, int) {
    return y, x
}

6.4 短变量声明 ​

在函数内部，可以使用 := 运算符进行短变量声明，它同时完成变量的声明和赋值：

go
x := 10 // 等价于 var x int = 10

短变量声明的特点：

  1. 自动类型推断：编译器会根据右侧表达式的值自动推断变量的类型
  2. 只能在函数内部使用：短变量声明只能在函数内部使用，不能在包级别使用
  3. 可以声明多个变量：可以同时声明多个变量
  4. 可以重新声明：在不同的作用域中，可以重新声明同名变量

示例代码：

go
func main() {
    // 短变量声明
    x := 10
    fmt.Println("x =", x, "类型:", reflect.TypeOf(x)) // 输出: x = 10 类型: int
    
    // 声明多个变量
    y, z := 20, 30
    fmt.Println("y =", y, "z =", z) // 输出: y = 20 z = 30
    
    // 重新声明（在不同的作用域中）
    if true {
        x := "hello" // 重新声明 x，类型为 string
        fmt.Println("内部 x =", x, "类型:", reflect.TypeOf(x)) // 输出: 内部 x = hello 类型: string
    }
    fmt.Println("外部 x =", x, "类型:", reflect.TypeOf(x)) // 输出: 外部 x = 10 类型: int
}

7. 常见错误与踩坑点 ​

7.1 左侧操作数不是左值 ​

错误表现：编译错误，提示 "cannot assign to ..."

产生原因：赋值运算符的左侧操作数不是可修改的左值，如常量、字面量、表达式等

解决方案：

  • 确保赋值运算符的左侧操作数是可修改的左值，如变量、数组元素、结构体字段等

示例代码：

go
func main() {
    // 左侧操作数不是左值
    
    // 错误：常量不能作为左值
    // const x = 10
    // x = 20 // 编译错误: cannot assign to x
    
    // 错误：字面量不能作为左值
    // 10 = 20 // 编译错误: cannot assign to 10
    
    // 错误：表达式不能作为左值
    // a := 10
    // (a + 1) = 20 // 编译错误: cannot assign to (a + 1)
    
    // 正确：变量作为左值
    b := 10
    b = 20
    fmt.Println("b =", b) // 输出: b = 20
}

7.2 类型不匹配 ​

错误表现：编译错误，提示 "cannot use ... (type ...) as type ... in assignment"

产生原因：赋值运算符右侧表达式的类型与左侧变量的类型不匹配

解决方案：

  • 确保右侧表达式的类型与左侧变量的类型匹配
  • 使用类型转换将右侧表达式转换为左侧变量的类型

示例代码：

go
func main() {
    // 类型不匹配
    
    // 错误：类型不匹配
    // var x int = 10
    // x = "hello" // 编译错误: cannot use "hello" (type string) as type int in assignment
    
    // 正确：类型匹配
    var y int = 10
    y = 20
    fmt.Println("y =", y) // 输出: y = 20
    
    // 正确：使用类型转换
    var z int = 10
    z = int(3.14)
    fmt.Println("z =", z) // 输出: z = 3
}

7.3 短变量声明的重复声明 ​

错误表现：编译错误，提示 "no new variables on left side of :="

产生原因：在同一个作用域中，使用 := 重复声明变量

解决方案：

  • 在同一个作用域中，对于已声明的变量，使用 = 进行赋值
  • 确保 := 左侧至少有一个新变量

示例代码：

go
func main() {
    // 短变量声明的重复声明
    
    // 正确：第一次声明
    x := 10
    fmt.Println("x =", x) // 输出: x = 10
    
    // 错误：重复声明
    // x := 20 // 编译错误: no new variables on left side of :=
    
    // 正确：使用 = 赋值
    x = 20
    fmt.Println("x =", x) // 输出: x = 20
    
    // 正确：至少有一个新变量
    x, y := 30, 40 // x 是重新声明，y 是新变量
    fmt.Println("x =", x, "y =", y) // 输出: x = 30 y = 40
}

7.4 多重赋值的数量不匹配 ​

错误表现：编译错误，提示 "assignment count mismatch: ..."

产生原因：多重赋值时，左侧变量的数量与右侧表达式的数量不匹配

解决方案：

  • 确保多重赋值时，左侧变量的数量与右侧表达式的数量匹配
  • 使用 _ 占位符忽略不需要的值

示例代码：

go
func main() {
    // 多重赋值的数量不匹配
    
    // 错误：数量不匹配
    // x, y := 1 // 编译错误: assignment count mismatch: 2 variables but 1 values
    
    // 正确：数量匹配
    a, b := 1, 2
    fmt.Println("a =", a, "b =", b) // 输出: a = 1 b = 2
    
    // 正确：使用 _ 占位符
    c, _ := swap(3, 4) // 忽略第二个返回值
    fmt.Println("c =", c) // 输出: c = 4
}

func swap(x, y int) (int, int) {
    return y, x
}

8. 常见应用场景 ​

8.1 变量初始化 ​

场景描述：使用赋值运算符初始化变量

使用方法：使用 = 或 := 运算符给变量赋初始值

示例代码：

go
func main() {
    // 变量初始化
    
    // 使用 = 初始化（包级别或函数级别）
    var x int = 10
    fmt.Println("x =", x) // 输出: x = 10
    
    // 使用 := 初始化（函数级别）
    y := 20
    fmt.Println("y =", y) // 输出: y = 20
    
    // 初始化多个变量
    a, b, c := 1, 2, 3
    fmt.Println("a =", a, "b =", b, "c =", c) // 输出: a = 1 b = 2 c = 3
}

8.2 变量更新 ​

场景描述：使用赋值运算符更新变量的值

使用方法：使用 = 或复合赋值运算符更新变量的值

示例代码：

go
func main() {
    // 变量更新
    
    // 使用 = 更新
    x := 10
    fmt.Println("初始 x =", x) // 输出: 初始 x = 10
    x = 20
    fmt.Println("更新后 x =", x) // 输出: 更新后 x = 20
    
    // 使用复合赋值运算符更新
    y := 10
    fmt.Println("初始 y =", y) // 输出: 初始 y = 10
    y += 5
    fmt.Println("y += 5 =", y) // 输出: y += 5 = 15
    y *= 2
    fmt.Println("y *= 2 =", y) // 输出: y *= 2 = 30
}

8.3 变量交换 ​

场景描述：使用多重赋值交换两个变量的值

使用方法：使用多重赋值语法 a, b = b, a 交换两个变量的值

示例代码：

go
func main() {
    // 变量交换
    
    // 传统方法：使用临时变量
    x, y := 1, 2
    fmt.Println("交换前: x =", x, "y =", y) // 输出: 交换前: x = 1 y = 2
    
    // 传统方法
    temp := x
    x = y
    y = temp
    fmt.Println("传统方法交换后: x =", x, "y =", y) // 输出: 传统方法交换后: x = 2 y = 1
    
    // Go 方法：使用多重赋值
    a, b := 3, 4
    fmt.Println("交换前: a =", a, "b =", b) // 输出: 交换前: a = 3 b = 4
    a, b = b, a
    fmt.Println("多重赋值交换后: a =", a, "b =", b) // 输出: 多重赋值交换后: a = 4 b = 3
}

8.4 函数返回值处理 ​

场景描述：使用多重赋值接收函数返回的多个值

使用方法：使用多重赋值语法接收函数返回的多个值

示例代码：

go
func main() {
    // 函数返回值处理
    
    // 接收函数返回的多个值
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }
    
    // 忽略错误
    result2, _ := divide(20, 5)
    fmt.Println("结果:", result2)
}

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

8.5 复合赋值优化 ​

场景描述：使用复合赋值运算符优化代码，提高代码可读性和执行效率

使用方法：使用复合赋值运算符替代等价的简单赋值表达式

示例代码：

go
func main() {
    // 复合赋值优化
    
    // 传统方法
    x := 10
    fmt.Println("初始 x =", x) // 输出: 初始 x = 10
    x = x + 5
    fmt.Println("x = x + 5 =", x) // 输出: x = x + 5 = 15
    x = x * 2
    fmt.Println("x = x * 2 =", x) // 输出: x = x * 2 = 30
    
    // 复合赋值方法
    y := 10
    fmt.Println("初始 y =", y) // 输出: 初始 y = 10
    y += 5
    fmt.Println("y += 5 =", y) // 输出: y += 5 = 15
    y *= 2
    fmt.Println("y *= 2 =", y) // 输出: y *= 2 = 30
}

9. 行业最佳实践 ​

9.1 变量初始化 ​

  • 使用短变量声明：在函数内部，使用 := 进行短变量声明，提高代码可读性
  • 初始化时赋值：尽量在变量声明时进行初始化，避免使用零值
  • 批量初始化：对于相关的变量，使用多重赋值进行批量初始化

示例代码：

go
func main() {
    // 变量初始化最佳实践
    
    // 好的做法：使用短变量声明
    x := 10
    fmt.Println("x =", x)
    
    // 好的做法：初始化时赋值
    y := 20
    fmt.Println("y =", y)
    
    // 好的做法：批量初始化
    a, b, c := 1, 2, 3
    fmt.Println("a =", a, "b =", b, "c =", c)
}

9.2 变量更新 ​

  • 使用复合赋值运算符：对于简单的更新操作，使用复合赋值运算符，提高代码可读性
  • 避免过度使用复合赋值：对于复杂的更新操作，使用简单赋值，提高代码可读性

示例代码：

go
func main() {
    // 变量更新最佳实践
    
    // 好的做法：使用复合赋值运算符
    x := 10
    x += 5 // 简洁明了
    fmt.Println("x += 5 =", x)
    
    // 好的做法：对于复杂操作，使用简单赋值
    y := 10
    y = (y + 5) * 2 // 清晰表达逻辑
    fmt.Println("y =", y)
}

9.3 多重赋值 ​

  • 使用多重赋值交换变量：使用 a, b = b, a 交换两个变量的值，避免使用临时变量
  • 使用 _ 忽略不需要的值：对于函数返回的多个值，使用 _ 占位符忽略不需要的值
  • 保持赋值顺序清晰：确保多重赋值时，左侧变量与右侧表达式的顺序对应清晰

示例代码：

go
func main() {
    // 多重赋值最佳实践
    
    // 好的做法：使用多重赋值交换变量
    a, b := 1, 2
    fmt.Println("交换前: a =", a, "b =", b)
    a, b = b, a
    fmt.Println("交换后: a =", a, "b =", b)
    
    // 好的做法：使用 _ 忽略不需要的值
    result, _ := divide(10, 2)
    fmt.Println("结果:", result)
}

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

9.4 代码风格 ​

  • 赋值运算符周围的空格：在赋值运算符周围添加空格，提高代码可读性
  • 对齐赋值语句：对于多行赋值语句，对齐赋值运算符，提高代码可读性

示例代码：

go
func main() {
    // 代码风格最佳实践
    
    // 好的做法：在赋值运算符周围添加空格
    x := 10
    y = 20
    
    // 好的做法：对齐赋值语句
    width  := 100
    height := 200
    depth  := 300
    
    fmt.Println("width =", width, "height =", height, "depth =", depth)
}

10. 常见问题答疑（FAQ） ​

10.1 Q: Go 语言中赋值运算符的优先级是怎样的？ ​

A: Go 语言中赋值运算符的优先级较低，低于算术运算符、关系运算符和逻辑运算符。具体来说：

  • 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

示例代码：

go
func main() {
    // 赋值运算符的优先级
    x := 10
    y := 5
    
    // 优先级示例
    x += y * 2 // 等价于 x = x + (y * 2)
    fmt.Println("x += y * 2 =", x) // 输出: x += y * 2 = 20
}

10.2 Q: Go 语言中复合赋值运算符的含义是什么？ ​

A: 复合赋值运算符是一种简洁的写法，它们等价于先执行运算，然后将结果赋给左侧变量。例如：

  • x += y 等价于 x = x + y
  • x -= y 等价于 x = x - y
  • x *= y 等价于 x = x * y
  • x /= y 等价于 x = x / y
  • x %= y 等价于 x = x % y

示例代码：

go
func main() {
    // 复合赋值运算符的含义
    x := 10
    y := 5
    
    // 等价于 x = x + y
    x += y
    fmt.Println("x += y =", x) // 输出: x += y = 15
    
    // 等价于 x = x - y
    x -= y
    fmt.Println("x -= y =", x) // 输出: x -= y = 10
}

10.3 Q: Go 语言中如何交换两个变量的值？ ​

A: 在 Go 语言中，可以使用多重赋值语法 a, b = b, a 交换两个变量的值，不需要使用临时变量。

示例代码：

go
func main() {
    // 交换两个变量的值
    a, b := 1, 2
    fmt.Println("交换前: a =", a, "b =", b) // 输出: 交换前: a = 1 b = 2
    
    // 使用多重赋值交换
    a, b = b, a
    fmt.Println("交换后: a =", a, "b =", b) // 输出: 交换后: a = 2 b = 1
}

10.4 Q: Go 语言中短变量声明和简单赋值有什么区别？ ​

A: 短变量声明和简单赋值的区别如下：

  • 语法：短变量声明使用 :=，简单赋值使用 =
  • 作用：短变量声明同时完成变量的声明和赋值，简单赋值只完成赋值
  • 使用范围：短变量声明只能在函数内部使用，简单赋值可以在任何地方使用
  • 重复声明：短变量声明在不同作用域中可以重复声明同名变量，简单赋值不能

示例代码：

go
func main() {
    // 短变量声明和简单赋值的区别
    
    // 短变量声明
    x := 10
    fmt.Println("x =", x) // 输出: x = 10
    
    // 简单赋值
    x = 20
    fmt.Println("x =", x) // 输出: x = 20
    
    // 短变量声明可以在不同作用域中重复声明
    if true {
        x := "hello" // 新的 x，类型为 string
        fmt.Println("内部 x =", x) // 输出: 内部 x = hello
    }
    fmt.Println("外部 x =", x) // 输出: 外部 x = 20
}

10.5 Q: Go 语言中如何处理函数返回的多个值？ ​

A: 在 Go 语言中，可以使用多重赋值语法接收函数返回的多个值，使用 _ 占位符忽略不需要的值。

示例代码：

go
func main() {
    // 处理函数返回的多个值
    
    // 接收所有返回值
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }
    
    // 忽略错误
    result2, _ := divide(20, 5)
    fmt.Println("结果:", result2)
}

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

10.6 Q: Go 语言中赋值表达式有返回值吗？ ​

A: 在 Go 语言中，赋值表达式没有返回值，不能作为其他表达式的一部分使用。这与 C、C++ 等语言不同。

示例代码：

go
func main() {
    // 赋值表达式没有返回值
    
    // 错误：赋值表达式不能作为其他表达式的一部分
    // x := 10
    // y := (x = 20) // 编译错误: assignment expression not used as value
    
    // 正确：分开写
    x := 10
    x = 20
    y := x
    fmt.Println("y =", y) // 输出: y = 20
}

11. 实战练习 ​

11.1 基础练习 ​

练习 1：基本赋值运算

题目：编写一个程序，使用赋值运算符进行基本的赋值操作。

解题思路：使用各种赋值运算符进行赋值操作，观察结果。

参考代码：

go
func main() {
    // 基本赋值运算
    
    // 简单赋值
    x := 10
    fmt.Println("x =", x)
    
    // 复合赋值
    x += 5
    fmt.Println("x += 5 =", x)
    
    x -= 3
    fmt.Println("x -= 3 =", x)
    
    x *= 2
    fmt.Println("x *= 2 =", x)
    
    x /= 4
    fmt.Println("x /= 4 =", x)
    
    x %= 5
    fmt.Println("x %= 5 =", x)
}

运行结果：

x = 10
x += 5 = 15
x -= 3 = 12
x *= 2 = 24
x /= 4 = 6
x %= 5 = 1

11.2 进阶练习 ​

练习 2：变量交换

题目：编写一个程序，使用多重赋值交换两个变量的值，并比较传统方法和多重赋值方法的区别。

提示：

  • 传统方法：使用临时变量交换
  • 多重赋值方法：使用 a, b = b, a 交换

参考代码：

go
func main() {
    // 变量交换
    
    // 传统方法：使用临时变量
    a, b := 10, 20
    fmt.Println("传统方法 - 交换前: a =", a, "b =", b)
    
    temp := a
    a = b
    b = temp
    fmt.Println("传统方法 - 交换后: a =", a, "b =", b)
    
    // 多重赋值方法
    c, d := 30, 40
    fmt.Println("多重赋值方法 - 交换前: c =", c, "d =", d)
    
    c, d = d, c
    fmt.Println("多重赋值方法 - 交换后: c =", c, "d =", d)
}

运行结果：

传统方法 - 交换前: a = 10 b = 20
传统方法 - 交换后: a = 20 b = 10
多重赋值方法 - 交换前: c = 30 d = 40
多重赋值方法 - 交换后: c = 40 d = 30

11.3 挑战练习 ​

练习 3：赋值运算符的应用

题目：编写一个程序，使用赋值运算符实现一个简单的计数器，并演示复合赋值运算符的应用。

提示：

  • 实现一个计数器，支持增加、减少、重置操作
  • 使用复合赋值运算符实现增加和减少操作

参考代码：

go
func main() {
    // 赋值运算符的应用
    
    // 实现一个计数器
    type Counter struct {
        value int
    }
    
    // 增加操作
    increment := func(c *Counter, n int) {
        c.value += n // 使用复合赋值运算符
    }
    
    // 减少操作
    decrement := func(c *Counter, n int) {
        c.value -= n // 使用复合赋值运算符
    }
    
    // 重置操作
    reset := func(c *Counter) {
        c.value = 0 // 使用简单赋值运算符
    }
    
    // 测试计数器
    counter := Counter{value: 0}
    fmt.Println("初始值:", counter.value)
    
    increment(&counter, 5)
    fmt.Println("增加 5 后:", counter.value)
    
    increment(&counter, 3)
    fmt.Println("增加 3 后:", counter.value)
    
    decrement(&counter, 2)
    fmt.Println("减少 2 后:", counter.value)
    
    reset(&counter)
    fmt.Println("重置后:", counter.value)
}

运行结果：

初始值: 0
增加 5 后: 5
增加 3 后: 8
减少 2 后: 6
重置后: 0

12. 知识点总结 ​

12.1 核心要点 ​

  • 基本赋值运算符：简单赋值（=）和复合赋值运算符（+=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=）
  • 复合赋值运算符：先执行运算，然后将结果赋给左侧变量，等价于 x = x op y
  • 多重赋值：使用 a, b = b, a 交换变量的值，接收函数返回的多个值
  • 短变量声明：使用 := 同时完成变量的声明和赋值，只能在函数内部使用
  • 赋值运算符的优先级：低于算术运算符、关系运算符和逻辑运算符

12.2 易错点回顾 ​

  • 左侧操作数不是左值：赋值运算符的左侧操作数必须是可修改的左值
  • 类型不匹配：右侧表达式的类型必须与左侧变量的类型匹配
  • 短变量声明的重复声明：在同一个作用域中，不能使用 := 重复声明变量
  • 多重赋值的数量不匹配：左侧变量的数量必须与右侧表达式的数量匹配
  • 赋值表达式没有返回值：Go 语言中赋值表达式没有返回值，不能作为其他表达式的一部分使用

13. 拓展参考资料 ​

13.1 官方文档链接 ​

13.2 进阶学习路径建议 ​

  • 变量和常量：深入学习 Go 语言中的变量和常量
  • 数据类型：学习 Go 语言中的数据类型
  • 函数：学习 Go 语言中的函数定义和使用
  • 控制流：学习 Go 语言中的控制流语句

13.3 相关资源 ​