1. 引言

在Go語言中，init()函式是一種特殊的函式，用于在程式啟動時自動執行一次，它的存在為我們提供了一種機制，可以在程式啟動時進行一些必要的初始化操作，為程式的正常運行做好準備，

在這篇文章中，我們將詳細探討init()函式的特點、用途和注意事項，希望能幫助你更好地理解和使用這個重要的Go語言特性，

2. init 函式的特點

2.1 自動執行

init()函式的一個重要特點，便是其無需手動呼叫，它會在程式啟動時自動執行，當程式開始運行時，Go運行時系統會自動呼叫每個包中的init()函式，下面是一個示例代碼，演示了init()函式在程式啟動時自動執行的特點：

package main

import "fmt"

func init() {
    fmt.Println("Init function executed")
}

func main() {
    fmt.Println("Main function executed")
}

在這個示例代碼中，我們定義了一個init()函式和一個main()函式，init()函式會在程式啟動時自動執行，而main()函式則是程式的入口函式，會在init()函式執行完畢后執行，

當我們運行這段代碼時，輸出結果如下：

Init function executed
Main function executed

可以看到，init()函式在程式啟動時自動執行，并且在main()函式之前被呼叫，這證明了init()函式在程式啟動時會自動執行，可以用于在程式啟動前進行一些必要的初始化操作，

2.2 在包級別變數初始化后執行

當一個包被引入或使用時，其中會先初始化包級別常量和變數，然后，按照init()函式在代碼中的宣告順序，其會被自動執行，下面是一個簡單代碼的說明:

package main

import "fmt"

var (
        Var1 = "Variable 1"
        Var2 = "Variable 2"
)

func init() {
        fmt.Println("Init function executed")
        fmt.Println("Var1:", Var1)
        fmt.Println("Var2:", Var2)
}

func main() {
        fmt.Println("Main function executed")
}

在這個示例代碼中，我們宣告了包級別的常量，并在init()函式中列印它們的值，在main()函式中，我們列印了一條資訊，當我們運行這段代碼時，輸出結果如下：

Init function executed
Var1: Variable 1
Var2: Variable 2
Main function executed

可以看到，init()函式在包的初始化階段被自動執行，并且在包級別常量和變數被初始化之后執行，這驗證了init()函式的執行順序，因為包級別常量和變數的初始化是在init()函式執行之前進行的，因此，在init()函式中可以安全地使用這些常量和變數，

2.3 執行順序不確定

在一個包中，如果存在多個init()函式，它們的執行順序是按照在代碼中出現的順序確定的，先出現的init()函式會先執行，后出現的init()函式會后執行，

具體來說，按照代碼中的順序定義了init()函式的先后順序，如果在同一個源檔案中定義了多個init()函式，它們的順序將按照在源代碼中的出現順序來執行，下面通過一個示例代碼來說明：

package main

import "fmt"

func init() {
        fmt.Println("First init function")
}

func init() {
        fmt.Println("Second init function")
}

func main() {
        fmt.Println("Main function executed")
}

在這個示例中，我們在同一個包中定義了兩個init()函式，它們按照在源代碼中的出現順序進行執行，當我們運行這段代碼時，輸出結果為：

First init function
Second init function
Main function executed

可以看到，先出現的init()函式先執行，后出現的init()函式后執行，

但是重點在于，如果多個init()函式分別位于不同的源檔案中，它們之間的執行順序是不確定的，這是因為編譯器在編譯時可能會以不同的順序處理這些源檔案，從而導致init()函式的執行順序不確定，

總結起來，同一個源檔案中定義的多個init()函式會按照在代碼中的出現順序執行，但多個源檔案中的init()函式執行順序是不確定的，

3. init 函式的用途

3.1 初始化全域變數

在大多數情況下，我們可以直接在定義全域變數或常量時賦初值，而不需要使用 init() 函式來進行初始化，直接在定義時賦值的方式更為簡潔和直觀，

然而，有時候我們可能需要更復雜的邏輯來初始化全域變數或常量，這些邏輯可能需要運行時計算、讀取組態檔、進行網路請求等操作，無法在定義時直接賦值，在這種情況下，我們可以使用 init() 函式來實作這些復雜的初始化邏輯，

讓我們通過一個示例來說明這種情況，假設我們有一個全域變數 Config 用于存盤應用程式的配置資訊，我們希望在程式啟動時從組態檔中讀取配置并進行初始化，這時就可以使用 init() 函式來實作：

package main

import (
        "fmt"
        "os"
)

var Config map[string]string

func init() {
        Config = loadConfig()
}

func loadConfig() map[string]string {
        // 從組態檔中讀取配置資訊的邏輯
        // 這里只是一個示例，實際中可能涉及更復雜的操作
        config := make(map[string]string)
        config["key1"] = "value1"
        config["key2"] = "value2"
        return config
}

func main() {
        fmt.Println("Config:", Config)
        // 其他業務邏輯...
}

在這個示例中，我們定義了一個全域變數 Config，并在 init() 函式中呼叫 loadConfig() 函式來讀取組態檔并進行初始化，在 loadConfig() 函式中，我們模擬了從組態檔中讀取配置資訊的邏輯，并回傳一個配置的 map，

當程式啟動時，init() 函式會被自動呼叫，執行初始化邏輯并將讀取到的配置資訊賦值給全域變數 Config，這樣，在應用程式的其他地方可以直接使用 Config 來獲取配置資訊，

使用 init() 函式來初始化全域變數或常量的好處是，可以在包初始化階段確保它們被正確初始化，并且可以執行一些復雜的邏輯，例如從檔案中讀取配置、初始化資料庫連接等，

3.2 執行一些必要的驗證操作

init() 函式也通常用于執行一些檢查操作，以確保程式在運行之前滿足特定的條件或要求，這些檢查操作的目的是確保程式在正式運行之前滿足特定的條件，從而避免出現潛在的問題或錯誤，下面是一個簡單的示例，說明了使用 init() 函式執行檢查操作的必要性：

package main

import (
        "fmt"
        "os"
)

var config *Config

func init() {
        err := loadConfig()
        if err != nil {
                fmt.Println("Failed to load configuration:", err)
                os.Exit(1)
        }

        err = validateConfig()
        if err != nil {
                fmt.Println("Invalid configuration:", err)
                os.Exit(1)
        }
}

func loadConfig() error {
        // 從組態檔或環境變數中加載配置資訊，并初始化 config 物件
        // ...
        return nil
}

func validateConfig() error {
        // 驗證配置是否滿足特定的要求或約束
        // ...
        return nil
}

func main() {
        // 在這里可以進行其他操作，前提是配置已經加載并且是有效的
        // ...
}

在這個示例中，我們假設程式需要加載配置資訊，并對配置進行驗證，在 init() 函式中，我們通過呼叫 loadConfig() 函式加載配置資訊，并呼叫 validateConfig() 函式對配置進行驗證，

如果配置加載或驗證程序中出現錯誤，我們可以輸出錯誤資訊，并使用 os.Exit() 函式終止程式的運行，這樣可以避免在不滿足條件或不正確的配置下運行程式，從而減少可能的問題或錯誤，

通過使用 init() 函式執行檢查操作可以確保程式在正式運行之前滿足特定的條件，并提前處理錯誤情況，從而增加程式的可靠性和可維護性，這樣可以減少在運行時出現問題的可能性，并提高代碼的可讀性和可維護性，

4. init 函式的注意事項

4.1 init 函式不能被顯式呼叫

當我們定義一個 init() 函式時，它會在程式啟動時自動執行，而無法被顯式呼叫，下面通過一個示例代碼來簡單說明：

package main

import "fmt"

func init() {
        fmt.Println("This is the init() function.")
}

func main() {
        fmt.Println("This is the main() function.")

        // 無法顯式呼叫 init() 函式
        // init() // 這行代碼會導致編譯錯誤
}

在這個示例中，我們定義了一個 init() 函式，并在其中列印一條訊息，然后，在 main() 函式中列印另一條訊息，在 main() 函式中，我們嘗試顯式呼叫 init() 函式，但是會導致編譯錯誤，這是因為 init() 函式是在程式啟動時自動呼叫的，無法在代碼中進行顯式呼叫，

如果我們嘗試去呼叫 init() 函式，編譯器會報錯，提示 undefined: init，因為它不是一個可呼叫的函式，它的執行是由編譯器在程式啟動時自動觸發的，無法通過函式呼叫來控制，

4.2 init 函式只執行一次

init() 函式在應用程式運行期間只會執行一次，它在程式啟動時被呼叫，并且僅被呼叫一次，當一個包被匯入時，其中定義的 init() 函式會被自動執行，

同時，即使同一個包被匯入了多次，其中的 init() 函式也只會被執行一次，這是因為 Go 編譯器和運行時系統會確保在整個應用程式中只執行一次每個包的 init() 函式，下面通過一個代碼來進行說明:

首先，我們創建一個名為util的包，其中包含一個全域變數counter和一個init()函式，它會將counter的值增加1，

// util.go
package util

import "fmt"

var counter int

func init() {
        counter++
        fmt.Println("init() function in util package executed. Counter:", counter)
}

func GetCounter() int {
        return counter
}

接下來，我們創建兩個獨立的包，分別為package1和package2，這兩個包都會同時匯入util包，

// package1.go
package package1

import (
        "fmt"
        "util"
)

func init() {
        fmt.Println("init() function in package1 executed. Counter:", util.GetCounter())
}

// package2.go
package package2

import (
        "fmt"
        "util"
)

func init() {
        fmt.Println("init() function in package2 executed. Counter:", util.GetCounter())
}

最后，我們創建一個名為main.go的程式，匯入package1和package2，

// main.go
package main

import (
        "fmt"
        "package1"
        "package2"
)

func main() {
        fmt.Println("Main function")
}

運行上述程式，我們可以得到以下輸出：

init() function in util package executed. Counter: 1
init() function in package1 executed. Counter: 1
init() function in package2 executed. Counter: 1
Main function

從輸出可以看出，util包中的init()函式只會執行一次，并且在package1和package2的init()函式中都能獲取到相同的計數器值，這表明，當多個包同時匯入另一個包時，該包中的init()函式只會被執行一次，

4.3 避免在 init 函式中執行耗時操作

當在 init() 函式中執行耗時操作時，會影回應用程式的啟動時間，這是因為 init() 函式在程式啟動時自動呼叫，而且在其他代碼執行之前執行，如果在 init() 函式中執行耗時操作，會導致應用程式啟動變慢，下面是一個例子來說明這一點：

package main

import (
        "fmt"
        "time"
)

func init() {
        fmt.Println("Executing init() function...")
        time.Sleep(3 * time.Second) // 模擬耗時操作，睡眠 3 秒鐘
        fmt.Println("Init() function execution completed.")
}

func main() {
        fmt.Println("Executing main() function...")
}

在這個例子中，我們在 init() 函式中使用 time.Sleep() 函式模擬了一個耗時操作，睡眠了 3 秒鐘，然后，在 main() 函式中輸出一條訊息，當我們運行這個程式時，會發現在啟動時會有 3 秒鐘的延遲，因為 init() 函式中的耗時操作會在程式啟動時執行，而 main() 函式會在 init() 函式執行完成后才開始執行，

通過這個例子，我們可以看到在 init() 函式中執行耗時操作會影回應用程式的啟動時間，如果有必要執行耗時操作，最好將其移至 main() 函式或其他合適的地方，在應用程式啟動后再執行，以避免啟動階段的延遲，

總之，為了保持應用程式的啟動性能，應避免在 init() 函式中執行耗時操作，盡量將其放在需要時再執行，以避免不必要的啟動延遲，

5. 總結

本文介紹了Go語言中的init()函式的特點，用途和注意事項，

在文章中，我們首先講述了init()函式的特點，包含init函式的自動執行，以及其執行時機的內容，接著詳細講解了init()函式的幾個常見用途，包括初始化全域變數以及執行一些必要的校驗操作，接著我們提到了init()函式的一些注意事項，如init函式不能被顯式呼叫等，

基于以上內容，完成了對init()函式的介紹，希望能幫助你更好地理解和使用這個重要的Go語言特性，

標籤：其他

上一篇：【技識訓累】SpringBoot中的簡介與配置【一】

下一篇：返回列表