go是个什么语言？

引自知乎

go是面向过程的语言, go的代码不讲究封装和整理，很多源码都是几千行代码呆在单个文件里面，表现出了典型的过程式语言的基本特征. c也是过程式的，go的语言特性跟c语言很相似，只是增加了gc，goroitine等常用工具而已，作者本身就对oop，fp等缺乏了解，只是根据c的经验，整理出了一些常用的工具，然后将其放到语言的runtime中去罢了.

另外go官网对于是否面询对象编程语言，他们自己说是：Yes and No。明显go是允许OO的编程风格的，但又缺乏一些常见类型继承结构和类对象。Go自己觉得这一套挺好的，更加的容易使用且通用性更强。很多时候我们用OO的思想来组织我们的项目，但需要注意的是继承关系是一种非常强的耦合，有时候会给以后的升级带来麻烦。大型项目中可能是非常有帮助的，当然小型的项目可能好处不是很明显。

接下来正式学习Go语言

包

包的引入

• 和其他语言的单个文件就是一个包的组织方式不同，go的package不局限于一个文件，多个文件可以声明同一个名称的包，互相间可以直接调用，不用import，同一个package内全局变量和函数等不能同名。
• go不要求package的名称和所在目录名相同，但建议最好保持相同。引入包的时候，go会使用子目录名作为包的路径，例如：import “root_dir/sub_dir/package”，
• import导入包,调用其属性或方法时,其属性和方法都是大写字母开头的，写自己的方法和属性时也要遵循这个规则.
• 一个文件夹下只能有一个package！！！

  package main
  import (
  // Python是要加逗号隔开,而且没有引号
  "fmt"
  "math"
  // 子包，Python是from...import...
  "math/rand"
  )
  func main() {
  fmt.Println(math.Pi)    // Python建议小写字母开头
  fmt.Println("My favorite number is", rand.Intn(10))
  }

基础数据类型

常见类型

int, string, bool, float32    // Python是int, str, bool, float
uint, int64, float64
byte // uint8 的别名

• 声明变量

  var i int
  var i, j int = 1, 2    // 同类型变量可以在一起声明, 且一次赋值多个变量
  var c, python, java = true, false, "no!"    // 可以省略类型,变量从初始值中获得类型
  i := 1    // 不用加var关键词的声明，compiler会自动识别, 这和Python差不多
  c, python, java := true, false, "no!”
  // Python也可以指定数据类型, i: int = 0, j: int = i

• 声明常量

  const Pi int = 3.14    // 常量不能使用 := 语法定义，必须指定数据类型。是Python的全局变量吗?

• 默认空值

  int:    0
  string:    ""
  bool:    false    // Python是False
  float32:    0.0

• 类型转换

  var i int = 42
  var f float64 = float64(i)
  var u uint = uint(f)

• string和int类型相互转换

• string转成int：
  • int, err := strconv.Atoi(string)
• string转成int64：
  • int64, err := strconv.ParseInt(string, 10, 64)
• int转成string：
  • string := strconv.Itoa(int)

• int64转成string：

  • string := strconv.FormatInt(int64,10)

• 查看变量数据类型

  fmt.Printf(`%T`, num)
  或
  fmt.Println(reflect.TypeOf(num))

逻辑处理

逻辑运算符

• && 逻辑 与 AND
• || 逻辑 或 OR
• ! 逻辑 非 NOT

if, switch控制

• if控制语句

  i := 2
  if i < 3 {
  j := 3
  }

• if 语句可以在条件之前执行一个简单的语句, 用分号;分隔

  if i := 2; i < 3 {
  j := 3
  }
  // 这比Python便捷

// if else语句

if i := 2; i < 3 {
    j := 3
} else {
    j := i
}
// else if 使用switch实现

• switch, Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch。

• 1) 一分支多值

  当出现多个 case 要放在一起的时候，可以写成下面这样：
  //一分支，多值
  switch str {
  case "hello", "nihao":
      fmt.Printf("一分支，多值:%s \n", str)
  default:
      fmt.Println("hi")
  }
  不同的 case 表达式使用逗号分隔。

• 2) 分支表达式

  case 后不仅仅只是常量，还可以和 if 一样添加表达式，代码如下：
  //分支表达式
  var num = 7
  switch {
  case num > 1 && num < 5:
      fmt.Println("小于5的数")
  case num > 5 && num < 10:
      fmt.Println("大于5，小于10的数")
  }

代码输出如下：
大于5，小于10的数

- 使用switch实现if, else if, else

func main() {
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning!")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}

## for循环

// 感觉比Python的要统一些, 新语言比较大胆.
func main() {
// 实现0一直+到9,Σ(0-9)
sum := 0
for i := 0; i < 10; i++ {
sum += i
}

// 类似while语句,累积小于1000的
sum := 1
for sum < 1000 {
    sum += sum
}

// while true 省略了循环条件,就成了死循环
for {
}

}

# 数据结构

## 数组 array

- 定义变量 a 是有2个字符串的数组

func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)
}

- 遍历数组

func main() {
var p = []int{2, 3, 5, 7, 11, 13}
fmt.Println("p ==", p)
// 遍历, 迭代
for i := 0; i < len(p); i++ {
fmt.Printf("p[%d] == %d\n", i, p[i])
}
}

## 序列 slice

- 定义slice, 类似单数据类型的Python列表

var z []int // slice 的零值是 nil
s := []{1, 2, 3}

- 对 slice 切片

s[:2], s[0:0], s[1:2] // s[lo:hi] 表示从lo到hi-1的元素,不包含第hi个元素

- 示例

func main() {
p := []int{2, 3, 5, 7, 11, 13}
fmt.Println("p ==", p)
fmt.Println("p[1:4] ==", p[1:4])
// 省略起始index代表从 0 开始
fmt.Println("p[:3] ==", p[:3])
// 省略结束index代表到 len(s) 结束
fmt.Println("p[4:] ==", p[4:])
}

- range语句遍历序列，可以用for循环 配合 range语句对 slice 进行迭代循环。

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
for i, v := range pow {
fmt.Printf("2**%d = %d\n", i, v) // 2的次方, i表示索引 0开始, v表示值
}
}

- make 构造slice

slice 由函数 make 创建。这会分配一个零长度的数组并且返回一个 slice 指向这个数组，【按python的range函数理解】：
a := make([]int, 5) // len(a)=5, 长度为5, 容量为5的全0序列，[0 0 0 0 0]
b := make([]int, 0, 5) // len(b)=0, cap(b)=5, 长度为0,容量为5的空序列, 占空间较少，[]
b = b[:cap(b)] // len(b)=5, cap(b)=5, 展开所有容量,变成全0序列
b = b[1:] // len(b)=4, cap(b)=4

- 向 slice 添加元素

func main() {
var a []int
a = append(a, 1) // 尾部追加
a = append(0, a) // 头部追加
a = append(a, 2, 3, 4) // 可以添加多个
a = append(a, "a”) // 但不能是其他类型数据（报错）
}

- slice遍历range出来的是index和value，如果只需要索引，可以去掉“, value”的部分即可。仅需要value,则把i赋值给 _ 来忽略索引。

func main() {
pow := make([]int, 10)
for i := range pow {
pow[i] = 1 << uint(i)
}
for _, value := range pow {
fmt.Printf("%d\n", value)
}
}

- 多层序列嵌套

func main() {
dx, dy := 8, 4
sdy := make([][]uint8, dy)
for i := range sdy {
sdy[i] = make([]uint8, dx)
}
fmt.Println(sdy)
}
[[0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0]]

## 映射表 map

- 定义map, 相当于只有一种数据类型的Python字典

mm := make(map[string]int) // make一个key是string类型，value是int类型的map
mm["Answer"] = 42 // 赋值
value := mm["Answer"] // 取值
v1, ok := mm["Answer"] // 取值并判断元素是否存在, true, 不存在则返回false
delete(mm, "Answer") // 删除元素，没有Python字典的pop方法

- 遍历map，range出来的是key和value，统计单词中字母个数

func main() {
s := "Hello World"
ss := strings.Split(s, "") // 分隔字符串
fmt.Println(ss)
wc := make(map[string]int)
for _, v := range ss {
wc[v]++
}
fmt.Println(wc)
}
[H e l l o W o r l d]
map[ :1 H:1 W:1 d:1 e:1 l:3 o:2 r:1]

# 高级数据类型

## 结构体 struct

- 定义struct

// 类似Python的class，指定了固定属性，使用时要“实例”
// 声明的方式也很像Python的类
type Vertex struct {
X, Y int // 有2个int型元素的结构体
// 也可以加入其它类型, Z string
}

- 赋值和取值

var (
v1 = Vertex{1, 2} // 类型为 Vertex, X:1 和 Y:2
v2 = Vertex{X: 1} // Y:0 被省略
v3 = Vertex{} // X:0 和 Y:0
)
func main() {
fmt.Println(v1, v2, v3)
v := Vertex{1, 2}
v.X = 4 // 点号来访问
fmt.Println(v.X)
}

- 重新分配（转换）

// 需要按照bson包，go get -u labix.org/v2/mgo/bson
type Task struct {
id int
name string
age int
sex int
}
type TaskForm struct {
name string
age int
}
// 转换
task_form := TaskForm{”name”: ”bb”, “age”: 17}
var _task Task
jsonstr, := bson.Marshal(task_form)
bson.Unmarshal(json_str, &_task)
fmt.Println(_task)

## 结构体 与 map

- map装入结构体, 即一个key对应的value值是一个struct类型数据. 类似Python字典套class.
- map 在使用之前须用 make 来创建；否则其值为 nil 的 map 是空的，并不能赋值。

type Vertex struct {
Lat, Long float64
}
var m map[string]Vertex // 声明变量 名称叫m的map机构类型
func main() {
m = make(map[string]Vertex) // 使用前要make下
m["Bell Labs"] = Vertex{
40.68433, -74.39967,
}
fmt.Println(m["Bell Labs"])
}

- 也可以这样直接赋值, 跟结构体文法相似，不过必须有键名。

type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
}

- 也可以直接在文法的元素中省略结构名。

import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}
func main() {
fmt.Println(m)
}

# 指针 * &

- 一元操作符 *[取值] &[取地址] ; 
- Go 具有指针。 指针保存了变量的内存地址。默认零值是 `nil`。
- 个人理解其目的是节省变量传递时内存的消耗, 只传递一个地址(一串16进制值), 比传递整个变量(需要新开辟地址空间), 节省空间
- 这也就是通常所说的“间接引用”或“非直接引用”。Python里没有指针

- 定义指针

var p int
fmt.Println(p, &p) // 打印指针地址，此时p是没有值的，也就是还没有分配地址
p = new(int) // 创建一块内存，并把内存地址分配给 指针p，不能直接分配值 p = 12 会报错，因为没有地址来存这个值
// 或 p = &int
fmt.Println(p, &p)
fmt.Println(p)

// 输出：
指针p指向的地址 指针p的地址
<nil> 0xc0000ae018
0xc0000b4010 0xc0000ae018
0 // 分配内存后的指针默认值为 0

- 赋值，两种方式：改地址 和 改值

i := 42
p := &i // 第一种：指向新的地址
fmt.Println(p, p)
p = 21 // 第二种：修改成新的值, 地址不变
fmt.Println(*p, p)

// 输出：
42 0xc00001e080
21 0xc00001e080

// 理解：*p == i, p == &i

- 接下来指针会被用到更多的地方，例如传参和函数返回。

# 过程式编程

## 函数

- 函数的入参,也可以多个同类型变量公用一个类型来声明

func add(x, y int) int {
return x + y
}

- 函数可以返回多个值

func swap(x, y string) (string, string) {
return y, x
}
a, b := swap("hello", "world") // a, b := b, a

- 函数也是值, 函数名可以当变量来传递给其他方法或函数

// 有点类似Python的内置函数
func main() {
hypot := func(x, y float64) float64 { // 相当于 func hypot(x, y float64) float64
return math.Sqrt(xx + yy)
}
fmt.Println(hypot(3, 4))
}

- 匿名函数

// 如果只调用一次，则不用给变量赋值，直接调用，并不给函数命名，称之为匿名函数
func main() {
i2 := func(x, y int) int { return x + y }(1,2)
fmt.Println(i2)
}

- 函数回调
    - 函数可以作为其它函数的参数进行传递，然后在其它函数内调用执行，一般称之为回调 。

func callback(a,b int) {
fmt.Print(a+b)
}
func add(c int, f func(int, int)) {
if c <= 4 {
f(c,c)
}
}
func main() {
add(4, callback)
}

// 输出：
8

- 闭包函数
    - 一个函数中包含另一个函数，内部的函数被封闭在外部函数里，自成环境，则该外部函数称为闭包函数。
    - 调用该闭包函数时，返回的是内部函数，由它来接受闭包外传入的变量。 传递变量的访问和赋值，都在内部环境完成。
    - 有点类似Python的类，先“实例化”外部函数，再“调用”内部函数，传入的变量会作为“类属性”被记忆，不会因为多次调用而被初始化。

// 闭包函数
func adder() func(int) int {
sum := 0 // 闭包函数首次调用默认值，再次被调用时，不会初始化该值。
return func(x int) int {
// 内部函数环境
sum += x
return sum
}
}
func main() {
pos, neg := adder(), adder() // 新分配内存, 并指向adder函数, 新的变量引用互不干扰
for i := 0; i < 5; i++ {
fmt.Println(
// 执行闭包内部函数，由于没有给闭包函数传值，故sum初始值都是：0
pos(i),
neg(-2*i),
)
}
}

// 输出
0 0
1 -2
3 -6
6 -12
10 -20

## 方法

- go语言中没有类class的声明方法, 不过, 仍然可以把一些同类函数定义到一个类似”类”对象的结构体下面, 也就是成为类中的”方法”.
- 函数式编程, 要实现对象编程那套真的好别扭

type Vertex struct { // 类似结构体, 可定义多个方法
X, Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.Xv.X + v.Yv.Y)
}
func (v Vertex) Avg() float64 {
return (v.X + v.Y) / 2 // 方法内, 可像类一样, 调用自己的属性值
}
func main() {
v := Vertex{3, 4} // 类似对象的实例化
fmt.Println(v.Abs()) // 类似对象的方法调用
}

- 可以对包中的 任意 类型定义任意方法，而不仅仅是针对结构体。

type MyFloat float64
func (f MyFloat) Abs() float64 {
if f < 0 {
return float64(-f)
}
return float64(f)
}
func main() {
f := MyFloat(-math.Sqrt2)
fmt.Println(f.Abs())
}

- 方法可以与命名类型或命名类型的指针关联, 可以节省结构体”实例化”带来的内存开销.

type Vertex struct {
X, Y float64
}
func (v Vertex) Scale(f float64) {
v.X = v.X f
v.Y = v.Y f
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.Xv.X + v.Yv.Y)
}
func main() {
v := &Vertex{3, 4}
v.Scale(5)
fmt.Println(v, v.Abs())
}

## 接口

- 接口类型是（类似方法）由一组方法定义的集合, 方法实现了接口中的函数，则表示这些方法都该接口下。
    - 有点绕，方法已经存在了，干嘛还要弄个接口呢？想调用的时候，直接struct.func不就好了，实际意义在哪？
    - 那如果一次执行多个struct的func时，且func逻辑差不多的，是选择单个执行，还是放入数组中遍历执行？
    - 如果放在数组，那这个数组的属性是哪个struct呢？所以就有了接口，来代表这些struct；好比一个Python列表中含有多个不同类实例（只是这些类的方法是必须含有相同的方法名）。
    - 如果想传的方法又不想实现同一个函数，可以试试空接口：interface{}，相当于所有方法和数据类型都实现了这个接口。

//接口定义
type Abser interface {
Abs() float64
}

- 实现不同形状的体积计算接口

// 接口
type Shape interface {
area() float64
}
// 方法
type Circle struct {
x,y,radius float64
}
type Rectangle struct {
width, height float64
}
// 实现了接口中的函数
func(circle Circle) area() float64 {
return math.Pi circle.radius circle.radius
}
func(rect Rectangle) area() float64 {
return rect.width * rect.height
}

// 所有形状体积和，传入接口数组
func getArea(shapes []Shape) float64 {
return shape.area()
}

func main() {
circle := Circle{x:0,y:0,radius:5}
rectangle := Rectangle {width:10, height:5}
fmt.Printf("all area: %f\n",getArea([]Shape{circle, rectangle}))
}

// 输出
all area: 128.539816

- 判断接口的具体数据类型

// 如果类型不匹配则返回false
func assert(i interface{}) {
v, ok := i.(int)
fmt.Println(v, ok)
}
func main() {
var s interface{} = 56
assert(s)
var i interface{} = "Steven Paul"
assert(i)
}

程序将输出：
56 true
0 false

## 空接口 与 map

- 后端接口常常返回的是多个数据类型组合一起的map（转成json）

data := make(map[string]interface{})
data[“key”] = “value”
data[“code”] = 0

# 错误处理

- go中错误必须自行处理, 处于传参严谨态度, 实际避免调用方的误传导致系统崩溃的问题; 没有提供Python那样的try...except...可供试错的语法.
- Go 程序使用 error 值来表示错误状态。`error` 类型是一个内建接口：

type error interface {
Error() string
}

- 通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 `nil`， 来进行错误处理。

i, err := strconv.Atoi("42”) // 可以忽略i,部分
if err != nil {
fmt.Printf("couldn't convert number: %v\n", err)
}
fmt.Println("Converted integer:", i)
// error 为 nil 时表示成功；非 nil 的 error 表示错误。

- go语言没有try excepte等异常处理语法, 可以通过判断函数执行结果来处理error

type MyError struct {
When time.Time
What string
}
func (e *MyError) Error() string {
return fmt.Sprintf("at %v, %s",
e.When, e.What)
}
func run() error {
return &MyError{
time.Now(),
"it didn't work",
}
}
func main() {
if err := run(); err != nil {
fmt.Println(err)
}
}

-函数通常返回错误作为最后一个返回值。 可使用errors.New来构造一个基本的错误消息，如下所示：

func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value) // 默认返回最后一次出参: nil == return math.Sqrt(value), nil
}
// 使用返回值和错误消息，如下所示
result, err:= Sqrt(-1)
if err != nil { // 错误值不等于空, 即: 有错误 == if err {}
fmt.Println(err)
}

- 可以使用第三方包 github.com/pkg/errors 错误库

# Go的并发

## goroutine协程

- goroutine 是由 Go 运行时环境管理的轻量级线程。

go f(x, y, z) // 声明
f(x, y, z) // 开启一个新的 goroutine 执行

- 定义和执行

func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world") // 异步执行
say("hello”) // 同步执行
}

- 思考
    - 有结果如何获取? 使用管道从线程中带出来(也就类似Python的Thread类中定义一个result方法取返回值)

## channel暂存管道

- channel 是有类型的管道, 可以理解为一个特殊的队列

ch <- v // 将 v 送入 channel ch, 在管道未流出前, 数据都是排队等待流出的(即阻塞)。
v := <-ch // 从 ch 接收，并且赋值给 v。
（“箭头”就是数据流的方向。）

- 和 map 与 slice 一样，channel 使用前必须创建： `ch := make(chan int)`
- 默认情况下，在另一端准备好之前，发送和接收都会阻塞。可以和go线程配合使用进行数据同步, 不用单独执行.

func sum(a []int, c chan int) {
sum := 0
for _, v := range a {
sum += v
}
c <- sum // 将和送入 c 管道暂存起来 等待
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int) // 主线程中定义管道 达到内存共享
go sum(a[:len(a)/2], c) // 后三个之和 先暂存到c管道
go sum(a[len(a)/2:], c) // 前三个之和 后暂存到c管道
x, y := <-c, <-c // 从 c 中获取, 管道内数据排队流出, 如何连续不断流出?
fmt.Println(x, y, x+y)
}

- 缓冲管道(有容量的队列)

cc := make(chan int, 2)
cc <- 1
cc <- 2
fmt.Println(<-cc)
fmt.Println(<-cc)

- channel 可以是 带缓冲的[容量]。为 make 提供第二个参数作为缓冲长度来初始化一个缓冲 channel： `ch := make(chan int, 100)`
- 向缓冲 channel 发送数据的时候，只有在缓冲区满的时候才会阻塞。当缓冲区清空的时候接受阻塞。如果满了之后仍然塞入数据则会报错, 如何判断是否满, 避免报错?

- close 和 range 关闭管道并遍历管道

func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
发送者可以 close 一个 channel 来表示再没有值会被发送了。
接收者可以通过赋值语句的第二参数来测试 channel 是否被关闭：当没有值可以接收并且 channel 已经被关闭，那么经过
v, ok := <-ch
之后 ok 会被设置为 false。
循环 for i := range c 会不断从 channel 接收值，直到它被关闭, 如果没有close, 则会一直处于阻塞情况并报错。
注意： 只有发送者才能关闭 channel，而不是接收者。向一个已经关闭的 channel 发送数据会引起 panic。
还要注意： channel 与文件不同；通常情况下无需关闭它们。只有在需要告诉接收者没有更多的数据的时候才有必要进行关闭，例如中断一个 range。

## select

- 个人理解

选择通信信道的一个语法, case语句不同于switch的条件, 而必须是chan操作.
select 语句使得一个 goroutine 在多个通讯操作上等待。
select 会阻塞，直到条件分支中的某个可以继续执行，这时就会执行那个条件分支。当多个都准备好的时候，会随机选择一个。
当 select 中的其他条件分支都没有准备好的时候，default 分支会被执行。

- 示例

func main() {
tick := time.Tick(100 time.Millisecond)
boom := time.After(500 time.Millisecond)
for {
select {
case <-tick:
fmt.Println("tick.")
case <-boom:
fmt.Println("BOOM!")
return
default:
fmt.Println(" .")
time.Sleep(50 * time.Millisecond)
}
}
}

# defer

- 在函数中，我们经常需要创建资源（如，数据库连接 / 文件句柄 / 锁等），为了在函数执行完毕后，可以及时释放资源，Go框架设计了defer。

Note：

当go执行到一个defer时，不会立即执行当前行defer {后半部分}的语句，而是将defer后面的语句压进栈中(可以理解为defer栈)
当函数执行结束后，defer 语句出栈，遵循先入后出
在defer将语句放入栈中时，也会将相关的值Copy，同时入栈
defer最主要的价值在于，当函数执行完毕后，可以及时地释放函数创建的资源，如defer file.close()  / defer connect.close()

示例：
func sum(num1 int, num2 int) int {
//暂时不执行，压进defer栈中
defer fmt.Println("defer1 num1=", num1)
defer fmt.Println("defer2 num2=", num2)
// 执行
res := num1 + num2
fmt.Println("resFun=", res)
return res
}
func main() {
res := sum(10,20)
// 当函数执行完毕后，defer按照先进后出的方式出栈
fmt.Println("res=",res)
}

// 运行结果：
resFun= 30
defer2 num2= 20
defer1 num1= 10
res= 30

# init函数

- 每一个源文件都可以包含一个init函数，该函数在main函之前被go框架运行。通常可以在init函数中完成初始化工作。

Note：
如果一个文件同时包含全局变量定义 / init() / main()。其执行的流程是 全局变量定义 -> init() -> main()
init函数最大的作用是完成一些初始化的工作

var gVar = gTest()
func gTest() string {
    fmt.Println("global variable:")
    return "global variable:"
}
func init() {
    fmt.Println("init function:")
}
func main() {
    fmt.Println("main function:")
}

// 运行结果：
global variable:
init function:
main function: