1.init 函數(shù)簡介

Golang init 函數(shù)是一種特殊的函數(shù)，主要用于完成程序的初始化工作，如初始化數(shù)據(jù)庫的連接、載入本地配置文件、根據(jù)命令行參數(shù)初始化全局變量等。

package main

import "flag"

var gopath string

func init() {
	println("init a")
}

func init() {
	println("init b")
}

func init() {
	println("init c")
	// gopath may be overridden by --gopath flag on command line.
	flag.StringVar(&gopath, "gopath", "/root/go", "override default GOPATH")
}

func main() {
	println("main")
	flag.Parse()
	println(gopath)
}

運行輸出：

$ go run main.go --gopath="/home/alice/go"
init a
init b
init c
main
/home/alice/go

之所以特殊，是因為 init 函數(shù)有如下特點：

• init 函數(shù)是可選的，可以沒有；
• 與 main 函數(shù)一樣，不能有入?yún)⑴c返回值；
• 與 main 函數(shù)一樣，init 會自動執(zhí)行，不能被其他函數(shù)調(diào)用；
• 一個包內(nèi)可以有多個 init 函數(shù)，即可以在包的多個源文件中定義多個 init 函數(shù)。一般建議在與包同名源文件中寫一個 init 函數(shù)，這樣可讀性好且便于維護(hù)；
• 一個源文件可以有多個 init 函數(shù)。

2.執(zhí)行順序

既然一個程序可以有多個 init 函數(shù)，那么對于位于不同包、不同源文件中的多個 init 函數(shù)，其執(zhí)行順序是怎樣的呢？

下面從多個方面去考察。

2.1 單個源文件的 init 執(zhí)行順序

package main

func init() {
	println("init a")
}

func init() {
	println("init b")
}

func init() {
	println("init c")
}

func main() {
	println("main")
}

運行輸出：

$ go run main.go
init a
init b
init c
main

結(jié)論： 同一個源文件的 init 函數(shù)執(zhí)行順序與其定義順序一致，從上到下。

2.2 單個包的 init 執(zhí)行順序

假設(shè) main 包有三個源文件 a.go，b.go 和 c.go。

// a.go
package main

func init() {
	println("init a")
}

// b.go
package main

func init() {
	println("init b")
}

// c.go
package main

func init() {
	println("init c")
}

// main.go
package main

func init() {
	println("init main")
}

func main() {
	println("main")
}

編譯運行輸出：

$ go build && ./main
init a
init b
init c
init main
main

結(jié)論： 同一個包中不同源文件 init 函數(shù)的執(zhí)行順序，是根據(jù)文件名的字典序來確定。

2.3 main 包導(dǎo)入多個包時 init 執(zhí)行順序

2.3.1 不存在依賴

對于不同的包，如果不相互依賴的話，在 main 包中被 import，那么這種情況下，各個包的 init 執(zhí)行順序是怎樣的呢？

假設(shè)有包 a，b 和 c，在 main.go 中被 import。

// a 包
// a.go
package a

func init() {
	println("init a")
}

// b 包
// b.go
package b

func init() {
	println("init b")
}

// c 包
// c.go
package c

func init() {
	println("init c")
}

// main 包
// main.go
package main

import (
	_ "main/a"
	_ "main/b"
	_ "main/c"
)

func init() {
	println("init main")
}

func main() {
	println("main")
}

編譯運行輸出：

$ go build && ./main
init a
init b
init c
init main
main

結(jié)論： 對于不同的包，如果不相互依賴的話，按照 main 包中導(dǎo)入順序調(diào)用包的 init 函數(shù)，最后再調(diào)用 main 包的 init 函數(shù)。

2.3.2 存在依賴

對于不同的包，如果存在依賴關(guān)系的話，在 main 包中被 import，那么這種情況下，各個包的 init 執(zhí)行順序是怎樣的呢？

假設(shè)有包 a，b 和 c，main 包 import a 包，a import b，b import c，即依賴關(guān)系為 main > a > b > c。

// a 包
// a.go
package a

import _ "main/b"

func init() {
	println("init a")
}

// b 包
// b.go
package b

import _ "main/c"

func init() {
	println("init b")
}

// c 包
// c.go
package c

func init() {
	println("init c")
}

// main 包
// main.go
package main

import (
	_ "main/a"
)

func init() {
	println("init main")
}

func main() {
	println("main")
}

編譯運行輸出：

$ go build && ./main
init c
init b
init a
init main
main

結(jié)論: 如果 package 存在依賴，不同包的 init 函數(shù)按照包導(dǎo)入的依賴關(guān)系決定執(zhí)行順序。 調(diào)用順序為最后被依賴的最先被初始化，如導(dǎo)入順序 main > a > b > c，則初始化順序為 c > b > a > main，依次執(zhí)行對應(yīng)的 init 方法。

2.4 包級變量初始化與 init 函數(shù)執(zhí)行順序

如果包中存在包級變量，那么其初始化與 init 函數(shù)執(zhí)行先后順序如何呢？

還是假設(shè)有包 a，b 和 c，main 包 import a 包，a import b，b import c，即依賴關(guān)系為 main > a > b > c。且每個包都有一個包級變量，并通過函數(shù)完成其初始化。

// a 包
// a.go
package a

import _ "main/b"

var A = func() string {
	println("init var A")
	return "A"
}()

func init() {
	println("init a")
}

// b 包
// b.go
package b

import _ "main/c"

var B = func() string {
	println("init var B")
	return "B"
}()

func init() {
	println("init b")
}

// c 包
// c.go
package c

var C = func() string {
	println("init var C")
	return "C"
}()

func init() {
	println("init c")
}

// main 包
// main.go
package main

import (
	_ "main/a"
)

var m = func() string {
	println("init var m")
	return "m"
}()

func init() {
	println("init main")
}

func main() {
	println("main")
}

編譯運行輸出：

$ go build && ./main
init var C
init c
init var B
init b
init var A
init a
init var m
init main
main

結(jié)論: 可見每個包的包級變量初始化是在 init 函數(shù)執(zhí)行之前完成的。不同包的 init 函數(shù)與包級變量的初始化順序如下圖所示。

3.小結(jié)

Golang 中的 init 是一種特殊的函數(shù)，主要用于完成程序的初始化工作。其特點有：

• init 函數(shù)是可選的，可以沒有；
• 與 main 函數(shù)一樣，不能有入?yún)⑴c返回值；
• 與 main 函數(shù)一樣，init 會自動執(zhí)行，不能被其他函數(shù)調(diào)用；
• 一個包內(nèi)可以有多個 init 函數(shù)，即可以在包的多個源文件中定義多個 init 函數(shù)。一般建議在與包同名源文件中寫一個 init 函數(shù)，這樣可讀性好且便于維護(hù)；
• 一個源文件可以有多個 init 函數(shù)。

程序中如果在不同包的不同源文件有多個 init 函數(shù)時，其執(zhí)行順序可概述為：

• 同一個源文件的 init 函數(shù)執(zhí)行順序與其定義順序一致，從上到下；
• 同一個包中不同文件的 init 函數(shù)的執(zhí)行順序按照文件名的字典序；
• 對于不同的包，如果不相互依賴的話，按照 main 包中 import 的順序調(diào)用其包中的 init 函數(shù)；
• 如果包存在依賴，不同包的 init 函數(shù)按照包導(dǎo)入的依賴關(guān)系決定執(zhí)行順序。 調(diào)用順序為最后被依賴的最先被初始化，如導(dǎo)入順序 main > a > b > c，則初始化順序為 c > b > a > main，依次執(zhí)行對應(yīng)的 init 方法；
• 如果包存在包級變量，則先于包的 init 函數(shù)完成初始化。

程序的初始化和執(zhí)行都起始于 main 包。如果 main 包還導(dǎo)入了其它的包，那么就會在編譯時將它們依次導(dǎo)入。有時一個包會被多個包同時導(dǎo)入，那么它只會被導(dǎo)入一次（例如很多包可能都會用到 fmt 包，但它只會被導(dǎo)入一次，因為沒有必要導(dǎo)入多次）。

當(dāng)一個包被導(dǎo)入時，如果該包還導(dǎo)入了其它的包，那么會先將其它包導(dǎo)入進(jìn)來，然后再對這些包中的包級常量和變量進(jìn)行初始化，接著執(zhí)行 init 函數(shù)，依次類推。

請務(wù)必銘記于心，雖然 init() 順序是明確的，但代碼可以更改，init() 函數(shù)之間的關(guān)系可能會使代碼變得脆弱和容易出錯，因此在編碼時避免依賴 init() 函數(shù)的執(zhí)行順序。

參考文獻(xiàn)

• Package initialization - The Go Programming Language Specification
• Initialization - Effective Go
• 徹底搞懂下golang的init函數(shù) - 嗶哩嗶哩

總結(jié) 

到此這篇關(guān)于一篇文章讀懂Golang init函數(shù)執(zhí)行順序的文章就介紹到這了,更多相關(guān)Golang init函數(shù)執(zhí)行順序內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論