Go 语言变量作用域
包级、函数级、块级、以及遮蔽带来的隐蔽 bug。
Key Points变量在哪个 `{}` 里声明，就活到那个 `{}` 结束；包级变量活到程序结束。
三个层级
Go
package main
import "fmt"
var global = "包级" // 整个包可见
func main() {
local := "函数级"
{
block := "块级"
fmt.Println(global, local, block)
}
// fmt.Println(block) // 编译错误：undefined
fmt.Println(global, local)
}Output
包级 函数级 块级
包级 函数级| Level | Lifetime | Visible to |
|---|---|---|
| 包级 | 程序运行期 | 同包所有文件 |
| 函数级 | 函数调用期间 | 函数体 |
| 块级 | 块执行期间 | 该 {} 内 |
遮蔽
Go
x := 1
if true {
x := 2 // 新变量，遮蔽外层
fmt.Println("内", x)
}
fmt.Println("外", x)Output
内 2
外 1err 遮蔽的经典坑
Go
func bad() error {
var err error
if true {
_, err := os.Open("nope.txt") // := 新建了一个 err！
_ = err
}
return err // 永远是 nil
}
func good() error {
var err error
if true {
_, err = os.Open("nope.txt") // = 赋值给外层 err
}
return err // 正确返回错误
}One of Go's nastiest bugs:
:= inside if/for/switch creates a new variable, the outer err stays nil, and the function "succeeds". Catch it with the shadow vet tool or your IDE.包级变量的初始化顺序
Go
var a = b + 1 // 依赖 b
var b = 2
func init() {
fmt.Println("init 执行")
}
func main() {
fmt.Println(a, b)
}Output
init 执行
3 2Go topologically sorts package-level initialisation, so a can use a b declared later. init() runs after all variables and before main().
什么时候用包级变量
- 用 —— 全局配置、日志器、单例连接池（且用
sync.Once保护） - 不用 —— 跨函数传状态。传参更清楚，也更好测试
- 不用 —— 可变全局状态。并发下必然出问题
Go
var (
once sync.Once
client *http.Client
)
func getClient() *http.Client {
once.Do(func() {
client = &http.Client{Timeout: 10 * time.Second}
})
return client
}三个层级
Go
package main
import "fmt"
var global = "包级" // 整个包可见
func main() {
local := "函数级"
{
block := "块级"
fmt.Println(global, local, block)
}
// fmt.Println(block) // 编译错误：undefined
fmt.Println(global, local)
}Output
包级 函数级 块级
包级 函数级| 层级 | 生命周期 | 可见范围 |
|---|---|---|
| 包级 | 程序运行期 | 同包所有文件 |
| 函数级 | 函数调用期间 | 函数体 |
| 块级 | 块执行期间 | 该 {} 内 |
遮蔽
Go
x := 1
if true {
x := 2 // 新变量，遮蔽外层
fmt.Println("内", x)
}
fmt.Println("外", x)Output
内 2
外 1err 遮蔽的经典坑
Go
func bad() error {
var err error
if true {
_, err := os.Open("nope.txt") // := 新建了一个 err！
_ = err
}
return err // 永远是 nil
}
func good() error {
var err error
if true {
_, err = os.Open("nope.txt") // = 赋值给外层 err
}
return err // 正确返回错误
}这是 Go 里最阴的 bug 之一：
:= 在 if / for / switch 里新建变量，外层 err 保持 nil，函数「成功」返回。用 go vet -vettool=$(which shadow) 或 IDE 的 shadow 检查能提前发现。包级变量的初始化顺序
Go
var a = b + 1 // 依赖 b
var b = 2
func init() {
fmt.Println("init 执行")
}
func main() {
fmt.Println(a, b)
}Output
init 执行
3 2Go 会先按依赖关系排序再初始化包级变量，所以 a 能用到后面声明的 b。init() 在所有变量初始化完之后执行，且在 main() 之前。
什么时候用包级变量
- 用 —— 全局配置、日志器、单例连接池（且用
sync.Once保护） - 不用 —— 跨函数传状态。传参更清楚，也更好测试
- 不用 —— 可变全局状态。并发下必然出问题
Go
var (
once sync.Once
client *http.Client
)
func getClient() *http.Client {
once.Do(func() {
client = &http.Client{Timeout: 10 * time.Second}
})
return client
}