Task6：函数

6.1 函数定义

在 go 语言中函数定义格式如下：

func functionName([parameter list]) [returnTypes]{
	//body
}

• 函数由 func 关键字进行声明
• functionName：函数名
• parameter list：函数列表，函数的参数是可选的，可以包含参数一可以不包含参数
• returnTypes：返回值类型，返回值是可选的，可以有返回值，也可以没有返回值
• body：函数的具体实现

例1：

下面的函数是用于求两个数的和

func GetSum(num1 int, num2 int) int {
	result := num1 + num2
	return result
}

这个函数传递了两个参数，分别为num1与num2，并且他们都为int类型，将相加后的结果进行返回

上面这个函数还可以这样定义

func GetSum1(num1, num2 int) int {
	result := num1 + num2
	return result
}

当num1和num2是相同类型的时候我们可以省略掉前面的类型，go编译器会自动进行推断

6.2 值传递与引用传递

因为在go语言中存在值类型与引用类型，所以在函数参数进行传递时也要注意这个问题

• 值传递是指在函数调用过程中将实参拷贝一份到函数中，这样在函数中如果对参数进行修改，将不会影响到实参。
• 引用传递是指在函数调用过程中将实参的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实参。

如果想要函数可以直接修改参数的值，那么我们可以用指针传递，将变量的地址作为参数传递到函数中。下面的这个例子为大家演示了以上的几种情况

例2：

func paramFunc(a int, b *int, c []int) {
	a = 100
	*b = 100
	c[1] = 100

	fmt.Println("paramFunc:")
	fmt.Println(a)
	fmt.Println(*b)
	fmt.Println(c)
}

func main() {
	a := 1
	b := 1
	c := []int{1, 2, 3}
	paramFunc(a, &b, c)

	fmt.Println("main:")
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

Output:

paramFunc:
100
100
[1 100 3]
main:
1
100
[1 100 3]

6.3 变长参数

在go语言中也支持变长参数，但需要注意的是变长参数必须放在函数参数的最后一个，否则会报错

下面这段代码演示了如何使用变长参数

例3：

func main() {
	slice := []int{7, 9, 3, 5, 1}
	x := min(slice...)
	fmt.Printf("The minimum 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
}

当然上面这段代码直接将切片作为参数也能实现同样的效果，但是变长参数更多的是为了参数不确定的情况，例如fmt包中的Printf函数设计如下：

func Printf(format string, a ...interface{}) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}

上面这段代码暂时看不懂也没关系，但是只需要记住，当你想传递给函数的参数不能确定有多少时可以使用变长参数。

6.4 多返回值

go语言中函数还支持一个特性那就是：多返回值。通过返回结果与一个错误值，这样可以使函数的调用者很方便的知道函数是否执行成功，这样的模式也被称为command,ok模式，在我们未来的程序设计中也推荐大家使用这种方式。下面这段代码显示了如何操作多返回值。

例4：

func div(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("The divisor cannot be zero.")
	}
	return a / b, nil
}

func main() {
	result, err := div(1, 2)
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}
	fmt.Println("result: ", result)
}

也可以下面这种模式

func main() {
	if result, err := div(1, 2); err != nil {
		fmt.Printf("error: %v", err)
		return
	} else {
		fmt.Println("result: ", result)
	}
}

注：多返回值需要使用()进行标记。

6.5 命名返回值

除了上面支持的多返回值，在go语言中还可以给返回值命名，当需要返回的时候，我们只需要一条简单的不带参数的return语句。我们将上面那个除法的函数修改一下

例5：

func div(a, b float64) (result float64, err error) {
	if b == 0 {
		return 0, errors.New("被除数不能等于0")
	}
	result = a / b
	return
}

注：即使只有一个命名返回值，也需要使用()括起来。

6.6 匿名函数

匿名函数如其名字一样，是一个没有名字的函数，除了没有名字外其他地方与正常函数相同。匿名函数可以直接调用，保存到变量，作为参数或者返回值。

例6：

func main() {
	f := func() string {
		return "hello world"
	}
	fmt.Println(f())
}

6.7 闭包

闭包可以解释为一个函数与这个函数外部变量的一个封装。粗略的可以理解为一个类，类里面有变量和方法，其中闭包所包含的外部变量对应着类中的静态变量。 为什么这么理解，首先让我们来看一个例子。

例7：

func add() func(int) int {
	n := 10
	str := "string"
	return func(x int) int {
		n = n + x
		str += strconv.Itoa(x)
		fmt.Print(str, " ")
		return n
	}
}

func main() {
	f := add()
	fmt.Println(f(1))
	fmt.Println(f(2))
	fmt.Println(f(3))

	f = add()
	fmt.Println(f(1))
	fmt.Println(f(2))
	fmt.Println(f(3))
}

程序输出：

string1 11
string12 13
string123 16
string1 11
string12 13
string123 16

如果不了解闭包肯定会感觉很奇怪，为什么输出这样的结果。这就要用到最开始的解释，闭关就是一个函数和一个函数外的变量的封装，而且这个变量对应着类中的静态变量。这样就可以将这个程序的输出结果解释通了

• 最开始我们先声明一个函数 add，在函数体内返回一个匿名函数
• 其中的 n，str 与下面的匿名函数构成了整个的闭包，n 与 str 就像类中的静态变量只会初始化一次，所以说尽管后面多次调用这个整体函数，里面都不会再重新初始化了
• 而且对于外部变量的操作是累加的，这与类中的静态变量也是一致的