go基础-函数

概述

在任何语言中函数都是极其重要的内容，业务功能都是由一个或多个函数组合完成。go语言是函数式编程语言，函数是一等公民，可以被传递、有函数类型，go语言有三种类型的函数，普通函数、匿名函数（Lambda函数）、方法函数。go语言函数有独特属性，可以有多个返回值，需要使用多个变量接收、函数也是一种类型，函数签名是函数类型、函数不能被重载
 
基本使用

声明函数时必须包含参数类型、返回值类型。单个返回值可省略括号

1. fun sum(x int, y int) int {
2.     return x+y
3. }

复制代码

调用函数

1. n := sum(10, 20)    // 30

复制代码

 
两个返回值，多个返回值必须使用括号。

1. fun sum(x int, y int) (int, int) {
2.     return x+y, x-y
3. }

复制代码

使用两个变量接收

1. n, m := sum(x, y)

复制代码

 
返回值变量也可以在声明中定义

1. func sum(x int, y int) (a int, b int) {
2.     a = x + y
3.     b = x - y
4.     return
5. }

复制代码

在函数声明定义返回类型和返回值变量，使用return时可省略返回对象。
 
两个返回值一般用于错误处理，一个表示结果，一个表示错误。很多库函数都有类似的应用

1. func Open(name string) (file *File, err error)

复制代码

 
第一个返回值file表示文件指针，第二个返回值err表示打开文件异常，所以一般先判断是否有异常

1. file, err := open("test.txt")
2. if err != nil {
3.     fmt.Pringln("打开文件失败, ", err)
4.     return
5. }

复制代码

 
使用_表示忽略返回值

1. file, _ := open("test.txt")

复制代码

 
go语言函数也支持可变参数，注意可变参数必须在最后位置，固定是切片类型。

1. func sum(x int, args... int) int {
2.     for _, arg := range args {
3.         x += arg
4.     }
5.     return x
6. }
8. // 使用
9. i := sum(10, 20, 30, 40)

复制代码

 
当可变参数是一个空接口类型时，调用者是否解包可变参数会导致不同的结果：

1. func Print(a ...interface{}) {
2.     fmt.Println(a...)
3. }
5. func main() {
6.     var a = []interface{}{123, "abc"}
8.     Print(a...) // 123 abc
9.     Print(a)    // [123 abc]
10. }

复制代码

第一个 Print 调用时传入的参数是 a...，等价于直接调用 Print(123, "abc")。第二个 Print 调用传入的是未解包的 a，等价于直接调用 Print([]interface{}{123, "abc"})。
 
Go 语言函数还可以直接或间接地调用自己，也就是支持递归调用。相比其他语言 Go 语言函数的递归调用深度逻辑上没有限制，函数调用的栈不会出现溢出错误，因为 Go 语言运行时会根据需要动态地调整函数栈的大小。每个 goroutine 刚启动时只会分配很小的栈（4 或 8KB，具体依赖实现），根据需要动态调整栈的大小，栈最大可以达到 GB 级（依赖具体实现，在目前的实现中，32 位体系结构为 250MB，64 位体系结构为 1GB）

1. func f(x int) {
2.     if x > 1 {
3.         f(x-1)
4.     } else {
5.         fmt.Println(x)
6.     }
7. }

复制代码

1.  

复制代码

因为Go 语言函数的栈会自动调整大小，所以程序员很少需要关心栈的运行机制的，在 Go 语言规范中甚至故意没有讲到栈和堆的概念。我们无法知道函数参数或局部变量到底是保存在栈中还是堆中，只需要知道它们能够正常工作就可以了

1. func f(x int) *int {
2.     return &x
3. }
5. func g() *int {
6.     i := 20
7.     return i
8. }

复制代码

有C/C++经验的程序员会惊讶这两个函数有bug，因为参数变量在栈上维护，函数返回之后栈变量就失效了，返回的地址自然也应该失效了，返回的是野指针。在Go语言中可以正常工作，Go 编译器会保证指针指向的变量在合适的地方，不用关心 Go 语言中函数栈和堆的问题，编译器和运行时会帮我们搞定；同样不要假设变量在内存中的位置是固定不变的，指针随时可能会变化，特别是在你不期望它变化的时候。
 
函数类型

函数也是一种类型，即函数类型，也称为函数签名。

1. func sum(x int, y int) int {
2.     return x + y
3. }
5. func main() {
6.     fmt.Printf("%T\n", sum)    // 输出：func(int, int) int
7. }

复制代码

注意，签名中不包括函数名称
 
和C语言一样，go的函数名是只读指针，指向函数的首地址，所以go函数是引用类型。
把函数当参数传递时，复制出来的新指针，也指向相同的函数地址。注意不是复制函数，是复制函数指针，还有多种引用类型，如slice、map、chan、interface等。

1. func main() {
2.     fmt.Println(sum)            // 0x108ef60
3.     fmt.Printf("%v\n", sum)        // 0x108ef60
4.     fmt.Printf("%v\n", &sum)    // err
5. }

复制代码

两条语句结果一样，都打印函数的起始内存地址。注意无法使用地址符获取函数地址，这也说明不存在函数指针，更无法通过指针调用函数，这与C语言有区别，C语言回调函数经常使用这招儿。
 
在go语言中函数是一等公民，可以被传递、调用，这时就依赖函数类型

1. func handler(sum func(int, int, ) int, x int, y int) int {
2.     return sum(x, y)
3. }

复制代码

第一个参数是函数类型，接收函数做为参数，使用函数签名定义。
 
也可自定义类型，简单理解就是定义别名，简化写法

1. // 自定义类型
2. type sum func(int, int) int
4. // 接收自定义类型
5. func handler(plus sum, x int, y int) int {
6.     return plus(x, y)
7. }

复制代码

 
匿名函数

与JavaScript一样go也支持匿名函数，声明函数时不写名称

1. func main() {
2.     f := func(x int, y int) int {
3.         return x + y
4.     }
6.     fmt.Printf("%T\n", f) // func(int, int) int
7.     fmt.Println(f(1, 2)) // 3
8. }

复制代码

 
与普通函数一样使用、传递，匿名函数也有函数签名，也可自定义类型

1. // 自定义类型
2. type sum func(int, int) int
4. func main() {
5.     // 声明变量
6.     var f sum = func(x int, y int) int {
7.         return x + y
8.     }
10.     fmt.Printf("%T\n", f)
11.     fmt.Println(f(1, 2))
12. }

复制代码

 
函数闭包

闭包是函数式编程语言的招牌功能之一，go当然也支持闭包。简单来说就是函数可记住诞生时的环境信息，也称为记忆效应。

1. var str string = "hello"
3. func func1() {
4.     fmt.Println(str)
5. }

复制代码

函数func1应用引用了外部变量str，注意是“引用”，而非值传递，两者会相互影响，这与函数调用传参有本质区别。

1. func1()         // hello
2. str = "world"
3. func1()         // world

复制代码

 
更多使用动态生成匿名函数的方式，如下

1. func Accumulate(value int) func() int {
2.     // 返回一个闭包
3.     return func() int {
4.         // 引入外部变量value并累加
5.         value++
6.         // 返回一个累加值
7.         return value
8.     }
9. }

复制代码

 
返回值是一个函数，并且引用了外部变量value，该变量被会记录在函数内部，外部环境被销毁也不受影响，有点类似Python的装饰器。

1. // 创建一个累加器, 初始值为1
2. accumulator := Accumulate(1)
5. fmt.Println(accumulator())    // 2
6. fmt.Println(accumulator())    // 3

复制代码

每次调用value都会被累加，有点Java中lombda的感觉，
 
延迟执行

这是go特有的技能，函数内部被defer修饰的语句总是最后执行，有点类似java中finally的特性。

1. func main() {
2.     fmt.Println("defer begin")
3.     defer fmt.Println(1)
4.     defer fmt.Println(2)
5.     defer fmt.Println(3)
6.     fmt.Println("defer end")
7. }

复制代码

 
可以有多条defer修饰，与栈的数据结构一致，先进后出，输出如下

1. defer begin
2. defer end
3. 3
4. 2
5. 1

复制代码

 
注意，被defer修饰的预计总是最后执行，不再是顺序执行，与语句所在的位置无关。

1. func main() {
2.     fmt.Println("start time: ", time.Now())
3.     defer fmt.Println("end time: ", time.Now())
5.     time.Sleep(time.Duration(rand.Intn(1000)))
6.     fmt.Println("ok")
7.     return
8. } 

复制代码

不受return影响，end time预计总是在最后打印，输出如下

1. start time:  2023-07-19 23:45:51.551994 +0800 CST m=+0.000133126
2. ok
3. end time:  2023-07-19 23:45:51.552634 +0800 CST m=+0.000773430

复制代码

也不受panic的影响，程序崩溃前也会执行被defer修饰的语句
 
主要使用场景是异常捕获、回收资源、释放互斥锁等，因为被defer修饰的语句一定会在最后执行

1. func main() {
2.     fp, err := os.Open(filename)
3.     if err != nil {
4.         fmt.Println("open file error", err)
5.         return
6.     }
7.    
8.     // 最后一定会关闭文件
9.     defer f.Close()
11.     // 对文件指针fp进行操作
12.     ...
13. }

复制代码

 
也可以用于申请和释放锁

1. func main(key string) int {
2.     // 申请锁
3.     sync.Mutex.Lock()
4.     // 释放锁，延迟到函数结束时执行
5.     defer sync.Mutex.Unlock()
7.     // 业务逻辑
8.     ...
9. }

复制代码

 
特殊函数

go语言中有两个比较特殊的函数，在固定场景下使用
 
main函数，同C一样是程序的入口函数，只能有一个main函数，程序从这里开始执行，注意main函数只能属于main包。只有当代码包含有main函数时才可编译出可执行文件。

1. package main    // main包
2. import "fmt"
4. func main() {    // main函数
5.     fmt.Println("hello world")
6. }

复制代码

 
init函数，也称为初始化函数，会在main函数之前被自动调用，只要被import导入，该包所有init函数都被会自动执行，多次导入只执行一次。import是链式导入，init执行也是链式执行，如下图。
 
go执行顺序是：常量定义（const） -> 全局变量定义（var） -> 初始化函数（init） -> 程序入口（main）
要注意的是，在 main 函数执行之前所有代码都运行在同一个 Goroutine 中，也是运行在程序的主系统线程中。如果某个 init 函数内部用 go 关键字启动了新的 Goroutine 的话，新的 Goroutine 和 main.main 函数是并发执行的
 
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！