函数

在GO语言中，函数的基本组成为func关键字，函数名，参数列表，返回值，函数体和返回语句。

1. 函数的定义

首先，我们通过一个最简单的加法函数来进行说明

package mymath

import "errors"

func Add(a int, b int) (ret int, err error) {
    if a < 0 || b < 0 { //假定函数只支持两个非负数相加
        err = errors.New("Should be non-negative numbers")
        return
    }
    return a + b, nil //支持多返回值
}

上面的函数中，(ret int, err error)表示多返回值，error是Go中特有的错误处理包。
后面我们会单独介绍这个包。

2. 函数调用

Go语言的函数调用非常简单，只要事先导入了该包。我们就可以按照如下方式调用。

import "mymath" //第1节中，我们定义了mymath包，这里我们导入这个包

c := mymath.Add(1, 2) 

注意在Go语言中，函数名以大写字母开头，才会被包导出，如果你不小心将上面的函数写为
func add(a int, b int)，这样在mymath.add(1, 2)使用时，编译器会告诉你无法
找到add函数。也就是说，小写字母开头的函数，在包外部是不可引用的。

3. 不定参数

在C语言时代，大家都用过printf()函数，不定参数带给我们的方便想必大家已经领略过了。下面
我们看看Go语言是如何支持不定参数的。

3.1 不定参数类型

我们首先把函数定义为接收不定参数类型:

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

这段代码的意思是myfunc函数接收不定数量的参数，这些参数全是int，所以要按照如下方式
调用:

myfunc(1, 2, 3, 4)
myfunc(2, 3, 5)

在上面的不定参数定义中，形入...type格式的类型只能作为函数的参数类型存在。并且必须是
最后一个参数。\

语法糖(syntactic sugar) ...type这样的语法对语言的功能并没有影响，但是更方便程序员
的调用。通常来说，使用语法糖能够增加程序的可读性，从而减少程序出错的机会。
从内部实现上来说，类型...type本质上是一个数组切片，也就是[]type，这也是上面为什么能
用range遍历的原因。
如果没有...type语法糖，则开发者就必须这样写：

func myfunc(args []int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

从函数的角度看，没有语法糖并没有什么影响，只是写法不同而已。
但是，从调用的角度来看，情况就完全不同。

myfunc([]int{1, 2, 3,4})

对比使用...type语法糖实现来看，调用时的写法会打不相同，语法糖使我们使用不定参数
更加便捷。

3.2 不定参数的传递

假设有另一个不定函数叫做myfunc2(arg ...int).

func myfunc(args ...int) {
    myfunc2(args...)  //按原样传递
    myfunc2(args[1:]...) //slice的特性在这里也可以使用
}

3.3 任意类型的不定参数

上面的例子中，我们将不定参数类型定为int型。下面我们来看看传递任意类型的实现。
我们不定参数类型知道为interface{}，下面是fmt.Printf()函数原型

func Printf(format string, args ...interface{})

下面代码展示了如何分离传入的不同类型数据

package main

import "fmt"

func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
                fmt.Println(arg, "is an int value.")
            case string:
                fmt.Println(arg, "is an string value.")
            case int64:
                fmt.Println(arg, "is an int64 value.")
            case default:
                fmt.Println(arg, "is an unknown value.")
        }
    }
}

4. 多返回值

不同于C语言，Go语言一个函数可以有多个返回值，这样能让我们的代码更加简洁。
比如File.Read()函数，可以同时返回读取的字节数和错误信息，如果读取成功，则返回
值中的n为读取的字节数，err为nil。否则，err为错误信息。

Func (file *File) Read(b []byte) (n int, err error) {}

Go语言不需要强制命名返回值，但是命名返回值可以让代码更清晰，也可用于文档。
如果我们不想使用某个返回值，可以用 "_"忽略，例如：

n, _ := f.Read(buf) //忽略返回的错误信息

5. 匿名函数与闭包

匿名函数是指不需要定义函数名的一种函数实现方式。

5.1 匿名函数

匿名函数定义如下

func(a, b int, z float64) bool {
    return a*b < int(z)
}

匿名函数可以直接赋值给一个变量

f := func(x, y int) int {
    return x + y
}

func (ch chan int) {
    ch <- ACK
} (reply_chan) //花括号后面跟参数列表，表示函数调用

5.2 闭包

匿名函数是一个闭包。下面我们来了解一下闭包的概念，价值和应用场景。

基本概念

闭包是可以包含自由(未绑定到特定对象)变量的代码块。这些变量不在这个代码块内或者
任何全局上下文，而是在定义代码块的环境中定义。要执行的代码块为自由变量提供绑定的计算
环境(作用域)

闭包的价值

闭包的价值在于可以作为函数对象或者匿名函数。对象类型系统而言，这意味着不仅要表示数据，
还要表示代码。这些函数可以存储到变量中作为参数传递给其他函数，最重要的是能够被函数
动态创建和返回。

Go语言中的闭包

Go语言中的闭包同样也会引用到函数外的变量。闭包的实现确保只要闭包还被使用，那么，被闭包
引用的变量会一直存在。

package main

import (
    "fmt"
)

func main() {
    var j int = 5
    
    a := func() (func()) {
        var i int = 10
        return func() {
            fmt.Printf("i, j: %d, %d\n", i, j)
        }
    } ()
    
    a()
    
    j += 2
    
    a()
}

上述代码执行的结果为：

i, j: 10, 5
i, j: 10, 7

上面的例子中，变量a指向的闭包函数引用了局部变量i和j，i的值被隔离，在闭包之外不可被
修改。只要匿名函数内部才能修改i的值，保证了i的安全性。

有疑问加站长微信联系（非本文作者）