关于go:golang中的init初始化函数

https://waterflow.link/articles/1666090530880

init 函数是用于初始化应用程序状态的函数。它不承受任何参数并且不返回任何后果（一个 func() 函数）。初始化包时，将初始化包中的所有常量和变量申明。而后，执行初始化函数。上面是一个初始化主包的例子：

package main

import "fmt"

// 1
var a = func() int {fmt.Println("var a")
    return 0
}()

// 2
func init()  {fmt.Println("init")
}

// 1
var b = func() int {fmt.Println("var b")
    return 1
}()

// 3
func main() {fmt.Println("main")
}

下面代码的初始化程序是：

初始化常量 / 变量（尽管 b 在 init 函数前面，然而会首先初始化）
初始化 init 函数
执行 main 函数

咱们看下打印的后果：

go run 2.go
var a
var b
init
main

初始化包时会执行一个 init 函数。在上面的例子中，咱们定义了两个包，main 和 redis，其中 main 依赖于 redis。首先，2 .go 是主包：

package main

import (
    "fmt"
    "go-demo/100gomistakes/2/redis"
)

// 2
func init()  {fmt.Println("main init")
}

// 3
func main() {err := redis.Store("ni", "hao")
    fmt.Println(err)
}

咱们能够看到 main 包中调用了 redis 包的办法。

咱们再看下 redis 包中的内容：

package redis

import "fmt"

// 1
func init()  {fmt.Println("redis init")
}

func Store(key, value string) error {return nil}

因为 main 依赖 redis，所以先执行 redis 包的 init 函数，而后是 main 包的 init，而后是 main 函数自身。下面的代码中表明了执行程序。

咱们能够为每个包定义多个初始化函数。当咱们这样做时，包内的 init 函数的执行程序是基于源文件的字母程序。例如，如果一个包蕴含一个 a.go 文件和一个 b.go 文件，并且都有一个 init 函数，则首先执行 a.go init 函数。

然而如果咱们把文件 a.go 改为 ca.go，则会先执行 b.go 的 init 函数。

所以咱们不应该依赖包中初始化函数的程序。实际上，这可能很危险，因为能够重命名源文件，从而可能影响执行程序。

下图阐明了这个问题：

当然，咱们还能够在同一个源文件中定义多个初始化函数：

package main

import (
    "fmt"
    "go-demo/100gomistakes/2/redis"
)


func init()  {fmt.Println("main init1")
}

func init()  {fmt.Println("main init2")
}


func main() {err := redis.Store("ni", "hao")
    fmt.Println(err)
}

执行程序是依照源文件程序执行的，咱们看下打印的后果：

go run 2.go
redis2 init
redis init
main init1
main init2
<nil>

咱们开发的时候常常会应用 gorm 查询数据库，所以咱们常常会看到在初始化 db 连贯的时候会有上面的代码：

package models

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
)

这种状况就是说，咱们没有强依赖 mysql 包（没有间接应用 mysql 的公共函数）。然而咱们须要初始化 mysql 包里的一些数据，也就是执行 mysql 包里的 init 函数。这个时候咱们就能够在这个包的后面加上 _。

须要留神的是 init 函数不能被当作一般函数调用，会编译报错 。

首先，让咱们看一个应用 init 函数可能被认为不适合的示例：持有数据库连接池。在示例的 init 函数中，咱们应用 sql.Open 关上一个数据库。这个全局变量 db 会被其余函数调用：

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "log"
)

var db *sql.DB

func init() {
    d, err := sql.Open("mysql",
        "root:[email protected](127.0.0.1:3306)/test")
    if err != nil {log.Panic(err)
    }

  err := db.Ping()
    if err != nil {log.Panic(err)
    }
  
    db = d
}

func main() {}

在本例中，咱们关上数据库，查看是否能够 ping 通，而后将其调配给全局变量。

然而这种实现会带来一些问题：

init 函数中的谬误治理是无限的。实际上，因为 init 函数不返回谬误，因而收回谬误信号的惟一办法之一就是 panic，导致应用程序进行。在咱们的示例中，如果关上数据库失败，无论如何都会进行应用程序。然而，不肯定要由包自身来决定是否进行应用程序。有可能调用者想实现重试或应用回退机制。在这种状况下，在 init 函数中关上数据库会阻止客户端包实现其错误处理逻辑。
如果咱们向这个文件增加测试，init 函数将在运行测试用例之前执行，然而咱们想要的是创立 db 连贯的时候须要测试。因而，此示例中的 init 函数使编写单元测试变得复杂。
该示例须要将数据库连接池调配给全局变量。全局变量有一些重大的毛病；例如：
- 任何函数都能够更改包中的全局变量
- 单元测试可能会更简单，因为依赖于全局变量的函数将不再被隔离

在大多数状况下，咱们应该偏向于封装一个变量而不是让它放弃全局。

因为这些起因，之前的初始化可能应该封装到一个函数中解决，如下所示：

func createDB() (*sql.DB, error) {
    d, err := sql.Open("mysql",
        "root:[email protected](127.0.0.1:3306)/test")
    if err != nil {return nil, err}
    err = db.Ping()
    if err != nil {return nil, err}
    return d, nil
}

这样写的话，咱们解决了之前探讨的次要毛病：

是否处理错误留给调用者
能够创立一个集成测试来查看此性能是否无效
连接池封装在函数中

然而这样就是不能应用 init 函数了么？在咱们下面的引入 mysql 驱动的例子中，阐明应用 init 还是有帮忙的：

func init() {sql.Register("mysql", &MySQLDriver{})
}

下面的例子，通过注册提供的驱动名称使数据库驱动程序可用。

关于go:golang中的init初始化函数

0.1、索引

1、概念

1.1、源文件里的代码执行程序

1.2、不同包的 init 函数执行程序

1.3、同一个包不同文件 init 执行程序

1.4、同一个文件中的 init 函数

1.5、以副作用形式执行的 init 函数

2、应用场景