go——函数

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\n", a)
	fmt.Printf("交换前b的值为%d\n", b)
 
	swap(a, b)
 
	fmt.Printf("交换前a的值为%d\n", a)
	fmt.Printf("交换前b的值为%d\n", 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\n", a)
	fmt.Printf("交换前b的值为%d\n", b)
 
	swap(&a, &b)  //交换的是指针
 
	fmt.Printf("交换前a的值为%d\n", a)
	fmt.Printf("交换前b的值为%d\n", 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捕获。