声明函数

func 函数名(传入参数)  (返回值) {
   函数体
}

用func关键字声明一个函数。传入参数是一个或者多个，返回值也是一个或者多个（这一点和别的语言不太一样，Go语言支持多返回值）。

基本用法

func f1(x int, y int) (int ,int ){
   return x+y,x-y
}

func f2(x int,y int) (int,int ) {
   return x*y,x/y
}

func main()  {
   a,b := f1(3,4)
   c, d := f2(3,4)
   fmt.Printf("a=%d n",a) // a=7
   fmt.Printf("b=%d n",b) // b=-1
   fmt.Printf("c=%d n",c) // c=12
   fmt.Printf("d=%d n",d) // d=0
}

f1是一个具体的函数，其中x,y是传入参数，定义函数时指定的传入参数称为「形参」。a,b := f1(3,4)是对函数f1的调用，其中a,b会顺序接收f1的返回值。3,4是「实参」，Go语言中实参是按值传递的，所以函数接收到的是每个实参的副本。如果实参包含了引用类型比如：指针、slice、map、函数、channel，则函数接收到的是指针地址的副本。

f1和f2两个函数，传入参数类型和顺序是完全相同的，返回值的个数和类型也是完全相同。在Go语言中，传入参数和返回参数完全相同的函数是同一类函数。

Go语言中的类型（type）也是非常重要的概念，我们后续单独写文章介绍，当前只需要记住判断两个函数是否同类型的标准就可以了。

返回值

Go语言中的函数可以有多个返回值，同时我们也可以对返回值进行命名。

func f1(x int, y int) (sum int , differe int ){
   sum = x+y
   differe = x-y
   return
}

func f2(x int, y int) (sum int , differe int ){
   sum = x+y
   differe = x-y
   return x,y
}

func main()  {
   a,b := f1(3,4)
   c,d := f2(3,4)
   fmt.Printf("a=%d n",a) // print a=7
   fmt.Printf("b=%d n",b) // print b=-1
   fmt.Printf("c=%d n",c) // print a=3
   fmt.Printf("d=%d n",d) // print b=4
}

如示例中的f1，对函数返回值显式命名时，return后面可以省略返回值。如果即给返回值命名，又return了返回值，return后面的返回值会生效，所以f2的返回结果是3，4。

匿名函数

匿名函数就是没有名字的函数，通常有两种使用方式。如下示例：

func main()  {
   a,b := 1,2
   // 方式一 把匿名函数复制给变量
   f1 := func() int{
      return a+b
   }
   fmt.Printf("f1的执行结果：%d n",f1());

   // 方式二 直接调用
   sum := func() int{
      return a+b
   }()
   fmt.Printf("f2的执行结果：%d n",sum);
}

可以把匿名函数赋值给一个变量，然后在后面添加()调用，也可以在匿名函数后面直接跟()调用。匿名函数也可以有传入参数。我们再来看一个例子：

func main()  {
   a := 1

   go func(b int) {
      time.Sleep(100*time.Millisecond)
      fmt.Println("a2=", b) // print a2=1
   } (a)

   a++
   fmt.Println("a1=", a) // print a1=2
   time.Sleep(5*time.Second)
}

匿名函数在一个Go rountine中运行，传入了值a，然后外面的变量a++，此时a变成了2，但是协程中的a仍然是1，这是因为匿名函数和普通的函数一样，调用时都会对实参的值进行拷贝。

不定长度函数

如fmt.Println()函数，传入的参数个数是不确定的。我们实现一个输出最大值的函数max()，可以接收到不定长的参数。

import "fmt"

func max(val ...int) int{
   var ret int
   for _,m := range val{
      if ret < m {
         ret = m
      }
   }
   return ret
}

func main()  {
   fmt.Printf("max=%d n",max(3,4,6,9,0)) // print  9
   fmt.Printf("max=%d n",max(-1,8,65)) // print 65

   arr := []int{99,23,56,8,12,5}
   fmt.Printf("max=%d n",max(arr...)) // print 99
}

如上示例，max函数接收int类型的参数不确定个数。Go语言中函数的最后一个形参类型前加...代表不限定参数个数。

高阶函数

当一个函数满足以下两个条件之一时，我们称之为高阶函数：

接受一个或多个函数作为输入
返回一个函数

下面我们举两个例子说明下高阶函数如何使用。
例1：实现红绿灯功能，每隔一秒，灯的颜色变换一次。

import (
   "fmt"
   "time"
)

// 高阶函数，传入的handler函数执行红绿灯切换
func highFun(s []string ,handler func(string,time.Duration))  func(){
   var count = 0
   var f func()
   f = func() {
      m := s[count%len(s)] // 通过对count取余，循环获取数组下表
      handler(m,2*time.Second)
      time.Sleep(2*time.Second)
      count++
      f()
   }
   return f
}

func main()  {
   f := func(color string, t time.Duration) {
      fmt.Printf("等待 %v 秒后，%s 灯亮。 n", t, color)
   }
   light := highFun([]string{"红灯","绿灯","黄灯"},f)
   light()
}

我们定义highFun函数，用来控制等待时间，并触发handler函数控制红绿灯切换；同时把控制函数f,作为返回值返回，让调用方决定何时调用。

例2：统计数组中各单词出现的频率。

我们首先实现一个类似javascript中的reduce方法，不断对当前函数f()的返回值和数组中的下一个元素调用f()方法；然后通过一个匿名函数，累加相同单词的数量，完成统计功能。

import "fmt"

func reduce(arr []string, f func(string,map[string] int) map[string] int , m map[string] int) func(arr []interface{}, f func(...interface{}) , m map[string] int) {
   if len(arr) >0 {
      return reduce(arr[1:],f,f(arr[0],m))
   }
   return nil
}

func countWord(arr []string)  {
   m := make(map[string] int)
   reduce(arr, func(s string, m map[string]int) map[string]int {
      m[s]++
      return m
   },m)
   fmt.Printf("统计结果：%v n",m) // print map[bad:2 beautiful:2 good:2] 
   return
}
func main()  {
   var arr = []string{"good","bad","beautiful","bad","good","beautiful"}
   countWord(arr)
}