滥用init函数

在Go语言中，滥用init函数会导致难以理解的代码流和槽糕的错误处理。本文将对init函数进行一个梳理，什么是init函数以及推荐的使用场景。

init函数

init函数是一个不带参数并且无返回结果的函数（func()函数）。初始化Go程序包时，会先处理所有常量和变量声明，然后执行init函数。init函数是在主函数main之前执行的。

package main
import "fmt"
var a = func() int {
        fmt.Println("var")
        return 0
}()
func init() {
        fmt.Println("init")
}
func main() {
        fmt.Println("main")
}

运行上述程序，得到输出结果如下：

var
init
main

初始化包时会执行init函数。下面的示例将定义两个包：main包和redis包，main包会调用redis包。

package main
import (
        "fmt"
        "redis"
)
func init() {
        // ...
}
func main() {
        err := redis.Store("foo", "bar")
        // ...
}

package redis
// imports
func init() {
        // ...
}
func Store(key, value string) error {
        // ...
}

由于main包依赖于redis包，所以会先执行redis包中的init函数，然后执行main包中的init函数，最后才执行main包中的main函数，整体执行顺序如下图所示。

一个包中可以定义多个init函数，在这种情况下，包内的init函数的执行顺序是基于源文件的字母顺序。例如，如果一个包包含一个a.go和b.go文件，并且文件中都有init函数，则首先执行的是a.go中的init函数。但是，我们不应该依赖包中init函数的执行顺序，因为这种做法很危险，像重命名源文件会导致顺序重排，从而可能影响执行顺序。

我们还可以在同一个源文件中定义多个init函数，例如，下面这段代码是完全有效的。

package main
import "fmt"
func init() {
        fmt.Println("init 1")
}
func init() {
        fmt.Println("init 2")
}
func main() {
}

上述程序的输出结果如下，多个init的执行顺序是按它们在源文件中的位置先后，在前的先执行。

init 1
init 2

我们也可以使用init函数来解决导包的副作用问题。例如在下面的示例中，main包对foo包没有很强的依赖关系，不会使用到foo包中定义的函数，但是需要初始foo包，执行foo包中的init函数，这时可以使用_操作符。foo包将在main包之前初始化，因此，foo中的init函数将被执行。

package main
import (
        "fmt"
        _ "foo"
)
func main() {
        // ...
}

init函数的另一个特性是它不能被直接调用。像下面程序中在main函数中调用init函数，是不被允许的。

package main
func init() {}
func main() {
        init()
}

编译上述代码，将会产生如下编译错误。

nbsp;go build .
./main.go:6:2: undefined: init

何时该使用init函数

首先，让我们先看一个可能不适合使用init函数的例子，该例子描述的是保存数据库连接池场景。在init函数中，使用sql.Open打开一个数据库，并将它赋值给了全局变量，以便在init函数执行后，可以直接使用这个全局变量。

var db *sql.DB
func init() {
        dataSourceName := os.Getenv("MYSQL_DATA_SOURCE_NAME")
        d, err := sql.Open("mysql", dataSourceName)
        if err != nil {
                log.Panic(err)
        }
        err = d.Ping()
        if err != nil {
                log.Panic(err)
        }
        db = d
}

上面的init函数主要完成了3件事：1.打开数据库， 2.检查数据库是否可以ping通，3.将数据库分配给全局变量。这样写有什么问题吗？

• 问题1：处理init函数中的错误会受到限制，因为init函数并不返回任何错误，所以当出现错误的时候调用Panic，这会导致程序挂掉。在上面的示例程序中，如果打开数据库失败，无论如何都可以停止程序。但是，不一定由包本身来决定是否停止程序，也许调用者可能更喜欢使用重试或回退机制。在init函数中执行打开数据库操作会阻止调用的客户端实现它们的错误处理逻辑。
• 问题2：与测试有关，如果我们要对上述程序文件进行单元测试，由于init函数将在运行测试函数之前执行，这不一定是我们期望的。例如，如果待测函数不依赖数据库连接，即可以直接进行测试，但是在执行测试函数之前init函数先被执行，只有init函数成功执行，才能运行我们的单元测试，这使得编写单元测试变得很复杂。
• 问题3：init函数将数据库连接池分配给全局变量，使用全局变量有一些严重的缺点：1. 包中的任何函数可以更改它的值；2. 全局变量会导致单元测试变得更加复杂，因为这会导致与依赖函数之间产生耦合。在大多数情况下，我们应该倾向于封装一个变量（在函数间传递）而不使用全局变量。

由于上述这些问题，init函数中的数据库操作应该放在普通函数中来处理，实现如下。

func createClient(dataSourceName string) (*sql.DB, error) {
        db, err := sql.Open("mysql", dataSourceName)
        if err != nil {
                return nil, err
        }
        if err = db.Ping(); err != nil {
                return nil, err
        }
        return db, nil
}

采用普通函数处理，解决了之前存在的3个问题。将错误处理的责任抛给调用者；可以创建一个集成测试来检查此功能是否有效；将连接池封装在函数内，而不是赋值给全局变量。

上面举了一个使用init函数的例子，以及使用init存在诸多问题。那是不是说我们应该不惜一切代价避免使用init函数呢？答案不是的。在一些场景中，init函数非常有用。例如，Go官方博客（采用Go语言实现的）使用init函数来设置静态HTTP配置。这是一个采用init函数非常好的示例。

func init() {
        redirect := func(w http.ResponseWriter, r *http.Request) {
                http.Redirect(w, r, "/", http.StatusFound)
        }
        http.HandleFunc("/blog", redirect)
        http.HandleFunc("/blog/", redirect)
        static := http.FileServer(http.Dir("static"))
        http.Handle("/favicon.ico", static)
        http.Handle("/fonts.css", static)
        http.Handle("/fonts/", static)
        http.Handle("/lib/godoc/", http.StripPrefix("/lib/godoc/",
                http.HandlerFunc(staticHandler)))
}

为什么上面程序采用init合适呢？一是init函数不会失败，除非http.HandleFunc出现特殊情况，这里的特殊情况是处理程序为nil,这不会在上述程序出现。二是不用创建全局变量。三是不会影响可能的单元测试。因此，采用init非常合适。

总结，通过前面的例子可以看到init函数可能会导致一些问题：1.会限制对错误的处理，2.可能会使得到单元测试变得复杂（例如，要设置外部依赖项，这对于单元测试可能不是必需的），3.如果初始化需要设置状态，则必须通过全局变量来完成。所以我们应该谨慎使用init函数。在某些场景下可能会有帮助，例如上面初始化静态配置的场景。但在大多数情况下，我们应该通过特定函数来进行初始化。