1.定义
函数是结构化编程的最小单元模式。它将复杂的算法过程分解为若干个较小任务，隐藏相关细节，使程序结构更加清晰，易于维护。
函数被设计成相对独立，通过接收输入参数完成一段算法指令，输出或存储相关结果。
一个函数的声明通常包括关键字func、函数名、分别由圆括号包裹的列表参数和结果列表，
以及由花括号包裹的函数体，就像这样：
func divide(dividend int,divisor int)(int,error){
//函数体
}
函数可以没有参数列表，也可以没有结果列表，但空参数列表必须保留括号，而结果列表则不用，示例如下：
func divide(){
//函数体
}
另外，参数列表中的必须有名称，而结果列表中结果的名称则可有可无。
不过，结果列表中的结果要么都省略名称，要么都要有名称。
带有结果名称的divide函数的声明如下：
func divide(dividend int,divisor int)(result int,err error){
//函数体
}
如果函数的结果有名称，那么在函数被调用时，以它们为名的变量就会被隐式声明。
如此一来在函数中就可以直接使用它们了，就像使用参数那样。
给代表结果的变量赋值，就相当于设置函数的返回结果。
在Go中，函数类型是一等类型，这意味着可以把函数当作一个值来传递和使用。
函数值既可以作为其它函数地参数，也可以作为其结果。另外，我们还可以利用函数类型的这一特性来生成闭包。
package main
import "fmt"
func hello() {
fmt.Println("hello, world")
}
func exec(f func()) { //将函数作为参数
f()
}
func main() {
f := hello
exec(f)
}
/*
结果：
hello, world
*/
函数只能判断其是否为nil，不支持其它比较操作。
package main
import "fmt"
func a() {}
func b() {}
func main() {
fmt.Println(a == nil) //false
fmt.Println(a == b) //不支持比较操作
//invalid operation: a == b (func can only be compared to nil)
//无效操作：a == b (函数只能去判断其是否为nil)
}
从函数返回局部变量指针是安全的，编译器会通过逃逸分析来决定是否在堆上分配内存。
package main
import "fmt"
func test() *int { //*int 返回值时指针类型
a := 0x100
return &a
}
func main() {
var a *int = test() //定义一个指针类型的变量
fmt.Println(a, *a) //a指针变量 *a反向取值
}
/*
结果：
0xc00000a168 256
*/
2.参数
Go对参数的处理偏向保守，不支持有默认值的可选参数，不支持命名实参。
调用时，必须按签名顺序传递指定类型和数量的实参，就算是“_”命名的参数也不能忽略。
package main
import "fmt"
func test(x, y int, s string, _ bool) *int {
return nil
}
func main() {
test(1, 2, "abc") // not enough arguments in call to test定义了四个变量却只传递了三个
}
在Go中应该避免在相同层次定义同名变量。
package main
import "fmt"
func add(x, y int) int { //形参和实参冲突
x := 100 //no new variables on left side of :=
var y int
return x + y
}
func main() {
result := add(10, 20)
fmt.Println(result)
}
在函数中定义的参数，我们称之为形参，函数被调用时所传递的参数我们称之为实参。
形参类似于函数的局部变量，而实参则是函数的外部对象，可以是常量、变量、表达式或函数。
package main
import "fmt"
func test(x *int) {
fmt.Println(&x, x)
}
func main() {
a := 0x100
p := &a
fmt.Println(&p, p)
test(p)
}
/*
结果：
0xc000076018 0xc00004e080
0xc000076028 0xc00004e080
*/
虽然形参和实参都指向一个目标，但是传递指针时依然被复制的。
不管传递的参数是指针、引用类型，还是其它类型参数，默认采用的都是值拷贝传递。
值拷贝传递就是在调用函数时将实际参数复制一份传递到函数中，
这样在函数中如果对参数进行修改，将不会影响到实际参数。
package main
import "fmt"
func main() {
var a int = 100
var b int = 200
fmt.Printf("交换前a的值为%d
", a)
fmt.Printf("交换前b的值为%d
", b)
swap(a, b)
fmt.Printf("交换前a的值为%d
", a)
fmt.Printf("交换前b的值为%d
", b)
}
func swap(x, y int) int {
var temp int
temp = x
x = y
y = temp
return temp
}
/*
交换前a的值为100
交换前b的值为200
交换前a的值为100
交换前b的值为200
*/
另外一种是引用传递，就是在调用函数时将实际参数的地址传递到函数中，那么在函数中，对参数所进行的修改。
package main
import "fmt"
func main() {
var a int = 100
var b int = 200
fmt.Printf("交换前a的值为%d
", a)
fmt.Printf("交换前b的值为%d
", b)
swap(&a, &b) //交换的是指针
fmt.Printf("交换前a的值为%d
", a)
fmt.Printf("交换前b的值为%d
", b)
}
func swap(x *int, y *int) int {
var temp int
temp = *x
*x = *y
*y = temp
return temp
}
/*
交换前a的值为100
交换前b的值为200
交换前a的值为200
交换前b的值为100
*/
如果函数的参数过多，建议将其重构为一个复合结构类型。
package main
import (
"fmt"
"log"
"time"
)
type serverOption struct { //定义结构体
address string
port int
path string
timeout time.Duration
log *log.Logger
}
func newOption() *serverOption { //以函数的形式返回默认参数
return &serverOption{
address: "0.0.0.0",
port: 8080,
path: "/var/test",
timeout: time.Second * 5,
log: nil,
}
}
func server(option *serverOption) { //需要操作的函数
fmt.Println(option)
}
func main() {
opt := newOption()
opt.port = 8085 //修改属性值
server(opt)
}
/*
结果：
&{0.0.0.0 8085 /var/test 5000000000 <nil>}
*/
在Go中还有一种称之为变参的用法，就是一个标识符传递多个参数的用法。
变参本质上就是一个切片。只能接收一到多个同类型的参数，且必须放在列表尾部。
将切片作为变参时，需进行展开操作。如果是数组，先将其转换为切片。
package main
import "fmt"
func test(s string, a ...int) {
fmt.Println(s, a)
}
func main() {
test("abc", 1, 2, 3, 4, 5)
x := []int{10, 20, 30} //使用切片作为变参
test("abc", x...)
y := [3]int{40, 50, 60} //使用数组作为变参
test("abc", y[:]...)
}
/*
结果：
abc [1 2 3 4 5]
abc [10 20 30]
abc [40 50 60]
*/
3.返回值
有返回值的函数，必须有明确的return终止语句。
package main
func test(a int) int { //函数如果有返回值就必须定义返回值的类型
if a > 0 {
return 1
} else if a < 0 {
return 2 //missing return at end of function
}
//逻辑必须完整，这里缺少一个else
}
func main() {
test(5)
}
函数体中每个条件分支的最后一般都要有return语句，该语句以return关键字开始，
后跟与函数结果列表相匹配的变量、常量、表达式或值。
无论是什么，它们都会被求值并得到确切的值。
但是，如果函数声明的结果是有名称的，那么return关键字后面就不用追加任何东西了。
package main
import (
"errors"
"fmt"
)
func div(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
}
func main() {
fmt.Println(div(10, 3))
}
在Go中没有元组类型可以用来接收返回值，也不能使用数组或者切片就收，但是可以用“_”忽略掉不想要的返回值。
多返回值可用作其它函数调用实参，或当作结果直接返回。
package main
import (
"errors"
"fmt"
)
func div(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
}
func log(x int, err error) {
fmt.Println(x, err)
}
func test() (int, error) {
return div(5, 0) //多返回值用作return结果
}
func main() {
log(test()) //多返回值用作实参
}
还有一种对返回值常用的操作是在定义函数的时候给返回值命名。
返回值和参数一样，可以当作函数局部变量使用，最后由return隐式返回。
package main
import "fmt"
func div(x, y int) (z int, err error) {
if y == 0 {
err = errors.New("division by zero")
return //这样就可以直接进行return
}
z := x / y, nil
return
}
func main() {
fmt.Println(div(10, 3))
}
需要注意的是，这些特殊的“局部变量”会被不同层级的同名变量遮蔽，这时候就需要使用显式地return返回。
package main
import "fmt"
func add(x, y int) (z int) {
{
z := x + y //新定义的同名局部变量，同名遮蔽
return //z is shadowed during return，改成return z就可以
}
return
}
func main() {
fmt.Println(add(10, 1))
}
此外，我们在命名地时候要全部命名，除非返回值能明确表明其含义，就可以省略命名。
package main
func test() (int, s string) { //cannot use 1 (type int) as type string in return argument
//要么都命名，要么都不命名
return 1, "abc"
}
func main() {
test()
}
4.匿名函数
匿名函数是指没有定义名字符号地函数。
除没有名字外，匿名函数和普通函数完全相同。
最大的区别是，我们可在函数内部定义匿名函数，形成类似嵌套效果。
匿名函数常见的使用方法有四种：直接使用、保存到变量、作为参数和返回值。
（1）直接执行
package main
import "fmt"
func main() {
func(s string) {
fmt.Println(s)
}("科比要结婚了") //直接执行
}
（2）复制给变量
package main
import "fmt"
func main() {
add := func(x, y int) int { //赋值给变量
return x + y
}
fmt.Println(add(1, 3)) //4
}
（3）作为参数
package main
import "fmt"
func test(f func()) {
f()
}
func main() {
test(func() { //匿名函数作为参数
fmt.Println("都走吧")
})
}
（4）作为返回值
package main
import "fmt"
func test() func(int, int) int { //func(int, int) int:func(int, int)这是返回值名称，后面的int是返回值的类型
return func(x, y int) int { //直接返回一个函数
return x + y
}
}
func main() {
add := test() //得到一个函数
fmt.Println(add(11, 22)) 传参
}
相比与语句块来说，匿名函数的作用域是被隔离的，不会引发外部污染，更加灵活。
5.闭包
在python中，你调用了一个函数A，但是函数A直接给你返回一个B函数，那么B函数就是闭包函数，
在B函数中，调用函数A的变量称作自由变量。
其实在Go语言中，闭包也是类似的定义。
package main
import "fmt"
func test(s string) func() {
return func() {
fmt.Println(s)
}
}
func main() {
reslut := test("时光悠悠")
reslut()
}
test返回的匿名函数会引用上下文环境变量s。
当该函数在main中执行时，它依然可以正确的读取x的值，这种现象就被称作闭包。
还有一种闭包的说法就是，如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，
那么内部函数就被认为是闭包。
那么闭包是如何实现的了？匿名函数被返回之后，为何还能读取环境的变量值了？
package main
import "fmt"
func test(s string) func() {
fmt.Println(&s, s)
return func() {
fmt.Println(&s, s)
}
}
func main() {
reslut := test("时光悠悠")
reslut()
}
/*
0xc0000421c0 时光悠悠
0xc0000421c0 时光悠悠
*/
通过指针我们发现闭包直接引用了原环境变量。
正是因为闭包通过指针引用环境变量，那么可能会导致其生命周期延长。
但这有时候会带来一些问题。
package main
import "fmt"
func test() []func() {
var s []func() //定义一个数组
for i := 0; i < 2; i++ {
s = append(s, func() { //添加元素
fmt.Println(&i, i)
})
}
return s //返回匿名函数列表
}
func main() {
for _, f := range test() { //迭代执行所有匿名函数
f()
}
}
/*
0xc00000a168 2
0xc00000a168 2
*/
这并不是我们想要看到的结果，为什么了？
for循环复用局部变量i，那么每次添加的匿名函数引用的就是同一个变量。
添加元素的操作仅仅是将匿名函数放入列表而并没有执行，所以就会出现这种状况。
解决办法就是每次使用不同的环境变量或传参复制，让各自闭包环境各不相同。
package main
import "fmt"
func test() []func() {
var s []func() //定义一个数组
for i := 0; i < 2; i++ {
x := i
s = append(s, func() { //添加元素
fmt.Println(&x, x)
})
}
return s
}
func main() {
for _, f := range test() {
f()
}
}
/*
结果：
0xc00000a168 0
0xc00000a180 1
*/
多个匿名函数引用同一变量时，任何修改都会影响其它函数的取值，这是我们需要注意的。
package main
import "fmt"
func test(x int) (func(), func()) { //返回两个匿名函数
return func() {
fmt.Println(x)
x += 10 //修改环境变量
}, func() {
fmt.Println(x)
}
}
func main() {
a, b := test(100)
a() //100
b() //110
}
所以对于闭包应该慎用。
6.延迟调用
除了前面介绍的流程控制语句外，Go还有一些特有的流程控制语句，其中一个就是defer。
该语句用于延迟调用指定的函数，它只能出现在函数内部，由defer关键字以及针对某个函数的调用表达式组成。
这里被调用的函数称为延迟函数。
func outerFunc() {
defer fmt.Println("函数执行结束前一刻才会被打印") //延迟执行，调用fmt.PrintLn
fmt.Println("第一个被打印") //延迟函数
}
其中，defer关键字后面是针对fmt.Println函数的调用表达式。代码里面也说明了延迟函数的执行时机。
这里的outerFunc称为外围函数，调用outerFunc的那个函数称为调用函数。
下面是具体的规则：
a.当外围函数中的语句正常执行完毕时，只有其中所有的延迟函数都执行完毕，外围函数才会真正结束执行。
b.当执行外围函数中的return语句时，只有其中所有的延迟函数都执行完毕后，外围函数才会真正返回。
c.当外围函数中的代码引发运行异常，只有其中所有的延迟函数都执行完毕后，该运行异常才会被真正扩散至调用函数。
正因为defer语句有这样的特性，所以它成为了执行释放资源或异常处理等收尾任务的首选。
明显的优势有以下两个：
A.对延迟函数的调用总会在外围函数执行结束前执行。
B.defer语句在外围函数体中的位置不限，并且数量不限。
不过，使用defer语句还有三点需要注意：
第一点，如果在延迟函数中使用外部变量，就应该通过参数传入。
func printNumbers() {
for i := 0; i < 5; i++ {
defer func() {
fmt.Printf("%d", i)
}()
}
}
上述代码的执行结果是55555，这正是由于延迟函数的执行实际引起的，for循环执行完毕之后，才会执行延迟函数。
也就是说，当执行延迟函数的时候，i已经等于5了。
func printNumbers() {
for i := 0; i < 5; i++ {
defer func(n,int) {
fmt.Printf("%d", n)
}(i)
}
}
打印的内容会是43210，至于为什么，请看下面的第二点。
第二点：同一个外围函数内多个延迟函数调用的执行顺序，会与其所属的defer语句的执行顺序完全相反。
同一个外围函数中的每个defer语句执行的时候，针对其延迟函数的调用表达式都会被压入同一个栈。
在该外围函数执行结束的那一刻，Go会从这个栈中依次取出，栈的取值顺序是先进后出。
第三点：延迟函数调用，若有参数传入，那么那些参数的值会在当前defer语句执行时求出。
func printNumbers() {
for i := 0; i < 5; i++ {
defer func(n,int) {
fmt.Printf("%d", n)
}(i*2)
}
}
此时，执行的结果是86420
最后看一个例子：
package main
import (
"fmt"
)
func main() {
x, y := 1, 3
defer func(a int) {
fmt.Println("defer x, y=", a, y) //y为闭包引用
}(x) //注册时复制调用参数，所以x为1
x += 100
y += 200
fmt.Println(x, y)
}
/*
101 203
defer x, y= 1 203
*/
7.错误处理
（1）error
标准库将error定义为接口类型，以便发现自定义错误类型。
type error interface {
Error() string
}
按惯例，error总是最后一个返回参数。标准库提供了相关创建函数，
可以很方便的创建包含简单错误处理文本的error对象。
package main
import (
"errors"
"fmt"
"log"
)
var errDivByZero = errors.New("division by zero")
func div(x, y int) (int, error) {
if y == 0 {
return 0, errDivByZero
}
return x / y, nil
}
func main() {
z, err := div(5, 0)
if err == errDivByZero {
log.Fatalln(err)
}
fmt.Println(z)
}
/*
2018/11/30 03:15:24 division by zero
exit status 1
*/
某些时候，我们需要自定义错误类型，以便容纳更多的上下文状态信息。
package main
import (
"fmt"
"log"
)
type DivError struct {
x, y int
}
func (DivError) Error() string {
return "division by zero"
}
func div(x, y, int) (int, error) {
if y == 0 {
return 0, DivError{x, y}
}
return x / y, nil
}
func main() {
z, err := div(5, 0)
if err != nil {
switch e := err.(type) {
case DivError:
fmt.Println(e, e.x, e.y)
default:
fmt.Println(e)
}
log.Fatalln(err)
}
fmt.Println(z)
}
（2）panic和recover
panic会立即中断当前函数流程，执行延迟调用。
而在延迟函数中，recover可捕获并返回panic提交的错误对象。
package main
import (
"fmt"
"log"
)
func main() {
defer func() {
if err := recover(); err != nil {
log.Fatalln(err)
}
}()
panic("I dead")
fmt.Println("exit!")
}
/*
2018/11/30 03:35:18 I dead
exit status 1
*/
因为panic参数是空接口类型，因此可以使用任何对象作为错误状态。
无论是否执行recover，所有延迟都会被执行。
但中断性错误会调用堆栈向外传递，要么被外层捕获，要么导致进程崩溃。t/css" />
从函数返回局部变量指针是安全的，编译器会通过逃逸分析来决定是否在堆上分配内存。
package main
import (
"fmt"
"log"
)
func test() {
defer fmt.Println("test.1")
defer fmt.Println("test.2")
panic("I dead")
}
func main() {
defer func() {
log.Fatalln(recover())
}()
test()
}
/*
test.2
test.1
2018/11/30 03:39:02 I dead
exit status 1
*/
连续调用panic，仅最后一个会被recover捕获。