1. main 和 init 函数
一个 package 里面可以写多个 init 函数，但必须仅包含一个 main 函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| package main
import (
"fmt"
)
func init() {
fmt.Println("init 1")
}
func init() {
fmt.Println("init 2")
}
func main() {
fmt.Println("main")
}
// init 1
// init 2
// main
|
2. defer 函数
Go 不会立即执行 defer 修饰的代码，而是进行标记，在程序退出之前执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| package main
import (
"fmt"
)
func main() {
defer func() {
fmt.Println("before exit, in defer")
}()
fmt.Println("I am in main")
}
// I am in main
// before exit, in defer
|
3. panic 和 recover 函数
Go 中的异常处理：抛出一个 panic ，然后在 defer 中使用 recover 捕获异常，并将 panic 抛向上一层。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| package main
import (
"fmt"
)
func main() {
defer fmt.Println("I am in main")
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
// do something
}
}()
panic("error message")
}
// error message
// I am in main
|
4. new 和 make 函数
原型：
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| package main
import (
"fmt"
)
func main() {
tmp := new(int)
fmt.Printf("tmp --> %#v \n", tmp)
fmt.Printf("tmp point to --> %#v \n ", *tmp)
}
// tmp --> (*int)(0x40e020)
// tmp point to --> 0
|
new 用来分配内存，参数是类型，返回值是一个指向分配零值的指针。
原型：
1
| func make(Type, size IntegerType) Type
|
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| package main
import (
"fmt"
)
func main() {
var s1 []int
fmt.Printf("s1 is --> %#v \n", s1)
s2 := make([]int, 3)
fmt.Printf("s2 is --> %#v \n", s2)
}
// s1 is --> []int(nil)
// s2 is --> []int{0, 0, 0}
|
make 用来为 slice，map 或 chan 类型分配内存、并初始化一个对象，参数是类型。但 make 返回类型的引用而不是指针。
区别：new 仅将内存置零，而 make 会对 slice、map、chan 引用的数据进行初始化。
