依次見例子代碼：

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 這樣的注釋， 數(shù)值從小到大，小的先初始化，依次進行.

總結(jié)：

在一個go文件中， 初始化順序規(guī)則： (1)引入的包 (2) 當前包中的變量常量 (3) 當前包的init （4）main函數(shù)

注意：

0. 當前go源文件中， 每一個被Import的包， 按其在源文件中出現(xiàn)順序初始化。

1. 如果當前包有多個init在不同的源文件中， 則按源文件名以字典序從小到大排序，小的先被執(zhí)行到， 同一包且同一源文件中的init,則按其出現(xiàn)在文件中的先后順序依次初始化； 當前包的package level變量常量也遵循這個規(guī)則； 其實準確來說，應是按提交給編譯器的源文件名順序為準，只是在提交編譯器之前， go命令行工具對源文件名按字典序排序了。

2. init只可以由go runtine自已調(diào)用， 我們在代碼中不可以顯示調(diào)用，也不可以被引用，如賦給a function variable。

3. 包A 引入包B , 包B又引入包C, 則包的初始化順序為： C -> B -> A

4. 引入包，必須避免死循環(huán)，如 A 引 B , B引C, C引A.

5. 一個包被其它多個包引入，如A -> B ->C 和 H -> I -> C , C被其它包引了2次， 但是注意包C只被初始化一次。

6. 另一個大原則， 被依賴的總是先被初始化，當然呀。

7. main包總是被最后一個初始化，這很好理解，因為它總是依賴別的包。

補充：golang入門-- import包與包內(nèi)init方法的執(zhí)行時機

最近在學習revel(golang web開發(fā)框架) ,了解到revel管理和加載所有controller的方式。其中涉及的golang基礎知識是import包。下面我們先來看看golang imort包的幾種方法和特征：

第一種方式相對路徑

import "./module" //當前文件同一目錄的module目錄， 此方式?jīng)]什么用容易出錯/span>

第二種方式絕對路徑

import “LearnGo/init” //加載gopath/src/LearnGo/init模塊

下面展示一些特殊的import方式

1.點操作

我們有時候會看到如下的方式導入包

import( . “fmt” )

這個點操作的含義就是這個包導入之后在你調(diào)用這個包的函數(shù)時，你可以省略前綴的包名，也就是前面你調(diào)用的fmt.Println("hello world")可以省略的寫成Println("hello world")

2.別名操作

別名操作顧名思義我們可以把包命名成另一個我們用起來容易記憶的名字，revel框架的app/controllers/tmp/main.go(框架的啟動入口)里可以看到此方式的應用。

import(
 f "fmt"
)

別名操作的話調(diào)用包函數(shù)時前綴變成了我們的前綴，即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"
)

3._操作

這個操作經(jīng)常是讓很多人費解的一個操作符，請看下面這個import

import (//revel框架的代碼片段
 _ "github.com/revel/modules/testrunner/app"
 _ "guild_website/app"
)

_操作其實是引入該包，而不直接使用包里面的函數(shù)，而是調(diào)用了該包里面的init函數(shù)，要理解這個問題，需要看下面這個圖，理解包是怎么按照順序加載的：

程序的初始化和執(zhí)行都起始于main包。如果main包還導入了其它的包，那么就會在編譯時將它們依次導入。

有時一個包會被多個包同時導入，那么它 只會被導入一次（例如很多包可能都會用到fmt包，但它只會被導入一次，因為沒有必要導入多次）。當一個包被導入時，如果該包還導入了其它的包，那么會先 將其它包導入進來，然后再對這些包中的包級常量和變量進行初始

化，接著執(zhí)行init函數(shù)（如果有的話），依次類推。等所有被導入的包都加載完畢了，就會開 始對main包中的包級常量和變量進行初始化，然后執(zhí)行main包中的init函數(shù)（如果存在的話），最后執(zhí)行main函數(shù)。

此外需了解別名操作方式導入包也會執(zhí)行init函數(shù)。

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。