Go语言基础之函数

函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

函数定义

Go语言中定义函数使用func关键字，具体格式如下：

func function_name( [parameter list] ) [return_types] {   函数体}

函数定义解析：

  • func：函数由 func 开始声明
  • function_name：函数名称，函数名和参数列表一起构成了函数签名。
  • parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
  • return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
  • 函数体：函数定义的代码集合。

以下示例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：

/* 函数返回两个数的最大值 */func max(num1, num2 int) int {   /* 声明局部变量 */   var result int   if (num1 > num2) {      result = num1   } else {      result = num2   }   return result}
函数的调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

调用函数，向函数传递参数，并返回值，例如：

package mainimport "fmt"func main() {   /* 定义局部变量 */   var a int = 100   var b int = 200   var ret int   /* 调用函数并返回最大值 */   ret = max(a, b)   fmt.Printf( "最大值是 : %d\n", ret )}/* 函数返回两个数的最大值 */func max(num1, num2 int) int {   /* 定义局部变量 */   var result int   if (num1 > num2) {      result = num1   } else {      result = num2   }   return result}
以上实例在 main() 函数中调用 max()函数，执行结果为：
最大值是 : 200
参数
类型简写

函数的参数中如果相邻变量的类型相同，则可以省略类型，例如：

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

上面的代码中，intSum函数有两个参数，这两个参数的类型均为int，因此可以省略x的类型，因为y后面有类型说明，x参数也是该类型。

可变参数

有时候参数过多，或者想要让函数处理任意多个的参数，可以在函数定义语句的参数部分使用ARGS...TYPE的方式。这时会将...代表的参数全部保存到一个名为ARGS的slice中，注意这些参数的数据类型都是一致的。

...在Go中称为variadic，在使用...的时候(如传递、赋值)，可以将它看作是一个slice。

注意：可变参数通常要作为函数的最后一个参数。

举个例子：

func intSum2(x ...int) int {        fmt.Println(x) //x是一个切片        sum := 0        for _, v := range x {        sum = sum + v    }    return sum}

调用上面的函数：

ret1 := intSum2()ret2 := intSum2(10)ret3 := intSum2(10, 20)ret4 := intSum2(10, 20, 30)fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60

固定参数搭配可变参数使用时，可变参数要放在固定参数的后面，示例代码如下：

func intSum3(x int, y ...int) int {        fmt.Println(x, y)        sum := x        for _, v := range y {        sum = sum + v    }     return sum}

调用上述函数：

ret5 := intSum3(100)ret6 := intSum3(100, 10)ret7 := intSum3(100, 10, 20)ret8 := intSum3(100, 10, 20, 30)fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160

本质上，函数的可变参数是通过切片来实现的。

返回值

Go语言中通过return关键字向外输出返回值。

多返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来。

举个例子：

func calc(x, y int) (int, int) {  sum := x + y  sub := x - y  return sum, sub}
返回值命名

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。

例如：

func calc(x, y int) (sum, sub int) {  sum = x + y  sub = x - y  return}
返回值补充

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片。

func someFunc(x string) []int {  if x == "" {    return nil // 没必要返回[]int{}  }  ...}

其它编程语言中函数的返回值

  • C/C++ 语言中只支持一个返回值，在需要返回多个数值时，则需要使用结构体返回结果，或者在参数中使用指针变量，然后在函数内部修改外部传入的变量值，实现返回计算结果，C++ 语言中为了安全性，建议在参数返回数据时使用“引用”替代指针。
  • C# 语言也没有多返回值特性，C# 语言后期加入的 ref 和 out 关键字能够通过函数的调用参数获得函数体中修改的数据。
  • lua 语言没有指针，但支持多返回值，在大块数据使用时方便很多。

Go语言既支持安全指针，也支持多返回值，因此在使用函数进行逻辑编写时更为方便。

函数进阶

变量作用
全局变量

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。在函数中可以访问到全局变量。

package mainimport "fmt"// 定义全局变量numvar num int64 = 10func testGlobalVar() {  fmt.Printf("num=%d\n", num) // 函数中可以访问全局变量num}func main() {  testGlobalVar() // num=10}
局部变量

局部变量又分为两种：函数内定义的变量无法在该函数外使用，例如下面的示例代码main函数中无法使用testLocalVar函数中定义的变量x：

func testLocalVar() {  //定义一个函数局部变量x,仅在该函数内生效  var x int64 = 100  fmt.Printf("x=%d\n", x)}func main() {  testLocalVar()  fmt.Println(x) // 此时无法使用变量x}

如果局部变量和全局变量重名，优先访问局部变量。

package mainimport "fmt"//定义全局变量numvar num int64 = 10func testNum() {  num := 100  fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量}func main() {  testNum() // num=100}

接下来我们来看一下语句块定义的变量，通常我们会在if条件判断、for循环、switch语句上使用这种定义变量的方式。

func testLocalVar2(x, y int) {  fmt.Println(x, y) // 函数的参数也是只在本函数中生效  if x > 0 {    z := 100 // 变量z只在if语句块生效    fmt.Println(z)  }  //fmt.Println(z) // 此处无法使用变量z}

还有我们之前讲过的for循环语句中定义的变量，也是只在for语句块中生效：

func testLocalVar3() {  for i := 0; i < 10; i++ {    fmt.Println(i) // 变量i只在当前for语句块中生效  }  //fmt.Println(i) // 此处无法使用变量i}
函数类型与变量
定义函数类型

我们可以使用type关键字来定义一个函数类型，具体格式如下：

type calculation func(int, int) int

上面语句定义了一个calculation类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。

简单来说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。

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

add和sub都能赋值给calculation类型的变量。

var c calculationc = add
函数类型变量

我们可以声明函数类型的变量并且为该变量赋值：

func main() {  var c calculation               // 声明一个calculation类型的变量c  c = add                         // 把add赋值给c  fmt.Printf("type of c:%T\n", c) // type of c:main.calculation  fmt.Println(c(1, 2))            // 像调用add一样调用c  f := add                        // 将函数add赋值给变量f1  fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int  fmt.Println(f(10, 20))          // 像调用add一样调用f}
高阶函数

高阶函数分为函数作为参数和函数作为返回值两部分。

函数作为参数

函数可以作为参数：

func add(x, y int) int {  return x + y}func calc(x, y int, op func(int, int) int) int {  return op(x, y)}func main() {  ret2 := calc(10, 20, add)  fmt.Println(ret2) //30}
函数作为返回值
func do(s string) (func(int, int) int, error) {  switch s {  case "+":    return add, nil  case "-":    return sub, nil  default:    err := errors.New("无法识别的操作符")    return nil, err  }}
匿名函数和闭包
匿名函数

函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

func([parameter list]) [return_types] {    函数体}

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数：

func main() {  // 将匿名函数保存到变量  add := func(x, y int) {    fmt.Println(x + y)  }  add(10, 20) // 通过变量调用匿名函数  //自执行函数：匿名函数定义完加()直接执行  func(x, y int) {    fmt.Println(x + y)  }(10, 20)}

匿名函数多用于实现回调函数和闭包。

闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包 = 函数 + 引用环境。首先我们来看一个例子：

func adder() func(int) int {  var x int  return func(y int) int {    x += y    return x  }}func main() {  var f = adder()  fmt.Println(f(10)) //10  fmt.Println(f(20)) //30  fmt.Println(f(30)) //60  f1 := adder()  fmt.Println(f1(40)) //40  fmt.Println(f1(50)) //90}

变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。在f的生命周期内，变量x也一直有效。闭包进阶示例1：

func adder2(x int) func(int) int {  return func(y int) int {    x += y    return x  }}func main() {  var f = adder2(10)  fmt.Println(f(10)) //20  fmt.Println(f(20)) //40  fmt.Println(f(30)) //70  f1 := adder2(20)  fmt.Println(f1(40)) //60  fmt.Println(f1(50)) //110}

闭包进阶示例2：

func makeSuffixFunc(suffix string) func(string) string {  return func(name string) string {    if !strings.HasSuffix(name, suffix) {      return name + suffix    }    return name  }}func main() {  jpgFunc := makeSuffixFunc(".jpg")  txtFunc := makeSuffixFunc(".txt")  fmt.Println(jpgFunc("test")) //test.jpg  fmt.Println(txtFunc("test")) //test.txt}

闭包进阶示例3：

func calc(base int) (func(int) int, func(int) int) {  add := func(i int) int {    base += i    return base  }  sub := func(i int) int {    base -= i    return base  }  return add, sub}func main() {  f1, f2 := calc(10)  fmt.Println(f1(1), f2(2)) //11 9  fmt.Println(f1(3), f2(4)) //12 8  fmt.Println(f1(5), f2(6)) //13 7}

闭包其实并不复杂，只要牢记闭包=函数+引用环境。

说白了，闭包的底层原理就是：

  • 函数可以作为返回值
  • 函数内部查找变量的顺序：现在自己内部找，找不到往外层找
defer语句

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

举个例子：

func main() {  fmt.Println("start")  defer fmt.Println(1)  defer fmt.Println(2)  defer fmt.Println(3)  fmt.Println("end")}

输出结果：

startend321

由于defer语句延迟调用的特性，所以defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

defer执行时

在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。具体如下图所示：

defer经典案例

阅读下面的代码，写出最后的打印结果。

func f1() int {  x := 5  defer func() {    x++  }()  return x}func f2() (x int) {  defer func() {    x++  }()  return 5}func f3() (y int) {  x := 5  defer func() {    x++  }()  return x}func f4() (x int) {  defer func(x int) {    x++  }(x)  return 5}func main() {  fmt.Println(f1())  fmt.Println(f2())  fmt.Println(f3())  fmt.Println(f4())}

内置函数介绍


在builtin包中有一些内置函数： 

func close(c chanType)func delete(m map[Type]Type1, key Type)func panic(v interface{})func print(args ...Type)func println(args ...Type)func recover() interface{}func complex(r, i FloatType) ComplexTypefunc imag(c ComplexType) FloatTypefunc real(c ComplexType) FloatTypefunc append(slice []Type, elems ...Type) []Typefunc make(t Type, size ...IntegerType) Typefunc new(Type) *Typefunc cap(v Type) intfunc copy(dst, src []Type) intfunc len(v Type) int
  • close用于关闭channel
  • delete用于删除map中的元素
  • copy用于拷贝slice
  • append用于追加slice
  • cap用于获取slice的容量
  • len用于获取
  • slice的长度
  • map的元素个数
  • array的元素个数
  • 指向array的指针时，获取array的长度
  • string的字节数
  • channel的channel buffer中的未读队列长度
  • print和println：底层的输出函数，用来调试用。在实际程序中，应该使用fmt中的print类函数
  • complex、imag、real：操作复数(虚数)
  • panic和recover：处理错误
  • new和make：分配内存并初始化
  • new适用于为值类(value type)的数据类型(如array,int等)和struct类型的对象分配内存并初始化，并返回它们的指针给变量。如v := new(int)
  • make适用于为内置的引用类的类型(如slice、map、channel等)分配内存并初始化底层数据结构，并返回它们的指针给变量，同时可能会做一些额外的操作

注意：地址和指针是不同的。地址就是数据对象在内存中的地址，指针则是占用一个机器字长(32位机器是4字节，64位机器是8字节)的数据，这个数据中存储的是它所指向数据对象的地址。

a -> AAAAb -> Pointer -> BBBB

new()和make()构造数据对象赋值给变量的都是指向数据对象的指针。

panic/recove

Go语言中目前(Go1.12)是没有异常机制，但是使用panic/recover模式来处理错误。panic可以在任何地方引发，但recover只有在defer调用的函数中有效。首先来看一个例子：

func funcA() {  fmt.Println("func A")}func funcB() {  panic("panic in B")}func funcC() {  fmt.Println("func C")}func main() {  funcA()  funcB()  funcC()}

输出：

unc Apanic: panic in Bgoroutine 1 [running]:main.funcB(...)        .../code/func/main.go:12main.main()        .../code/func/main.go:20 +0x98

程序运行期间funcB中引发了panic导致程序崩溃，异常退出了。这个时候我们就可以通过recover将程序恢复回来，继续往后执行。

func funcA() {  fmt.Println("func A")}func funcB() {  defer func() {    err := recover()    //如果程序出出现了panic错误,可以通过recover恢复过来    if err != nil {      fmt.Println("recover in B")    }  }()  panic("panic in B")}func funcC() {  fmt.Println("func C")}func main() {  funcA()  funcB()  funcC()}

注意：

  1. recover()必须搭配defer使用。
  2. defer一定要在可能引发panic的语句之前定义。

递归函数

递归，就是在运行的过程中调用自己。

语法格式如下：

func recursion() {    recursion() // 函数调用自身}func main() {    recursion()}

Go语言支持递归。但我们在使用递归的时候，开发者需要设置退出条件，否则递归将陷入无限循环中。

递归函数对于解决数学上的问题是非常有用的，就像计算阶乘，生成斐波那契数列等。

阶乘

以下实例通过Go语言的递归函数实现阶乘：

package mainimport "fmt"/*  递归实现阶乘  例：15的阶乘 = 15 * 14 * 13 * 12 * 11 * ...*/func factorial(n uint64) (result uint64) {  if n > 0 {    result = n * factorial(n-1)    return result  }  return 1}func main() {  var i int = 15  fmt.Printf("%d 的阶乘是 %d\n", i, factorial(uint64(i)))}

输出：

15 的阶乘是 1307674368000

函数的运用

分金币

package mainimport (  "fmt")/*  你有30枚金币，需要分配给以下几个人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。  分配规则如下：  a. 名字中每包含1个'e'或'E'分1枚金币  b. 名字中每包含1个'i'或'I'分2枚金币  c. 名字中每包含1个'o'或'O'分3枚金币  d: 名字中每包含1个'u'或'U'分4枚金币  写一个程序，计算每个用户分到多少金币，以及最后剩余多少金币？注意金币不能超分！  程序结构如下，请实现 ‘dispatchCoin’ 函数*/var (  coins = 30  users = []string{    "Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",  }  distribution = make(map[string]int, len(users)))func main() {  left := dispatchCoin()  fmt.Println("剩下：", left)}func dispatchCoin() int {  // 遍历 users 切片，得到每个人的名字  for _, v := range users {    distribution[v] = 0    // 得到一个人的名字，根据分金币的规则去分金币    // 每个人分到的金币数应该保存到 distribution 中    for _, value := range v {      switch value {      case 'e', 'E':        distribution[v]++        if coins > 0 {          coins--        } else {          break        }      case 'i', 'I':        distribution[v] += 2        if coins > 0 {          coins -= 2        } else {          break        }      case 'o', 'O':        distribution[v] += 3        if coins > 0 {          coins -= 3        } else {          break        }      case 'u', 'U':        distribution[v] += 4        if coins > 0 {          coins -= 4        } else {          break        }      }    }  }  fmt.Println(distribution)  // 记录剩余的金币数  return coins}