I've tried to find a precise explanation of what the init() function does in Go. I read what Effective Go says but I was unsure if I understood fully what it said. The exact sentence I am unsure is the following:
And finally means finally: init is called after all the variable declarations in the package have evaluated their initializers, and those are evaluated only after all the imported packages have been initialized.
What does all the variable declarations in the package have evaluated their initializers mean? Does it mean if you declare "global" variables in a package and its files, init() will not run until all of it is evaluated and then it will run all the init function and then main() when ./main_file_name is ran?
I also read Mark Summerfield's go book the following:
If a package has one or more init() functions they are automatically executed before the main package's main() function is called.
In my understanding, init() is only relevant when you intend to run main() right? Anyone understands more precisely init() feel free to correct me
11 Answers
Yes assuming you have this:
var WhatIsThe = AnswerToLife()
func AnswerToLife() int { // 1
return 42
}
func init() { // 2
WhatIsThe = 0
}
func main() { // 3
if WhatIsThe == 0 {
fmt.Println("It's all a lie.")
}
}
AnswerToLife() is guaranteed to run before init() is called, and init() is guaranteed to run before main() is called.
Keep in mind that init() is always called, regardless if there's main or not, so if you import a package that has an init function, it will be executed.
Additionally, you can have multiple init() functions per package; they will be executed in the order they show up in the file (after all variables are initialized of course). If they span multiple files, they will be executed in lexical file name order (as pointed out by @benc):
It seems that
init()functions are executed in lexical file name order. The Go spec says "build systems are encouraged to present multiple files belonging to the same package in lexical file name order to a compiler". It seems thatgo buildworks this way.
A lot of the internal Go packages use init() to initialize tables and such, for example
See this picture. :)
import --> const --> var --> init()
If a package imports other packages, the imported packages are initialized first.
Current package's constant initialized then.
Current package's variables are initialized then.
Finally,
init()function of current package is called.
A package can have multiple init functions (either in a single file or distributed across multiple files) and they are called in the order in which they are presented to the compiler.
A package will be initialised only once even if it is imported from multiple packages.
Something to add to this (which I would've added as a comment but the time of writing this post I'd not yet enough reputation)
Having multiple inits in the same package I've not yet found any guaranteed way to know what order in which they will be run. For example I have:
package config
- config.go
- router.go
Both config.go and router.go contain init() functions, but when running router.go's function ran first (which caused my app to panic).
If you're in a situation where you have multiple files, each with its own init() function be very aware that you aren't guaranteed to get one before the other. It is better to use a variable assignment as OneToOne shows in his example. Best part is: This variable declaration will happen before ALL init() functions in the package.
For example
config.go:
var ConfigSuccess = configureApplication()
func init() {
doSomething()
}
func configureApplication() bool {
l4g.Info("Configuring application...")
if valid := loadCommandLineFlags(); !valid {
l4g.Critical("Failed to load Command Line Flags")
return false
}
return true
}
router.go:
func init() {
var (
rwd string
tmp string
ok bool
)
if metapath, ok := Config["fs"]["metapath"].(string); ok {
var err error
Conn, err = services.NewConnection(metapath + "/metadata.db")
if err != nil {
panic(err)
}
}
}
regardless of whether var ConfigSuccess = configureApplication() exists in router.go or config.go, it will be run before EITHER init() is run.
Here is another example -
package main
import (
"fmt"
)
func callOut() int {
fmt.Println("Outside is beinge executed")
return 1
}
var test = callOut()
func init() {
fmt.Println("Init3 is being executed")
}
func init() {
fmt.Println("Init is being executed")
}
func init() {
fmt.Println("Init2 is being executed")
}
func main() {
fmt.Println("Do your thing !")
}
Output of the above program
$ go run init/init.go
Outside is being executed
Init3 is being executed
Init is being executed
Init2 is being executed
Do your thing !
When is the
init()function run?
With Go 1.16 (Q1 2021), you will see precisely when it runs, and for how long.
See commit 7c58ef7 from CL (Change List) 254659, fixing issue 41378 .
