Master Go's Initialization: Variable, init, and main Execution Order

Before discussing Go's program initialization, it is essential to grasp the execution order and the effect of importing third‑party libraries for writing efficient and maintainable Go code. The initialization process includes package‑level variable initialization, init function calls, and finally the main function execution.

Basic Order of Go Initialization

Package‑level variable initialization : Go initializes package‑level variables before program execution, respecting dependency relationships so that a variable depended on by another is initialized first.

init function calls : After all package variables are set, Go calls each package's init functions in the order they are compiled. Imported packages have their init functions executed before the importing package. A package may contain multiple init functions, and their order within the same package is undefined.

main function execution : Finally, the program starts executing the main function in the main package, which is the entry point.

Impact of Importing Third‑Party Libraries

When a third‑party library is imported, its initialization (variables and init functions) runs before the current package's initialization. This means any global state in the library is set up before the current package's code runs, which is crucial for understanding execution order and debugging.

Why Understanding Initialization Matters

Avoid circular dependencies : Knowing the order helps prevent circular import issues.

Ensure correct initialization sequence : Critical for global variables and singleton patterns to maintain program stability.

Optimize startup time : Streamlining init code can reduce launch time, especially in fast‑startup scenarios.

Example Illustration

The following example demonstrates package‑level variable initialization, init function calls, and main function execution using two packages: lib and main.

lib package

package lib

import "fmt"

var (
    // Package‑level variable initialization
    LibraryName = "Go Library"
)

func init() {
    // init function
    fmt.Println("lib package init:", LibraryName)
}

func PrintLibName() {
    fmt.Println("Library name:", LibraryName)
}

main package

package main

import (
    "fmt"
    "github.com/xilu0/uml/lib" // import custom lib package
)

var (
    // Package‑level variable initialization
    appName = "Go Application"
)

func init() {
    // init function
    fmt.Println("main package init:", appName)
}

func main() {
    fmt.Println("main function execution")
    lib.PrintLibName()
}

Initialization Process Analysis

Package‑level variable initialization :

The lib package initializes LibraryName to "Go Library".

The main package then initializes appName to "Go Application".

init function calls :

Because main depends on lib, the lib init runs first, printing "lib package init: Go Library".

Next, the main init runs, printing "main package init: Go Application".

main function execution :

The main function runs, printing "main function execution".

It then calls lib.PrintLibName(), which outputs "Library name: Go Library".

This example shows the deterministic order of Go's initialization: first package variables, then init functions respecting dependencies, and finally the main function. Understanding this flow is vital for writing efficient, reliable Go programs, ensuring clear and predictable initialization logic.

Conclusion

Go's initialization design guarantees a predictable and stable program start. Deep comprehension of this process is crucial for developing efficient, maintainable Go code. While init functions can modularize setup, they should be used judiciously to avoid tangled initialization logic that is hard to trace.