依次见例子代码：
p1.go
- package p1
- import "fmt" //1.1
- var x float32 = 1.2 //1.2
- func init() { //1.3
- fmt.Printf("p1 package, x:%f\n", x) //1.4
- }
- func Donothing() {
- fmt.Println("do nothing.\n")
- }
a.go:
- package main
- import "fmt"
- var WhatIsThe1 = AnswerToLife(2.1) //2.1
- var WhatIsThe2 = AnswerToLife(2.2) //2.2
- var WhatIsThe3 = AnswerToLife(2.3) //2.3
- func init() { //3.1
- fmt.Printf("init WhatIsThe in a.go `s init 3.1: %d\n", 2)
- }
- func init() { //3.2
- fmt.Printf("init WhatIsThe in a.go`s init 3.2: %d\n", 3)
- }
testinit.go
- package main
- import "p1" //1
- import "fmt"
- var WhatIsThe4 = AnswerToLife(2.4) //2.4
- var WhatIsThe5 = AnswerToLife(2.5) //2.5
- var WhatIsThe6 = AnswerToLife(2.6) //2.6
- func AnswerToLife(index float32) float32 {
- fmt.Printf("init package level variable, WhatIsThe: %f\n", index)
- return index
- }
- func init() { //3.3
- fmt.Printf("init WhatIsThe in testinit.go`s init3.3: %d\n", 0)
- }
- func init() { //3.4
- fmt.Printf("init WhatIsThe in testinit.go`s init3.4: %d\n", 1)
- }
- func main() { //4
- p1.Donothing() //5
- }
z.go
- package main
- import "fmt"
- var WhatIsThe7 = AnswerToLife(2.7) //2.7
- var WhatIsThe8 = AnswerToLife(2.8) //2.8
- var WhatIsThe9 = AnswerToLife(2.9) //2.9
- func init() { //3.5
- fmt.Printf("init WhatIsThe in z.go`s init 3.5: %d\n", 4)
- }
- func init() { //3.6
- fmt.Printf("init WhatIsThe in z.go`s init 3.6: %d\n", 5)
- }
代码文件贴出的顺序就是各大块之间的初始化顺序， 具体准确顺序请看，形如//1 , //2.1 这样的注释， 数值从小到大，小的先初始化，依次进行.
总结：
在一个go文件中， 初始化顺序规则： (1)引入的包 (2) 当前包中的变量常量 (3) 当前包的init （4）main函数
注意：
0. 当前go源文件中， 每一个被Import的包， 按其在源文件中出现顺序初始化。
1. 如果当前包有多个init在不同的源文件中， 则按源文件名以字典序从小到大排序，小的先被执行到， 同一包且同一源文件中的init,则按其出现在文件中的先后顺序依次初始化； 当前包的package level变量常量也遵循这个规则； 其实准确来说，应是按提交给编译器的源文件名顺序为准，只是在提交编译器之前， go命令行工具对源文件名按字典序排序了。
2. init只可以由go runtine自已调用， 我们在代码中不可以显示调用，也不可以被引用，如赋给a function variable。
3. 包A 引入包B , 包B又引入包C, 则包的初始化顺序为： C -> B -> A
4. 引入包，必须避免死循环，如 A 引 B , B引C, C引A.
5. 一个包被其它多个包引入，如A -> B ->C 和 H -> I -> C , C被其它包引了2次， 但是注意包C只被初始化一次。
6. 另一个大原则， 被依赖的总是先被初始化，当然呀。
7. main包总是被最后一个初始化，这很好理解，因为它总是依赖别的包。
补充：golang入门-- import包与包内init方法的执行时机
最近在学习revel(golang web开发框架) ,了解到revel管理和加载所有controller的方式。其中涉及的golang基础知识是import包。下面我们先来看看golang imort包的几种方法和特征：
第一种方式相对路径
- import "./module" //当前文件同一目录的module目录， 此方式没什么用容易出错</span>
第二种方式绝对路径
- import “LearnGo/init” //加载gopath/src/LearnGo/init模块
我们有时候会看到如下的方式导入包
这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名，也就是前面你调用的fmt.Println("hello world")可以省略的写成Println("hello world")
2.别名操作
别名操作顾名思义我们可以把包命名成另一个我们用起来容易记忆的名字，revel框架的app/controllers/tmp/main.go(框架的启动入口)里可以看到此方式的应用。
别名操作的话调用包函数时前缀变成了我们的前缀，即f.Println("hello world")。
- import (//revel框架的代码片段
- "flag"
- "reflect"
- "github.com/revel/revel"
- controllers0 "github.com/revel/modules/static/app/controllers"
- _ "github.com/revel/modules/testrunner/app"
- controllers1 "github.com/revel/modules/testrunner/app/controllers"
- _ "guild_website/app"
- controllers "guild_website/app/controllers"
- tests "guild_website/tests"
- "github.com/revel/revel/testing"
- )
这个操作经常是让很多人费解的一个操作符，请看下面这个import
- import (//revel框架的代码片段
- _ "github.com/revel/modules/testrunner/app"
- _ "guild_website/app"
- )
_操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数，要理解这个问题，需要看下面这个图，理解包是怎么按照顺序加载的：
程序的初始化和执行都起始于main包。如果main包还导入了其它的包，那么就会在编译时将它们依次导入。
有时一个包会被多个包同时导入，那么它 只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。当一个包被导入时，如果该包还导入了其它的包，那么会先 将其它包导入进来，然后再对这些包中的包级常量和变量进行初始
化，接着执行init函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开 始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。
此外需了解别名操作方式导入包也会执行init函数。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持晓枫资讯。如有错误或未考虑完全的地方，望不吝赐教。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
发表于 2024-4-1 20:48:03
