携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第12天，点击查看活动详情

一、函数的定义

Go 语言中 函数 也是一种数据类型，有内存地址，且未被初始化的函数的值为 nil。

函数由函数名、参数和返回值组成，使用 func 关键字定义，{} 中定义函数体。

func funcName(arg1 argType, arg2 argType) (returnVar1 varType, returnVar2 varType) {
    //funcBody
}

Go 中函数的参数可以是不定长的，并且可以有多个返回值。

返回值的定义

函数的返回值第一种定义方式

Go 函数只有一个返回值是可以将括号省略，有多个返回值时需要使用括号报告，并且括号中的数据类型与 函数体中 return 关键字返回的变量一一对应。参数类型如果相同，可以只在最后一个参数后面跟上参数类型，其他可以省略。

func main(){

   sum := zuluAdd(1,4)
   fmt.Println(sum)
   sum1, isTrue := zuluAddwithTwoReturn(2, 6)
   fmt.Println(sum1, isTrue)

}

func zuluAdd(x, y int) int {
   return x + y
}

func zuluAddwithTwoReturn(x, y int) (int, bool) {
   return x + y, true
}

执行上述代码，输出结果如下：

5
8 true

函数的返回值第二种定义方式

返回值第二种定义方式，将返回值在函数定义的时候初始化，而不是在函数体内初始化(函数体中不要再使用 := 或者 var 定义返回变量)，并且可以省略 return 关键字后的返回值变量名。

func main(){

   sum := yankeeAdd(1,4)
   fmt.Println(sum)
   sum1, isTrue := yankeeAddwithTwoReturn(2, 6)
   fmt.Println(sum1, isTrue)

}

func yankeeAdd(x, y int) (sum int) {
   sum = x + y
   return
}

func yankeeAddwithTwoReturn(x, y int) (sum int, isTrue bool) {
   sum = x + y
   isTrue = true
   return
}

执行上述代码，输出结果如下：

5
8 true

第二种返回值的定义方式是最常用的

通过省略号设置不定长参数

Go 中的函数可以设置不定长参数，不定长参数有两种表示方式，第一种时使用 ... 表示

func main(){

   argsSum1, argsLen1 := xrayAddwithArgsByDots(2, 6)
   fmt.Println(argsSum1, argsLen1)

   argsSum2, argsLen2 := xrayAddwithArgsByDots(2, 6, 7, 9)
   fmt.Println(argsSum2, argsLen2)

}

func xrayAddwithArgsByDots(args ...int) (argsSum, argsLen int) {

   for _, val := range args {
      argsSum += val
   }

   argsLen = len(args)

   fmt.Printf("%T\n", args)

   return
}

执行上述代码，输出结果如下：

[]int
8 2
[]int
24 4

根据输出结果可以确定，不定长参数的类型是切片类型。

所以第二种表示不定长参数的表示方式就是可以直接放一个切片作为参数，因为切片时可以自动扩容的。

func main(){

   argsSum1, argsLen1 := xrayAddwithArgsBySlice([]int{2, 6})
   fmt.Println(argsSum1, argsLen1)

   argsSum2, argsLen2 := xrayAddwithArgsBySlice([]int{2, 6, 7, 9})
   fmt.Println(argsSum2, argsLen2)

}

func xrayAddwithArgsBySlice(args []int) (argsSum, argsLen int) {

   for _, val := range args {
      argsSum += val
   }

   argsLen = len(args)

   fmt.Printf("%T\n", args)

   return
}

这两种不定长参数的定义有什么区别？

首先可以确定的是切片是引用传递，那么 ... 传递是值传递还是引用传递？可以通过代码来进行验证。

func main(){

   args := []int{1, 3, 5}

   xrayAddwithArgsByDots(args...)

   fmt.Println(args)
   fmt.Printf("%v\n", &args[0])

   fmt.Println("传递单独赋值的变量")

   x := args[0]
   y := args[1]
   xrayAddwithArgsByDots(x, y)

   fmt.Println(args)
   fmt.Printf("%v\n", &args[0])

}

func xrayAddwithArgsByDots(args ...int)  {

   fmt.Printf("%v\n", &args[0])
   fmt.Println(args)
   args[0] = 100
   fmt.Println(args)
}

执行上述代码，输出结果如下：

0xc00001a078
[1 3 5]
[100 3 5]
[100 3 5]
0xc00001a078
传递单独赋值的变量
0xc00001c0e0
[100 3]
[100 3]
[100 3 5]
0xc00001a078

... 定义不定长参数传入一个切片进行拆解时，是引用传递，但是如果将切片拆解并单独赋值给变量，再讲赋值的变量传入不定长参数的函数，这种是值传递（本质上传递的还是基本数据类型）。

... 在 append 添加一个slice 的时候也会用到。

匿名函数

当函数只在某一处会使用，不会在其他地方使用时，为了避免函数名泛滥，可以定义匿名函数。匿名函数调用时参数在 {} 后面传递，使用 () 包裹。

func main(){

   res := func(x, y int) int {
      return x + y
   }(1, 2)

   fmt.Println(res)

   // 匿名函数的调用
   fmt.Println(func(x, y int) int {
      return x * y
   }(2, 3))

}

执行上述函数，输出代码如下：

3
6

二、函数的 ”一等公民（FirstClass）“ 特性

Go 中函数的 “一等公民” 特性是指函数可以存储在变量中，可以作为参数传递给函数，可以在函数中创建并作为返回值从函数返回。

函数存储在变量中

将函数赋值给一个变量，并查看变量的类型。

func main(){

   // 第一种定义方式，函数类型为 func(int, int) int, 类似其他如 float63， int64等
   var whiskeyFunc1 func(int, int) int = whiskeyAdd
   fmt.Printf("%T\n", whiskeyFunc1)

   // 直接使用 := 简写方式
   whiskeyFunc := whiskeyAdd
   fmt.Printf("%T\n", whiskeyFunc)

   res := whiskeyFunc(1, 2)

   fmt.Println(res)

}

func whiskeyAdd(x, y int) (sum int) {
   sum = x + y
   return
}

执行上述代码，输出结果如下：

func(int, int) int
func(int, int) int
3

要注意区分函数名和保存函数的变量名。

当然匿名函数也可以赋值给一个变量。

func main(){

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

   fmt.Println(funcVal(1, 2))
   
}

函数作为参数传递

使用 type 关键字自定义函数类型

首先自己定义出来一个类型，这个类型是函数类型，就跟 int 类型 map 类型是一样的

func main(){

   // 定义一个函数类型（自定义的函数类型）的变量，将victoryImpl函数赋值给函数变量
   var myVictor victor = victorImpl

   res := myVictor(7, 2)
   fmt.Println(res)

   // 也可以直接将匿名函数赋值给自定义的函数类型的变量

   var myVictor2 victor = func(x, y int) int {
      return x - y
   }

   fmt.Println(myVictor2(3, 2))

}

// 定义一个函数类型
type victor func (x, y int) int

// 定义一个函数实现
func victorImpl(x, y int) int {
   return x % y
}

执行上述代码，输出结果如下：

1
1

将函数作为另一个函数的参数

以一个过滤列表中的元素为例

func main(){

   balances := []int{10, 15, 13, 20, 22}

   fmt.Println(filter(balances))


}

func filter(balances []int) (greaterThanTen []int){

   greaterThanTen = make([]int, 0)

   for _, balance := range balances {
      if balance >= 10 {
         greaterThanTen = append(greaterThanTen, balance)
      }
   }

   return
}

执行上述代码，输出结果如下：

[10 15 13 20 22]

如果筛选条件变化了，那么可以将筛选条件定义为一个函数 greater，该函数返回布尔值，在 filter 函数中传入 greater 函数作为参数

func main(){

   balances := []int{10, 15, 13, 30, 22}

   // greater 函数赋值给一个变量
   greateFunuc := greater
   
   fmt.Println(filter(balances, greateFunuc))

}

func filter(balances []int, funcParam func(int, int) bool) (greaterThanTen []int){

   greaterThanTen = make([]int, 0)

   for _, balance := range balances {
      if greater(balance, 20) {
         greaterThanTen = append(greaterThanTen, balance)
      }
   }

   return
}


func greater(item, val int) (isGreater bool) {

   if item > val {
      return true
   }

   return false
}

执行上述代码，输出结果如下:

[30 22]

函数作为参数在链式处理类函数中应用也很广泛。