函数是组织好的、可重复使用的、用于执行指定任务的代码块。本文介绍了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 }
请发表评论