一、什么是变量遮蔽？

一句话讲清楚：
内层作用域定义了和外层同名的变量，导致外层变量被“盖住”，无法访问。

特点：
✅ 语法不报错
✅ 编译不报错
✅ 运行逻辑错到离谱
这是 Go 新手Top 级隐形坑！

二、变量遮蔽核心规则

1. 1. 同名变量 + 不同层级作用域 = 遮蔽发生
2. 2. 内层覆盖外层，全局 ← 函数 ← 块级
3. 3. 使用 := 声明变量最容易触发遮蔽
4. 4. 外层变量并不会被修改，只是看不见了

三、变量遮蔽场景对照表（收藏）

四、最经典的 3 大遮蔽案例

1. 全局变量被函数遮蔽

var name = "全局"

func main() {
    name := "局部" // 遮蔽！全局被盖住
    fmt.Println(name) // 输出：局部
}

2. if 块遮蔽函数变量（最常见）

func main() {
    age := 18
    if true {
        age := 99 // 遮蔽！
        fmt.Println(age) // 99
    }
    fmt.Println(age) // 依旧 18（没改到外层！）
}

3. := 多变量赋值隐形遮蔽（90% 人中招）

func main() {
    err := initConfig()
    if true {
        // 这里新定义了 err，遮蔽了外层！
        data, err := readData()
    }
    // 外层 err 根本没变！
}

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

main.go 零语法错误，演示遮蔽 + 正确写法👇

package main

import "fmt"

// 全局变量
var globalVar = "我是全局"

func main() {
    fmt.Println("===== 1. 全局变量被遮蔽 =====")
    globalVar := "我是函数内变量"
    fmt.Println("输出结果：", globalVar)

    fmt.Println("\n===== 2. 块级遮蔽（经典坑） =====")
    outer := 100
    if true {
        outer := 200 // 遮蔽！
        fmt.Println("if 内：", outer)
    }
    fmt.Println("if 外：", outer) // 依旧 100

    fmt.Println("\n===== 3. 正确写法（不遮蔽） =====")
    outer2 := 100
    if true {
        outer2 = 200 // 直接赋值，不声明
        fmt.Println("if 内：", outer2)
    }
    fmt.Println("if 外：", outer2) // 变成 200 ✅

    fmt.Println("\n✅ 变量遮蔽演示完成！")
}

运行命令

go run main.go

运行结果

===== 1. 全局变量被遮蔽 =====
输出结果： 我是函数内变量

===== 2. 块级遮蔽（经典坑） =====
if 内： 200
if 外： 100

===== 3. 正确写法（不遮蔽） =====
if 内： 200
if 外： 200

✅ 变量遮蔽演示完成！

六、如何快速判断 & 避免遮蔽？（超级实用）

✅ 方法1：不要用同名变量（最安全）

✅ 方法2：块里要修改外层 → 用 = 不要用 :=

✅ 方法3：开启 IDE 警告（GoLand / VS Code 都支持）

✅ 方法4：使用 go vet 检查

go vet main.go

能直接检测出变量遮蔽！

七、新手避坑指南（必看）

1. 1. ❌ 不要随便用同名变量
2. 2. ❌ if/for 内部尽量不用 := 声明同名变量
3. 3. ❌ 多返回值 := 要特别小心
4. 4. ✅ 修改变量用 =，声明变量用 :=
5. 5. ✅ 不确定就用 go vet 检查

📌 总结

1. 1. 变量遮蔽 = 内层同名盖住外层
2. 2. 语法不报错，逻辑必出错
3. 3. 最常出现在 if/for/多返回值 :=
4. 4. 避免方法：不同名 + 用 = 修改变量
5. 5. 检查工具：go vet

学会变量遮蔽，直接避开 Go 最常见的隐形bug ✨