参考资料

翻译自

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不允许包与包之间的循环依赖，所以只能形成一个包内的变量依赖另一个包初始化的关系