函数是组织好的、可重复使用的、用于执行指定任务的代码块。本文介绍了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) //
}
注意，调用有返回值的函数时，可以不接收其返回值。
参数
同类型参数简写
函数的参数中如果相邻变量的类型相同，则可以省略类型，例如：
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) //
}
固定参数搭配可变参数使用时，可变参数要放在固定参数的后面，示例代码如下：
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() //
}
函数作为参数
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) //
}
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() //
}
局部变量
局部变量只能在局部使用,外部若想使用局部变量,需要通过返回值的形式拿到变量的值再使用
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()
}
recover()必须搭配defer使用。defer一定要在可能引发panic的语句之前定义
