Go语言基础（五）：函数

文章目录

一、函数定义二、函数的调用三、参数与返回值1、参数（1）类型简写（2）可变参数 2、返回值（1）多返回值（2）返回值命名（3）返回值补充 四、变量作用域1、全局变量2、局部变量（1）函数局部变量（2）语句块局部变量 五、函数类型与变量1、函数类型2、函数类型变量 六、高阶函数1、函数作为参数2、函数作为返回值 七、匿名函数和闭包1、匿名函数2、闭包 八、defer语句1、defer特性2、defer执行时机3、defer笔试经典案例 九、Go的内置函数 函数是组织好的、可重复使用的、用于执行指定任务的代码块。

一、函数定义

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

实例：

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

函数的参数和返回值都是可选的，无参数、返回值实例如下：

func sayHello() { fmt.Println("Hello 沙河") }

二、函数的调用

定义了函数之后，我们可以通过函数名()的方式调用函数。 例如我们调用上面定义的两个函数，代码如下：

func main() { sayHello() ret := intSum(10, 20) fmt.Println(ret) }

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

三、参数与返回值

1、参数

（1）类型简写

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

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

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

（2）可变参数

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

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

举个例子：

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

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

func intSum3(x int, y ...int) int {}

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

2、返回值

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

（1）多返回值

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

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

（2）返回值命名

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

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

（3）返回值补充

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

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

四、变量作用域

1、全局变量

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

package main import "fmt" var num int64 = 10 // 定义全局变量num func testGlobalVar() { fmt.Println(num) } func main() { testGlobalVar() }

2、局部变量

（1）函数局部变量

函数内定义的变量无法在该函数外使用，如下：

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

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

（2）语句块局部变量

语句块定义的变量，通常我们会在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 }

语句块局部变量只在本语句块生效！

五、函数类型与变量

1、函数类型

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

type calculation func(int, 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 calculation c = add

2、函数类型变量

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

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 }

六、高阶函数

1、函数作为参数

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 }

2、函数作为返回值

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

七、匿名函数和闭包

1、匿名函数

在python中，我们可以进行函数嵌套，但是在go中只允许在一个函数中嵌套一个匿名函数。

// 匿名函数定义 func(参数)(返回值){ 函数体 }

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

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

2、闭包

内层匿名函数中包含了对外层函数的变量的引用！

func adder() func(int) int { var x int return func(y int) int { x += y return x } } 或 func adder2(x int) func(int) int { return func(y int) int { x += y return x } }

八、defer语句

1、defer特性

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将ret返回时，将延迟处理的语句按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语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

2、defer执行时机

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

3、defer笔试经典案例

func f0() (x int) { x = 5 defer func() { x++ }() return } func f1() int { // 和上面的区别时这里的返回值只有类型 x := 5 defer func() { x++ }() return x // 返回值赋值后，返回值是5，defer再修改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(f0()) // 6 fmt.Println(f1()) // 5 fmt.Println(f2()) // 6 fmt.Println(f3()) // 5 fmt.Println(f4()) // 5 } 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)) fmt.Println("main函数执行完毕,该逆序执行两个defer语句了！") } 运行结果： A 1 2 3 B 10 2 12 main函数执行完毕,该逆序执行两个defer语句了！ BB 10 12 22 AA 1 3 4 /* 注：执行时，扫描到defer语句，先要执行里面的calc，让defer语句确定 因此先执行： calc("A", x, y) calc("B", x, y) 执行到最后时，延迟逆序调用defer语句 calc("BB", x, calc("B", x, y)) defer calc("AA", x, calc("A", x, y)) */

九、Go的内置函数

还有一个panic与recover这两个内置函数我后面要单独说明！