Go语言 - 函数 | 作用域 | 匿名函数 | 闭包 | 内置函数

函数是组织好的、可重复使用的、用于执行指定任务的代码块。本文介绍了Go语言中函数的相关内容。

 介绍

Go语言中支持函数、匿名函数和闭包，并且函数在Go语言中属于“一等公民”。

• 函数可以赋值给变量
• 函数可以被当做参数传入函数
• 函数可以被调用

函数定义

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

func 函数名(参数)(返回值){
    函数体
}
//  函数可以无参数, 无返回值

• 函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也称不能重名（包的概念详见后文）。
• 参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。
• 返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用,分隔。
• 函数体：实现指定功能的代码块。

// 定义函数
func seyHello()  {
    fmt.Println("hello func")
}
func intSum(x int, y int) int {
    return x + y
}

函数调用

func main()  {
    // 函数调用
    seyHello()  // hello func
    res := intSum(1, 2)  // 传参
    fmt.Println(res)  // 3
}

注意，调用有返回值的函数时，可以不接收其返回值。

 参数

• 同类型参数简写

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

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

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

•  可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。

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

func intSum1(x ...int) int {
    fmt.Printf("%T \n", x)  // []int
    sum := 0
    for _, v := range x{
        sum = sum + v
    }
    return sum
}
func main()  {
    res1 := intSum1(1, 2, 3)
    fmt.Println(res1)  // 6
}

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

func intSum2(x int, y ...int) int {
    fmt.Printf("%T \n", y)  // []int
    sum := 0
    for _, v := range y{
        sum = sum + v
    }
    return sum
}
func main()  {
    res2 := intSum2(0)  // x=0, y=[]
    res3 := intSum2(0, 1 )  // x=0, y=[1]
    res4 := intSum2(0, 1, 2, 3)  // x=0, y=[1 2 3]
    fmt.Println(res2, res3, res4)  // 0 1 6
}

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

 返回值

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

• 多返回值

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

func ret(x, y int) (int, int) {
    sum := x + y
    sub := x - y
    return sum, sub
}
func main()  {
    res, res1 := ret(5, 3)
    fmt.Println(res, res1)  // 8 2
}

• 返回值命名

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

func calc(x, y int) (sum, sub int) {
    sum = x + y
    sub = x - y
    return
}

函数作为变量的值

func test()  {
    x := 10
    fmt.Println(x)
}
func main()  {
    f := test
    fmt.Printf("%T \n", f)  // func()
    f()  // 10
}

函数作为参数

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

func test1(x, y int, op func(int, int)int) int {
    return op(x, y)
}

func main()  {
    res := test1(10, 20, add)
    fmt.Println(res)  // 30
}

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")
}

 结果:

start
end
3
2
1

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

defer执行时机

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

 面试题1

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())
}
结果: 5 6 5 5

面试题2

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    x := 1
    y := 2
    defer calc("AA", x, calc("A", x, y))
    x = 10
    defer calc("BB", x, calc("B", x, y))
    y = 20
}

 

变量作用域

• 全局变量

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

package main

import "fmt"

var a = 10
func test()  {
    // 先在函数内部作用域查找变量
    // 再到全局作用域查找变量
    fmt.Println(a)  
}

func main()  {
    test()  // 10
}

• 局部变量

 局部变量只能在局部使用,外部若想使用局部变量,需要通过返回值的形式拿到变量的值再使用

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

func main() {
    testLocalVar()
    fmt.Println(x) // 此时无法使用变量x
}

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

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

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

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

 Go语言中,名称空间的查找是一层一层向外查找,先找自己,没有再找外层,外层不能使用内层的名称空间

 

匿名函数

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

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

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

package main

import "fmt"

func main()  {
    // 定义匿名函数方式一
    add := func (x, y int)  {
        fmt.Println(x + y)
    }
    add(1, 2)  // 通过变量调用匿名函数

    // 定义匿名函数方式二
    func (x, y int)  {
        fmt.Println(x - y)
    }(20, 5)  //自执行函数：匿名函数定义完加()直接执行
}

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

 闭包

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

eg: 函数作为返回值

package main

import "fmt"

func a() func() {
    return func ()  {
        fmt.Println("函数作为返回值")
    }
}

func main()  {
    f := a()  // 相当于执行了a函数,将返回值(匿名函数)赋值给了变量f
    f()  // 相当于执行了匿名函数
}

 eg: 内层函数引用外层函数名称空间中的变量 即 闭包

func a() func() {
    name := "熊二"
    return func ()  {
        fmt.Println("hello", name)
    }
}

func main()  {
    f := a()  // f此时就是一个闭包
    f()  // hello 熊二
}

 

// 函数a中的形参,相当于在a函数中声明了一个变量
func a(name string) func() {
    return func ()  {
        fmt.Println("hello", name)
    }
}

func main()  {
    f := a("熊二") 
    f()   // hello 熊二 

进阶案例1

package main

import (
    "fmt"
    "strings"
)

func makeSuffixFunc(suffix string) func(string) string {
    return func(name string) string {
        // HasSuffix 用来判断目标是以什么为结尾,返回bool值
        if !strings.HasSuffix(name, suffix) {
            return name + suffix
        }
        return name
    }
}

func main()  {
    f1 := makeSuffixFunc(".txt")
    res1 := f1("熊大")  
    fmt.Println(res1)  // 熊大.txt
    f2 := makeSuffixFunc(".txt")
    res2 := f2("熊大.txt")  
    fmt.Println(res2)  // 熊大.txt
}

 进阶案例2

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

 

内置函数介绍

内置函数	介绍
close	主要用来关闭channel
len	用来求长度，比如string、array、slice、map、channel
new	用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
make	用来分配内存，主要用来分配引用类型，比如chan、map、slice
append	用来追加元素到数组、slice中
panic和recover	用来做错误处理

panic/recover

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()
}

输出：

func A
panic: panic in B

goroutine 1 [running]:
main.funcB(...)
        .../code/func/main.go:12
main.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的语句之前定义