一、什么是短变量声明 :=

:= 是 Go 极简语法，用来快速声明+初始化变量
好处：不用写 var，自动推导类型
语法：

a := 10

但！它不是无害语法糖，藏着超多作用域陷阱！

二、:= 核心规则（必须背）

1. 1. 同时声明+赋值，一步到位
2. 2. 只能在函数内部使用（不能全局）
3. 3. 左侧必须至少有一个新变量
4. 4. 相同作用域不能重复声明同名变量
5. 5. 不同作用域会产生变量遮蔽！

三、:= 最容易踩的 4 大陷阱（高频）

1️⃣ 变量遮蔽（最常见）

内层 := 会创建新变量，盖住外层同名变量

func main() {
    a := 10
    if true {
        a := 20  // 新变量！遮蔽外层
        fmt.Println(a) // 20
    }
    fmt.Println(a) // 10（没变！）
}

2️⃣ 多变量赋值只部分声明

必须至少一个新变量，否则报错

a := 1
a, b := 2, 3  // ✅ 合法（b是新的）
a, b := 4, 5  // ❌ 报错：无新变量

3️⃣ 不能全局使用

num := 100  // ❌ 报错！全局只能用 var

4️⃣ 误覆盖 err 导致逻辑错误

err := func1()
if xxx {
    data, err := func2()  // 新err，遮蔽旧err
}
// 外层err没变！

四、:= vs = 对比表（收藏）

五、完整可运行 Demo（全覆盖、可直接跑）

main.go 零语法错误，演示所有陷阱+正确写法👇

package main

import "fmt"

func main() {
    fmt.Println("===== 1. 变量遮蔽陷阱 =====")
    x := 10
    if true {
        x := 20 // 遮蔽！
        fmt.Println("if 内 x =", x)
    }
    fmt.Println("if 外 x =", x) // 依旧10

    fmt.Println("\n===== 2. 正确写法（不遮蔽） =====")
    y := 10
    if true {
        y = 20 // 直接赋值，不新建
        fmt.Println("if 内 y =", y)
    }
    fmt.Println("if 外 y =", y) // 变成20 ✅

    fmt.Println("\n===== 3. 多变量 := 用法 =====")
    a, b := 1, 2
    fmt.Println("a =", a, "b =", b)

    // 部分新变量 → 合法
    b, c := 3, 4
    fmt.Println("b =", b, "c =", c)

    fmt.Println("\n✅ 短变量声明演示完成！")
}

运行命令

go run main.go

运行结果

===== 1. 变量遮蔽陷阱 =====
if 内 x = 20
if 外 x = 10

===== 2. 正确写法（不遮蔽） =====
if 内 y = 20
if 外 y = 20

===== 3. 多变量 := 用法 =====
a = 1 b = 2
b = 3 c = 4

✅ 短变量声明演示完成！

六、如何避免 := 陷阱？（超级实用）

✅ 规则1：if/for 内部尽量用 = 不要用 :=

✅ 规则2：尽量不要用同名变量

✅ 规则3：多返回值赋值时小心 err 被覆盖

✅ 规则4：使用 go vet 检查遮蔽

go vet main.go

七、新手避坑指南

1. 1. ❌ 不要在块内用 := 重名声明
2. 2. ❌ 不要全局使用 :=
3. 3. ❌ 不要在同一行重复声明所有变量
4. 4. ✅ 修改变量用 =，新变量用 :=
5. 5. ✅ 变量名尽量语义化，不重名

📌 总结

1. 1. := = 声明+赋值，只能在函数内
2. 2. 同作用域不能重复声明
3. 3. 不同作用域会产生变量遮蔽（最大坑）
4. 4. 多变量必须至少一个新变量
5. 5. 避免陷阱：少重名 + 块内用 =

掌握 := 规则，Go 代码稳定性直接提升一个档次 ✨