参考资料
翻译自
https://medium.com/golangspec/initialization-dependencies-in-go-51ae7b53f24c
正文
让我们从两个简单地go程序开始举例
程序1
package main
import "fmt"
var (
a int = b + 1
b int = 1
)
func main() {
fmt.Println(a)
fmt.Println(b)
}
程序1输出
2
1
Program exited.
程序2
package main
import "fmt"
func main() {
var (
a int = b + 1
b int = 1
)
fmt.Println(a)
fmt.Println(b)
}
程序2输出
./prog.go:5:17: undefined: b
Go build failed.
如果两个程序输出一样，就不会成为本文的材料了。一般情况下来说，go的初始化表达式都是从上到下，自左向右执行的。如下的例子程序
package main
import "fmt"
func f() int { fmt.Println("f"); return 1 }
func g() int { fmt.Println("g"); return 2 }
func h() int { fmt.Println("h"); return 3 }
func main() {
var (
a int = f()
b int = g()
c int = h()
)
fmt.Println(a, b, c)
}
输出
f
g
h
1 2 3
“一般”指的是函数内的初始化流程。如果是顶级声明（包级别），这个时候初始化依赖就要发挥作用了: 如下的程序
package main
import "fmt"
var (
a = c - 2
b = 2
c = f()
)
func f() int {
fmt.Printf("inside f and b = %d\n", b)
return b + 1
}
func main() {
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
并不会提示c没有被定义，而是，程序会正常运行，并按以下的流程来推断初始化顺序
- b最先，因为它不依赖其他的未初始化变量
- 接下来是c，c通过f函数依赖了b
- a依赖c，所以a在最后初始化
输出是这样的
inside f and b = 2
1
2
3
每个初始化周期选择第一个（按声明顺序）准备好的变量。整个流程一直会持续，直到所有的变量都初始化完毕，或者碰到初始化循环处理不了为止，例如:
package main
import "fmt"
var (
a = c - 2
b = 2
c = f()
)
func f() int {
fmt.Printf("inside f and b = %d\n", b)
return b + 1
}
func main() {
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
会报错，./main.go:4:2: initialization loop:
依赖关系可以在包级别生效，即使使用多个文件也是一样的效果。
译者注：依赖关系也可以在包与包之间生效，golang不允许包与包之间的循环依赖，所以只能形成一个包内的变量依赖另一个包初始化的关系
