Go语言init函数的执行顺序与多个init函数的情况

Go语言init函数的执行顺序与多个init函数的情况

Go 语言中的 init 函数是一种特殊的函数，它用于在程序执行前进行包级别的初始化操作。理解 init 函数的执行顺序，特别是当存在多个文件和多个包时的调用逻辑，是掌握 Go 程序生命周期的关键。

1. 单个文件内的多个 init 函数

在同一个 .go 源文件中，可以定义多个 init 函数。Go 编译器保证这些函数会按照它们在代码中出现的先后顺序依次执行。

执行规则：
从上到下依次执行。

代码示例：

package main

import "fmt"

func init() {
    fmt.Println("第一个 init 函数")
}

func init() {
    fmt.Println("第二个 init 函数")
}

func main() {
    fmt.Println("主函数执行")
}

预期输出：

第一个 init 函数
第二个 init 函数
主函数执行

2. 同一个包内多个文件的 init 函数

当一个包包含多个 .go 源文件时，每个文件中可能都包含 init 函数。虽然 Go 语言规范没有严格规定文件之间的执行顺序，但在标准的 Go 编译器（gc）实现中，通常按照文件名的字典序（字母顺序）来处理。

执行规则：
通常按照文件名字母顺序执行各文件内的 init 函数。

操作步骤：

1. 创建两个文件 a.go 和 b.go 在同一个包（例如 main）中。

2. 在 a.go 中 写入以下代码：

   package main
   
   import "fmt"
   
   func init() {
       fmt.Println("来自 a.go 的 init")
   }

3. 在 b.go 中 写入以下代码：

   package main
   
   import "fmt"
   
   func init() {
       fmt.Println("来自 b.go 的 init")
   }

4. 运行程序 go run .。

预期输出：

来自 a.go 的 init
来自 b.go 的 init

3. 多个包之间的 init 函数执行顺序

在 Go 语言中，包之间存在导入依赖关系。init 函数的执行顺序严格遵循依赖关系的深度优先遍历原则。

执行规则：

1. 被依赖的包先初始化。
2. 同级包按导入顺序或字母顺序初始化。
3. 最后初始化 main 包。

逻辑流程图：

假设有如下依赖关系：main 包导入 pkg_b，pkg_b 导入 pkg_a。

执行顺序：pkg_a init -> pkg_b init -> main init。

4. 实操演练：构建多级依赖并观察顺序

通过构建一个包含三个包的项目，通过控制台输出直观地验证 init 的执行顺序。

第一步：初始化项目结构

1. 创建一个名为 init-test 的文件夹。

2. 打开终端，进入该目录。

3. 执行命令初始化 Go 模块：

   go mod init example.com/init-test

第二步：创建被依赖的底层包 (package_a)

1. 创建文件夹 package_a。

2. 在该文件夹下 创建文件 pack.go。

3. 写入如下代码：

   package package_a
   
   import "fmt"
   
   func init() {
       fmt.Println("[1] Package A: 初始化")
   }
   
   func ShowA() {
       fmt.Println("Package A: 函数调用")
   }

第三步：创建中间层包 (package_b)

1. 创建文件夹 package_b。

2. 在该文件夹下 创建文件 pack.go。

3. 写入如下代码，确保导入 package_a：

   package package_b
   
   import (
       "example.com/init-test/package_a"
       "fmt"
   )
   
   func init() {
       fmt.Println("[2] Package B: 初始化 (依赖 A)")
       package_a.ShowA()
   }
   
   func ShowB() {
       fmt.Println("Package B: 函数调用")
   }

第四步：创建主入口 (main)

1. 在项目根目录下 创建文件 main.go。

2. 写入如下代码，确保导入 package_b（不需要直接导入 package_a）：

   package main
   
   import (
       "example.com/init-test/package_b"
       "fmt"
   )
   
   func init() {
       fmt.Println("[3] Main: 初始化")
   }
   
   func main() {
       fmt.Println("[4] Main: 开始执行")
       package_b.ShowB()
   }

第五步：运行并观察结果

1. 执行命令运行程序：

   go run .

2. 观察终端输出。输出应当严格遵循依赖链条，从最底层向上逐层初始化，最后才执行主函数。

预期输出结果：

[1] Package A: 初始化
[2] Package B: 初始化 (依赖 A)
Package A: 函数调用
[3] Main: 初始化
[4] Main: 开始执行
Package B: 函数调用

5. 特殊情况总结

在实际开发中，init 函数的执行机制遵循以下核心逻辑，需牢记于心以免产生副作用。