Go 里面有三种类型的函数：
1. 普通的带有名字的函数
2. 匿名函数或者 lambda 函数
3. 方法
## init() 函数
init() 函数的特性如下：
- 每个源码可以使用 1 个 init() 函数。
- init() 函数会在程序执行前（main() 函数执行前）被自动调用。
- 调用顺序为 main() 中引用的包，以深度优先顺序初始化。
- 同一个包中的多个 init() 函数的调用顺序不可预期。
- init() 函数不能被其他函数调用。
例如，假设有这样的包引用关系：main→A→B→C，那么这些包的 init() 函数调用顺序为：
```
C.init→B.init→A.init→main
```
除了 main ()、init () 函数外，其它所有类型的函数都可以有参数与返回值。函数参数、返回值以及它们的类型被统称为函数签名。
函数可以将其他函数调用作为它的参数，只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的，例如：
假设 f1 需要 3 个参数 f1(a, b, c int)，同时 f2 返回 3 个参数 f2(a, b int) (int, int, int)，就可以这样调用 f1：f1(f2(a, b))。
函数能够接收参数供自己使用，也可以返回零个或多个值（我们通常把返回多个值称为返回一组值）。
函数定义时，它的形参一般是有名字的，不过我们也可以定义没有形参名的函数，只有相应的形参类型，就像这样：func f(int, int, float64)。
没有参数的函数通常被称为 niladic 函数（niladic function），就像 main.main()。
### 按值传递和按引用传递
Go 默认使用按值传递来传递参数，也就是传递参数的副本。函数接收参数副本之后，在使用变量的过程中可能对副本的值进行更改，但不会影响到原来的变量，比如 Function(arg1)。
如果你希望函数可以直接修改参数的值，而不是对参数的副本进行操作，你需要将参数的地址（变量名前面添加 & 符号，比如 &variable）传递给函数，这就是按引用传递，比如 Function(&arg1)，此时传递给函数的是一个指针。如果传递给函数的是一个指针，指针的值（一个地址）会被复制，但指针的值所指向的地址上的值不会被复制；我们可以通过这个指针的值来修改这个值所指向的地址上的值。
几乎在任何情况下，传递指针（一个 32 位或者 64 位的值）的消耗都比传递副本来得少。
在函数调用时，像切片（slice）、字典（map）、接口（interface）、通道（channel）这样的引用类型都是默认使用引用传递（即使没有显式的指出指针）。
### 命名返回值和非命名返回值
```
package main
import "fmt"
var num int = 10
var numx2, numx3 int
func main() {
numx2, numx3 = getX2AndX3(num)
PrintValues()
numx2, numx3 = getX2AndX3_2(num)
PrintValues()
}
func PrintValues() {
fmt.Printf("num = %d, 2x num = %d, 3x num = %d\n", num, numx2, numx3)
}
// 非命名返回值，如果只有一个返回值可以省略括号
func getX2AndX3(input int) (int, int) {
return 2 * input, 3 * input
}
// 命名返回值，即使仅有一个命名返回值也需要用括号括起来
func getX2AndX3_2(input int) (x2 int, x3 int) {
x2 = 2 * input
x3 = 3 * input
//return x2, x3 两种返回方法都可以
return
}
```
### 改变外部变量
传递指针给函数不但可以节省内存（因为没有复制变量的值），而且赋予了函数直接修改外部变量的能力，所以被修改的变量不再需要使用 return 返回。如下的例子，reply 是一个指向 int 变量的指针，通过这个指针，我们在函数内修改了这个 int 变量的数值。
```
package main
import (
"fmt"
)
// this function changes reply:
func Multiply(a, b int, reply *int) {
*reply = a * b
}
func main() {
n := 0
reply := &n
Multiply(10, 5, reply)
fmt.Println("Multiply:", *reply) // Multiply: 50
}
```
这仅仅是个指导性的例子，当需要在函数内改变一个占用内存比较大的变量时，性能优势就更加明显了。然而，如果不小心使用的话，传递一个指针很容易引发一些不确定的事，所以，我们要十分小心那些可以改变外部变量的函数，在必要时，需要添加注释以便其他人能够更加清楚的知道函数里面到底发生了什么。
### 传递变长参数
如果函数的最后一个参数是采用 ...type 的形式，那么这个函数就可以处理一个变长的参数，这个长度可以为 0，这样的函数称为变长函数。
```
定义：
func myFunc(a, b, arg ...int) {}
使用：
myFunc(a, b, c, d)
或者
slice := []int{a, b, c, d}
myFunc(slice...)
```
```
package main
import "fmt"
func main() {
x := min(1, 3, 2, 0)
fmt.Printf("The minimum is: %d\n", x)
slice := []int{7,9,3,5,1}
x = min(slice...)
fmt.Printf("The minimum in the slice is: %d", x)
}
func min(s ...int) int {
if len(s)==0 {
return 0
}
min := s[0]
for _, v := range s {
if v < min {
min = v
}
}
return min
}
```
### defer 和追踪
关键字 defer 允许我们推迟到函数返回之前（或任意位置执行 return 语句之后）一刻才执行某个语句或函数（为什么要在返回之后才执行这些语句？因为 return 语句同样可以包含一些操作，而不是单纯地返回某个值）。
```
package main
import "fmt"
func main() {
function1()
}
func function1() {
fmt.Printf("In function1 at the top\n")
defer function2()
fmt.Printf("In function1 at the bottom!\n")
}
func function2() {
fmt.Printf("function2: Deferred until the end of the calling function!")
}
```
输出
```
In Function1 at the top
In Function1 at the bottom!
Function2: Deferred until the end of the calling function!
```
```
func returnValues() int {
var result int
defer func() {
result++
}()
return result // 0
}
func namedReturnValues() (result int) {
defer func() {
result++
}()
return result // 1
}
```
先执行 return，确定返回值为 0，之后执行 defer，变量 result++，因为非命名返回值所以此时修改的变量并没有赋值给返回值，所以返回的仍然是 0；而方法二是命名返回值，所以一直都在操作返回值，所以返回1
将函数作为返回值
```
package main
import "fmt"
func main() {
var f = Adder()
fmt.Print(f(1), " - ") // 1 -
fmt.Print(f(20), " - ") // 1 - 21 -
fmt.Print(f(300)) // 1 - 21 - 321
}
func Adder() func(int) int {
var x int
return func(delta int) int {
x += delta
return x
}
}
```
三次调用函数 f 的过程中函数 Adder () 中变量 delta 的值分别为：1、20 和 300。
我们可以看到，在多次调用中，变量 x 的值是被保留的，即 0 + 1 = 1，然后 1 + 20 = 21，最后 21 + 300 = 321：闭包函数保存并积累其中的变量的值，不管外部函数退出与否，它都能够继续操作外部函数中的局部变量。
**defer执行顺序**
当一个方法中有多个defer时， defer会将要延迟执行的方法“压栈”，当defer被触发时，将所有“压栈”的方法“出栈”并执行。所以defer的执行顺序是LIFO。
```
func stackingDefers() {
defer func() {
fmt.Println("1")
}()
defer func() {
fmt.Println("2")
}()
defer func() {
fmt.Println("3")
}()
}
```
输出：3 2 1