今天是 golang专题 的第八篇，我们来聊聊golang当中的函数。
我们在之前的时候已经介绍过了函数的基本用法，知道了怎么样设计或者是定义一个函数，以及怎么样调用一个函数，还了解了defer的用法。今天这篇文章我们来继续深入这个话题，来看看golang当中关于函数的一些 进阶 的用法。
返回error
前文当中我们曾经提到过，在golang当中并 没有try catch捕获异常的机制 。在其他语言当中异常只有一种，可以通过try catch语句进行捕获，而golang当中做了区分，将异常分为两种，一种是可以在函数当中返回的error，另外一种是严重的会引起程序崩溃的 panic 。
在golang中，error也是一个数据类型，由于golang支持函数的多值返回，所以我们可以设置一个返回值是error。我们通过对这个error的判断来获取运行函数的情况。
举个例子，比如说，假设我们实现一个Divide函数实现两个int相除。那么显然我们需要 除数不能为0 ，当除数为0的时候我们需要返回一个异常。这个时候我们可以把代码写成这样：
// Divide test
func Divide(a, b int) (ret int, err error) {
if b == 0 {
err = errors.New("divisor is zero")
return
}
return a / b, nil
}
当我们调用函数的时候，我们用两个变量去接收这个函数返回的结果，第二个变量的类型是error。当这个函数成功执行的时候第二个变量的结果为nil，我们只需要 判断它是否等于nil ，就可以知道函数执行是否成功。如果不成功，我们还可以记录失败的原因。
func main() {
ret, err := Divide(5, 2)
if err == nil {
fmt.Println(ret)
} else {
fmt.Println(err)
}
}
这种用法在golang当中非常常见，我们之前在介绍字符串相关操作的时候也介绍过返回error的用法。我们在设计函数的时候如果需要判断输入的合法性可以使用error，这样就可以保证handle住非法的情况，并且也能让下游感知到。
不定参数
不定参数的用法在很多语言当中都有，比如在 Python 当中，不定参数是*args。通过*args我们可以接受任何数量的参数，由于Python是弱变量类型的语言，所以args这些参数的类型可以互不相同。但是golang不行，golang严格限制类型， 不定参数必须要保证类型一样 。除此之外，其他的用法和Python一样，不定参数会以数组的形式传入函数内部，我们可以使用数组的api进行访问。
我们来看一个例子，我们通过…来定义不定参数。比如我们可以实现一个sum函数，可以将任意个int进行累加。
func Sum (nums ... int) int{
ret := 0
for _, num := range nums {
ret += num
}
return ret
}
我们来仔细研究一下上面这个例子，在这个例子当中，我们通过…传入了一个不定参数，我们不定参数的类型只写一次，写在…的后面。从底层实现的机制上来说，不定参数本质上是 将传入的参数转化成数组的切片 。但是这就有了一个问题，既然传入的是一个数组的切片，我们为什么要专门设置一个关键字，而不是规定传入一个切片呢？
比如上面的代码我们完全可以写成这样：
func Sum(nums []int) int{
ret := 0
for _, num := range nums {
ret += num
}
return ret
}
无论从代码的阅读还是编写上来看相差并不大，好像这样做完全没有意义，其实不是这样的。这个关键字简化的并不是函数的设计方，而是函数的使用方。如果我们规定了函数的输入是一个切片，那么当我们在传入数据的时候， 必须要使用强制转化 ，将我们的数据转化成切片，比如这样：
Sum([]int(3, 4, 6, 8))
而使用…关键字我们则可以省略掉强制转化的过程，上面的代码我们写成这样就可以了：
Sum(3, 4, 6, 8)
很明显可以看出差异，使用不定参数的话调用方会轻松很多，不需要再进行额外的转换。如果我们要传入的也是一个数组，那么 在传递的时候也需要用…符号将它展开 。
a := make([]int)
a = append(a, 3)
a = append(a, 4)
Sum(a...)
Sum(a[1:]...)
既然聊到不定参数的传递，那么又涉及到了一个问题，当我们想要像Python那样传递多个类型不同的参数的时候，应该怎么办呢？按照道理golang是静态类型的语言，限制死了参数的类型，是不能随便转换的才对。但是偏偏这样操作是可以的，因为golang当中有一个特殊的类型，叫做 interface 。
interface的用法很多，一个很重要的用法是用在面向对象当中充当结构体的接口。这里我们不做过多深入，我们只需要知道，interface的一个用法是 可以用来代替所有类型的变量 。我们来看一个例子：
func testInterface(args ...interface{}) {
for _, arg := range args {
switch arg.(type) {
case int:
fmt.Println("it's a int")
case string:
fmt.Println("it's a string")
case float32:
fmt.Println("it's a float")
default:
fmt.Println("it's an unknown type")
}
}
}
func main() {
testInterface(3, 4.5, "abc")
}
我们可以用.(type)获取一个interface变量实际的类型，这样我们就实现了任意类型任意数量参数的传入。
匿名函数和闭包
匿名函数我们在Python当中经常使用到，其实这个概念出现已久，最早可以追溯到1958年Lisp语言。所以这并不是一个新鲜的概念，只是传统的C、C++等语言没有支持匿名函数的功能，所以显得好像是一个新出现的概念一样。golang当中也支持匿名函数，但是golang当中匿名函数的使用方式和Python等语言稍稍有些不同。
在Python当中我们是通过lambda关键字来定义匿名函数，它可以被传入另一个函数当中，也可以赋值给一个变量。golang当中匿名函数的定义方式和普通函数基本是一样的， 只是没有函数名 而已，不过它也可以被传入函数或者是赋值给另一个变量。
比如：
s := func(a, b int) int {
return a + b
}
c := s(3, 4)
除了匿名函数之外，golang还支持 闭包 。闭包的概念我们在之前Python闭包的介绍当中曾经提到过，我们之前也用过好几次，闭包的本质不是一个包，而是一个函数， 是一个持有外部环境变量的函数 。比如在Python当中，我们经常可以看到这样的写法：
def outside(x):
def inside(y):
print(x, y)
return inside
ins = outside(3)
ins(5) #3, 5
我们可以看到outside这个函数返回了inside这个函数，对于inside这个函数而言，它持有了x这个变量。x这个变量并不是属于它的，而是定义在它的外部域的。并且我们在调用inside的时候是无法干涉这个变量的，这就是一个闭包的典型例子。根据轮子哥的说法， 闭包的闭的意思并不是封闭内部，而是封闭外部 。当外部scope失效的时候，函数仍然持有一份外部的环境的值。
golang当中闭包的使用方法大同小异，我们来看一个类似的例子：
func main() {
a := func(x int) (func(int)) {
return func(y int){
fmt.Println(x, y)
}
}
b := a(4)
b(5)
}
这个闭包的例子和刚才上面Python那个例子是一样的，唯一不同的是由于golang是强类型的语言，所以我们需要在定义闭包的时候将输入和输出的类型定义清楚。
总结
关于golang当中函数的高级用法就差不多介绍完了，这些 都是实际编程当中经常使用的方法 ，如果想要学好golang这门语言的话，这些是基本功。如果你之前有其他语言的基础，来写go的话，整体上手的难度还是不大的，很多设计都可以在其他的语言当中找到影子，有了参照来学会简单得多。
我很难描述实际工作当中写golang的体验，和我写任何一门其他的语言都不一样，有一种一开始期望很低，慢慢慢慢总能发现惊喜的感觉。我强烈建议大家去实际感受一下。
如果喜欢本文，可以的话，请 点个关注 ，给我一点鼓励，也方便获取更多文章。
本文始发于公众号： TechFlow
