基本概念：

在Go语言中，init 函数是一个特殊的函数，它在程序执行开始之前自动执行。每个包可以包含一个或多个 init 函数，这些函数会在包被导入时自动执行。init 函数的主要用途包括：

初始化包级别的变量：可以在 init 函数中对包级别的变量进行初始化。执行一些初始化逻辑：例如，打开数据库连接、读取配置文件等。注册服务或插件：在某些情况下，init 函数可以用来注册服务或插件。特点init 函数的执行顺序1.文件结构简单，没有其他依赖的场景：

在Go语言中，一个文件中可以定义多个 init 函数。这些 init 函数的执行顺序遵循以下规则：

按代码顺序执行：在一个文件中，多个 init 函数会按照它们在文件中出现的顺序依次执行。文件间的顺序：如果一个包中有多个文件，Go编译器会按照文件名的字母顺序加载这些文件，并依次执行每个文件中的 init 函数。示例

假设有一个包 example，其中包含两个文件 a.go 和 b.go，它们的代码如下：

a.go

package example
import "fmt"
func init() {
    fmt.Println("init 1 in a.go")
}
func init() {
    fmt.Println("init 2 in a.go")
}

b.go

package example
import "fmt"
func init() {
    fmt.Println("init 1 in b.go")
}
func init() {
    fmt.Println("init 2 in b.go")
}

main.go

package main
import (
    "example"
    "fmt"
)
func main() {
    fmt.Println("main function")
}

执行顺序文件加载顺序：Go编译器会按照文件名的字母顺序加载文件，因此 a.go 会先于 b.go 被加载。文件内 init 函数的执行顺序：在每个文件中，init 函数会按照它们在文件中出现的顺序依次执行。

因此，程序的输出顺序将是：

init 1 in a.go
init 2 in a.go
init 1 in b.go
init 2 in b.go
main function

这种设计确保了 init 函数的执行顺序是可预测的，开发者可以根据需要合理安排 init 函数的位置和顺序。

2.文件结构相对复杂，存在导入其他包的场景

init 函数的执行顺序不仅与当前包内的文件和代码顺序有关，还与包的导入关系有关。如果一个文件导入了其他包，并且这些被导入的包中也有 init 函数，那么执行顺序会更加复杂。

执行顺序规则包的初始化顺序：Go会按照包的依赖关系，从最底层的包开始初始化。如果包 A 导入了包 B，那么包 B 的 init 函数会先于包 A 的 init 函数执行。文件的加载顺序：在同一个包内，文件按照文件名的字母顺序加载。每个文件中的 init 函数按照它们在文件中出现的顺序依次执行。文件内 init 函数的执行顺序：在同一个文件中，多个 init 函数按照它们在文件中出现的顺序依次执行。导入包的 init 函数优先执行：如果一个文件导入了其他包，那么被导入包的 init 函数会先于当前文件的 init 函数执行。示例

假设有以下包和文件结构：

包 example包 sub1包 sub2main.gosub1/sub1.go

package sub1
import "fmt"
func init() {
    fmt.Println("init in sub1")
}

sub2/sub2.go

package sub2
import "fmt"
func init() {
    fmt.Println("init in sub2")
}

example/a.go

package example
import (
    "example/sub1"
    "fmt"
)
func init() {
    fmt.Println("init 1 in a.go")
}
func init() {
    fmt.Println("init 2 in a.go")
}

example/b.go

package example
import (
    "example/sub2"
    "fmt"
)
func init() {

    fmt.Println("init 1 in b.go")
}
func init() {
    fmt.Println("init 2 in b.go")
}

main.go

package main
import (
    "example"
    "fmt"
)
func main() {
    fmt.Println("main function")
}

执行顺序分析包的依赖关系：文件的加载顺序：init 函数的执行顺序：输出结果

程序的输出顺序将是：

init in sub1
init in sub2
init 1 in a.go
init 2 in a.go
init 1 in b.go
init 2 in b.go
main function

从执行结果来看，同一个文件中的 init 函数在程序的生命周期中只会执行一次，无论这个文件被导入多少次。

Go 文件的初始化顺序

在Go语言中，文件的初始化顺序遵循一定的规则，以确保程序在启动时正确地初始化各个包和变量。

1. 包级别的初始化顺序

Go程序的初始化从main包开始，然后按照依赖关系递归地初始化其他包。具体来说，包的初始化顺序如下：

包级别的变量初始化：init函数：2. 包之间的初始化顺序

Go程序的初始化是按照包的依赖关系进行的。具体来说：

依赖关系：递归初始化：3. main包的初始化

main包是Go程序的入口点，它的初始化顺序如下：

包级别的变量初始化：init函数：main函数：4. 示例

假设有以下文件结构：

main.go
pkgA/a.go
pkgB/b.go

main.go内容如下：

package main
import (
    "example/pkgA"
    "example/pkgB"
)
var mainVar = 10
func init() {
    fmt.Println("main init")
}
func main() {
    fmt.Println("main function")
}

pkgA/a.go内容如下：

package pkgA
import "fmt"
var aVar = 20
func init() {
    fmt.Println("pkgA init")
}

pkgB/b.go内容如下：

package pkgB
import "fmt"
var bVar = 30
func init() {
    fmt.Println("pkgB init")
}

假设main.go中导入了pkgA和pkgB，那么初始化顺序如下：

初始化pkgA包中的aVar。执行pkgA包中的init函数。初始化pkgB包中的bVar。执行pkgB包中的init函数。初始化main包中的mainVar。执行main包中的init函数。调用main函数。

输出结果可能是：

pkgA init
pkgB init
main init
main function