Golang中init函数在main函数之前自动执行，用于完成包的初始化工作。执行顺序为：先初始化包级别变量，再按文件名排序及声明顺序执行init函数，遵循依赖包优先的原则，最后运行main函数。多个init函数可存在于同一包中，按文件名和声明顺序执行，适用于数据库连接、配置加载、服务注册等一次性初始化场景。
Golang的
init函数，它就像程序启动时的一个小秘密，总是在幕后默默完成一些准备工作。简单来说，当一个包被导入时，它的
init函数就会被Go运行时自动执行，而且这发生在
main函数运行之前，甚至在包内的任何其他代码（包括包级别的变量初始化）有机会被触及之前。它确保了你的程序在真正开始“工作”前，所有必要的环境、配置或依赖都已就绪。
解决方案
谈到
init函数的执行原理，这背后其实是Go语言一套精心设计的包初始化机制。当Go程序启动时，它会遍历所有被直接或间接导入的包。这个过程并非随机，而是遵循一个严格的拓扑排序：首先初始化那些不依赖其他包的包，然后是依赖它们的包，层层递进。一个包的初始化顺序是这样的：先是所有包级别的变量按声明顺序进行初始化，接着，如果该包有
init函数，它们会按在源文件中的出现顺序（或者说，文件名排序，然后文件内声明顺序）依次执行。整个程序中所有被导入包的
init函数都执行完毕后，才会轮到我们熟悉的
main包，最终调用
main函数。
我个人觉得，这个机制非常优雅，它把那些“一次性设置”的需求从
main函数中剥离出来，让
main函数可以更专注于程序的业务逻辑入口。想象一下，如果没有
init，我们可能需要在
main函数开头写一大堆配置加载、数据库连接、服务注册的代码，那会显得很臃肿。
init函数就是为了这些场景而生，它不接受任何参数，也没有返回值，你也不能手动调用它。它就是那个“一次性、自动执行”的幕后英雄。
package database
import (
"fmt"
"sync"
)
var (
dbConnection *string
once sync.Once
)
func init() {
// 这是一个模拟的数据库连接初始化
fmt.Println("Database package init: Establishing database connection...")
once.Do(func() {
// 实际应用中，这里会读取配置、建立连接
temp := "Connected to PostgreSQL"
dbConnection = &temp
fmt.Println("Database connection established.")
})
}
func GetDBConnection() string {
if dbConnection == nil {
return "No database connection available."
}
return *dbConnection
}当你在
main函数中导入
database包时，上面的
init函数就会自动执行，确保数据库连接在任何其他代码需要它之前就已经准备好了。
立即学习“go语言免费学习笔记（深入）”；
Golang init
函数与main
函数，以及包级别变量的初始化顺序是怎样的？
理解Go程序的启动流程，最核心的就是搞清楚这三者的执行顺序。在我看来，这就像一个层层递进的仪式。首先，Go运行时会处理包级别的变量。这些变量会按照它们在文件中声明的顺序进行初始化。如果一个包级别的变量的初始化依赖于另一个变量，那么被依赖的变量会先初始化。这是一种非常自然的顺序，符合我们阅读代码的习惯。
紧接着，当所有包级别的变量都初始化完毕后，该包内声明的
init函数便开始登场。如果一个包有多个
init函数，它们会按照在源文件中出现的顺序依次执行。这里需要注意的是，Go会先初始化所有被导入的包（也就是依赖项），然后才轮到当前包。这意味着，如果你有一个
package A导入了
package B，那么
package B的变量和
init函数会全部执行完毕，然后才轮到
package A的变量和
init函数。
最后，当所有被导入包的
init函数都执行完毕，整个程序的初始化阶段就告一段落了。这时，Go运行时才会信心满满地调用
main包里的
main函数，程序的主逻辑才真正开始运行。所以，你可以把
init函数看作是
main函数的前置守卫，为
main函数准备好一切所需。
// main.go
package main
import (
"fmt"
_ "myproject/mypackage" // 导入mypackage，但可能不直接使用其导出内容
)
var mainVar1 = initMainVar1()
var mainVar2 = "mainVar2 initialized"
func initMainVar1() string {
fmt.Println("main package: Initializing mainVar1")
return "mainVar1 initialized"
}
func init() {
fmt.Println("main package: First init function called")
}
func init() {
fmt.Println("main package: Second init function called")
}
func main() {
fmt.Println("main package: main function called")
// 假设mypackage的init已经执行，且可能设置了一些全局状态
}
// mypackage/mypackage.go
package mypackage
import "fmt"
var packageVar1 = initPackageVar1()
var packageVar2 = "packageVar2 initialized"
func initPackageVar1() string {
fmt.Println("mypackage: Initializing packageVar1")
return "packageVar1 initialized"
}
func init() {
fmt.Println("mypackage: First init function called")
}
func init() {
fmt.Println("mypackage: Second init function called")
}运行上述代码，你会看到一个清晰的输出顺序：
mypackage的变量初始化和
init函数先执行，然后才是
main包的变量初始化和
init函数，最后是
main函数。这个顺序是严格且可预测的。
在Golang中，多个init
函数如何协作？它们可以被重复定义吗？
这是个很常见的问题，尤其对于刚接触Go的开发者来说。答案是肯定的，一个包中可以有多个
init函数，它们甚至可以存在于同一个源文件里，或者分散在不同的源文件中。这其实是Go设计的一个巧妙之处，它允许开发者将不同模块的初始化逻辑分隔开来，保持代码的清晰度。
当一个包中存在多个
init函数时，它们的执行顺序是有讲究的。Go会先按照源文件的名称（通常是字母顺序）进行排序，然后对于每个源文件，
init函数会按照它们在文件中的声明顺序依次执行。这种机制意味着，如果你有特定的顺序要求，你需要确保它们在文件中的位置或文件名能够反映出这种顺序。我个人在使用时，如果一个包有多个
init，我会倾向于把它们放在不同的文件里，每个文件负责一个独立的初始化任务，这样职责更明确，也更容易管理。
然而，这种灵活性也带来了一些潜在的挑战。如果多个
init函数之间存在隐式的顺序依赖，但你没有通过文件命名或函数声明顺序来明确表达，就可能导致难以调试的问题。毕竟，
init函数是自动执行的，你不能像普通函数那样控制它们的调用时机。所以，我的建议是，尽量让每个
init函数都保持独立，或者只依赖于那些在它之前明确初始化的状态。如果实在需要复杂的顺序，可能需要重新审视设计，或者在
init中引入一些同步机制（虽然不常见）。
// mypackage/config.go
package mypackage
import "fmt"
func init() {
fmt.Println("mypackage/config.go: init for configuration loading")
// 实际中会加载配置文件
}
// mypackage/metrics.go
package mypackage
import "fmt"
func init() {
fmt.Println("mypackage/metrics.go: init for metrics setup")
// 实际中会初始化度量指标系统
}
// mypackage/logging.go
package mypackage
import "fmt"
func init() {
fmt.Println("mypackage/logging.go: init for logging setup")
// 实际中会配置日志系统
}当
main包导入
mypackage时，这些
init函数会根据文件名的字母顺序执行（例如，
config.go的
init先于
logging.go的
init，然后是
metrics.go的
init）。
Golang init
函数在实际项目中常见的应用场景有哪些？
init函数虽然看起来简单，但在实际项目中却扮演着非常关键的角色，尤其是在需要进行“一次性”设置的场景。在我看来，它就是项目启动时的“管家”，负责把一切都打理得井井有条。
-
数据库连接池或ORM框架初始化：这是最常见的场景之一。你可能需要在程序启动时就建立好数据库连接池，或者初始化你的ORM框架（如GORM、XORM），让它们随时待命。
init
函数是完成这项工作的理想场所，确保在任何业务逻辑尝试访问数据库之前，连接就已经准备就绪。// db/db.go package db import ( "database/sql" "fmt" _ "github.com/lib/pq" // 导入数据库驱动，通常驱动的init函数会注册自身 ) var globalDB *sql.DB func init() { fmt.Println("db package init: Initializing database connection pool...") // 从环境变量或配置文件加载数据库连接字符串 connStr := "user=go_user password=go_pass dbname=go_db sslmode=disable" var err error globalDB, err = sql.Open("postgres", connStr) if err != nil { panic(fmt.Sprintf("Failed to connect to database: %v", err)) } globalDB.SetMaxOpenConns(10) globalDB.SetMaxIdleConns(5) fmt.Println("db package init: Database connection pool ready.") } func GetDB() *sql.DB { return globalDB } 配置加载与解析：程序启动时往往需要读取配置文件（JSON, YAML, TOML等）或者环境变量。将这些配置加载逻辑放在
init
函数中，可以确保在任何业务代码尝试访问配置之前，所有配置项都已经被正确解析并加载到内存中。-
服务注册与插件机制：如果你正在构建一个可扩展的系统，允许通过插件或模块来扩展功能，那么
init
函数就非常有用。每个插件包可以在其init
函数中，将自己注册到一个全局的服务注册中心或工厂模式中。这样，主程序在运行时就可以动态发现并使用这些插件。// registry/registry.go package registry import "fmt" type Service interface { Run() } var services = make(map[string]Service) func RegisterService(name string, s Service) { fmt.Printf("Registering service: %s\n", name) services[name] = s } func GetService(name string) Service { return services[name] } // my_service/my_service.go package my_service import ( "fmt" "myproject/registry" ) type MyService struct{} func (s *MyService) Run() { fmt.Println("MyService is running!") } func init() { registry.RegisterService("myService", &MyService{}) }当
my_service
包被导入时，MyService
就会自动注册。 初始化日志系统：在程序开始输出任何日志信息之前，你可能需要配置日志级别、输出格式、输出目标（文件、控制台、远程服务等）。
init
函数可以确保日志系统在程序早期就设置妥当。一次性验证或资源检查：有时，程序在启动时需要进行一些前置检查，比如检查某个目录是否存在、某个外部服务是否可达等。
init
函数可以用于执行这些检查，如果条件不满足，可以直接panic
，避免程序在后续运行中遇到更复杂的问题。
总的来说，
init函数是Go语言提供的一个强大且便利的工具，用于处理那些需要在程序主逻辑开始之前完成的各种初始化任务。合理利用它，可以使你的代码结构更清晰，启动流程更健壮。
