devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Golang基础3-函数、nil相关

作者：我家小花儿 | 2024-04-24 21:30:27

赞

踩

Golang基础3-函数、nil相关

函数

    • 需要声明原型
    • 支持不定参数 func sum(numbers ...int)int
    • 支持返回多值
    • 支持递归
    • 支持命名返回参数
  1. // 命名返回参数
  2. func add(a, b int) (sum int) {
  3.     sum = a + b
  4.     return // 这里不需要显式地写出返回值，因为已经在函数签名中声明了命名返回参数
  5. }
    • 支持匿名函数、闭包
    • 函数也是一种类型，函数可以赋值给变量（本质函数指针）
    • 一个包中能有名字一样的函数
    • 不支持：重载（==，!=等等均不支持)，默认参数

简单demo

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. //测试函数
  6. func test(x, y int, s string) (int, string) {
  7.     n := x + y
  8.     return n, fmt.Sprintf("%s,%d\n", s, n)
  9. }
  10. func main() {
  11.     a, b := test(1, 2, "你好")
  12.     // _可以忽略某些值的返回
  13.     fmt.Println(a)
  14.     fmt.Println(b)
  15.  
  16. }

回调函数demo

回调函数本质其实就是函数指针作为形参，传递给了函数，增加了代码的灵活度。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. // 回调函数1
  6. func testFunc(fn func() int) int {
  7.     return fn()
  8. }
  9.  
  10. // 定义函数类型
  11. type FormatFunc func(s string, x, y int) string
  12.  
  13. func format(fn FormatFunc, s string, x, y int) string {
  14.     return fn(s, x, y)
  15. }
  16.  
  17. func formatHelper(s string, x, y int) string {
  18.     return fmt.Sprintf(s, x, y)
  19. }
  20.  
  21. func main() {
  22.     s1 := testFunc(func() int {
  23.         return 100
  24.     })
  25.     fmt.Println(s1) //100
  26.  
  27.     //匿名函数，回调进行格式化返回string
  28.     //s2 := format(func(s string, x, y int) string {
  29.     //    return fmt.Sprintf(s, x, y)
  30.     //}, "%d %d", 10, 20)
  31.     s2 := format(formatHelper, "%d %d", 10, 20)
  32.     fmt.Println(s2)
  33. }

闭包demo

闭包很简单，可以理解为返回值是一个函数指针，其他的再看就很好理解了。

https://juejin.cn/post/6844903793771937805

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5. )
  6.  
  7. //返回函数指针 func()int
  8. func a() func() int {
  9.     i := 0
  10.     b := func() int {
  11.         i++
  12.         fmt.Println(i)
  13.         return i
  14.     }
  15.     return b
  16. }
  17.  
  18. func main() {
  19.     //a执行完返回func() int 的这个函数指针，其中赋值给c，
  20.     //那么这里面保存有这个b匿名函数的所有信息，实现了自增，可以不用定义全局变量
  21.     c := a()
  22.     c()
  23.     c()
  24.     c()
  25.     //因为这个是函数指针
  26.     a() //不会输出i
  27. }

递归demo

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. // 递归1，求阶乘
  6. func Factorial(n int) int {
  7.     if n <= 1 {
  8.         return 1
  9.     }
  10.     return n * Factorial(n-1)
  11. }
  12.  
  13. // 递归2，斐波那契数列
  14. func Fibonaci(n int) int {
  15.     if n == 0 {
  16.         return 0
  17.     }
  18.     if n == 1 {
  19.         return 1
  20.     }
  21.     return Fibonaci(n-1) + Fibonaci(n-2)
  22. }
  23. func main() {
  24.     fmt.Println("5!=", Factorial(5))
  25.  
  26.     fmt.Println("前10项斐波那契数列：")
  27.     for i := 0; i < 10; i++ {
  28.         fmt.Printf("%d\t", Fibonaci(i))
  29.     }
  30. }

异常处理demo

参考文档：异常处理 · Go语言中文文档

使用panic抛出错误，defer捕获错误，一般panic中抛出异常，defer中捕获异常，之后正常处理。

panic:

内置函数，panic后的代码不执行， interface{}，直到goroutine整个退出并报告错误，

recover:

1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。

2.recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。

3.多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。

painc处理demo

painc会导致程序直接退出，平时开发中尽量不随便使用。

一般场景：我的服务想要启动，必须依赖某些服务、日志、mysql能联通，配置文件没问题，那么才能启动的时候，直接使用panic

一旦服务启动，这时你的某行代码不小心触发panic，那么这就是重大事故（比如别人请求，你直接挂了）

但是架不住有些地方被动触发panic，这时就引入了recover来捕获panic

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. // painc部分后面代码不执行
  6. func test() {
  7.     defer func() {
  8.         if err := recover(); err != nil {
  9.             println("recover panic:", err.(string))
  10.         }
  11.     }()
  12.     panic("panic错误测试！")
  13.     //panic后的代码不执行
  14.     //fmt.Println("panic后代码")
  15. }
  16.  
  17. func main() {
  18.     test()
  19.     fmt.Println("main")
  20. }

error处理 demo
  1. package main
  2.  
  3. import (
  4.     "errors"
  5.     "fmt"
  6. )
  7.  
  8. func A() (int, error) {
  9.     return 2, errors.New("this is an error")
  10.  
  11. }
  12.  
  13. func main() {
  14.     if _, err := A(); err != nil {
  15.         fmt.Println(err)
  16.     }
  17. }

recover捕获panic的demo

recover需要延迟调用，也就是必须在defer的函数内部，否则返回nil

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func except() {
  6.     fmt.Println("except延迟函数调用!")
  7.     fmt.Println("except延迟函数recover:", recover())
  8. }
  9.  
  10. func recoveryDemo() {
  11.  
  12.     //等效于下面的匿名延迟函数
  13.     defer except()
  14.  
  15.     //延迟调用，recover在函数内部
  16.     defer func() {
  17.         if err := recover(); err != nil {
  18.             fmt.Println("有效", err.(string))
  19.         }
  20.     }()
  21.  
  22.     //defer recover()              //无效，不是延迟调用，nil
  23.     defer fmt.Println(recover()) //无效，空
  24.  
  25.     defer func() {
  26.         func() {
  27.             fmt.Println("defer inner")
  28.             fmt.Println("defer inner", recover()) //无效
  29.         }()
  30.  
  31.     }()
  32.  
  33.     panic("panic错误测试！")
  34.     //不会执行
  35.     fmt.Println("End of test!")
  36. }
  37.  
  38. func main() {
  39.     recoveryDemo()
  40.     fmt.Println("main")
  41. }

总结：需要recover捕获panic时defer延迟函数进行接受，并且第一个有效的recover只能捕获最后一个painc(如果多个panic),之后有效的recover也返回nil。

defer的使用

defer延迟调用，一般释放资源和连接、关闭文件、释放锁等等。类似于java的finally和c++中析构函数，不过defer一般跟在函数或方法中。

参考博客：【Golang】Go语言defer用法大总结(含return返回机制)_golang defer return-CSDN博客

多个defer满足后进先出

defer跟无参、有参函数、方法
  1. package main
  2.  
  3. import "fmt"
  4. //无返回值
  5. func test(a int) {
  6.     defer fmt.Println("defer1 = ", a)//方法
  7.     defer func(v int) {
  8.         fmt.Println("defer2 = ", v)
  9.     }(a)//有参函数
  10.     defer func() {
  11.         fmt.Println("defer3 = ", a)
  12.     }()//无参函数
  13.     a += 100
  14. }
  15.  
  16. func main() {
  17.     test(0)
  18. }

defer满足后进先出，其次，有参情况下a会先传递进入，最后等a+=100之后执行完了再输出。

可读取函数返回值（return返回机制）

先return结构写入返回值，后defer收尾，最后携带返回值退出.

无名返回值，有名返回值的区别，见下面demo

无名有名返回值defer的demo

函数返回值可以无名、有名，这个是方便理解的不全代码，有名res的话本质局部变量，因此defer后会可能会影响res的返回值。而int这个返回值就直接定了。这个很容易引起bug，因此看下面例子：

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. // 无名返回值
  6. func UnNamed(n int) int {
  7.     n += 100
  8.  
  9.     defer func() {
  10.         n += 100
  11.         fmt.Println("UnNamed defer1", n)
  12.     }()
  13.  
  14.     return n
  15. }
  16.  
  17. // 有名返回值
  18. func Named(n int) (res int) {
  19.     res = n + 100
  20.  
  21.     defer func() {
  22.         res += 100
  23.         fmt.Println("UnNamed defer1", res)
  24.     }()
  25.     // 返回res局部变量，因此受defer中的res的逻辑影响
  26.     return res
  27. }
  28.  
  29. func main() {
  30.     n := 0
  31.     fmt.Println("main UnNamed return:", UnNamed(n))
  32.  
  33.     fmt.Println("main Named return:", Named(n))
  34. }

对于第一无名返回值，先执行return保存返回值100，之后defer输出200，最后返回到main函数为100.

第二有名返回值，先执行return知道返回的是res(此时100)，之后defer修改输出res200,最终返回到main为200.

同理可以更复杂，defer可以传入形参的无名有名函数，可以进行分析。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. // 无名返回值
  6. func UnNamed(n int) int {
  7.     n += 100
  8.  
  9.     defer func(n int) { //传入100，输出110
  10.         n += 10
  11.         fmt.Println("UnNamed defer2", n)
  12.     }(n)
  13.  
  14.     defer func() { //200
  15.         n += 100
  16.         fmt.Println("UnNamed defer1", n)
  17.     }()
  18.  
  19.     return n //100
  20. }
  21.  
  22. // 有名返回值
  23. func Named(n int) (res int) {
  24.     res = n + 100 //100
  25.  
  26.     defer func(res int) { //传入100并且注意是值拷贝，并且入栈,110
  27.         res += 10
  28.         fmt.Println("UnNamed defer2", res)
  29.     }(res)
  30.  
  31.     defer func() { //入栈
  32.         res += 100
  33.         fmt.Println("UnNamed defer1", res)
  34.     }()
  35.  
  36.     return res //100->200
  37. }
  38.  
  39. func main() {
  40.     n := 0
  41.     fmt.Println("main UnNamed return:", UnNamed(n)) //100
  42.  
  43.     fmt.Println()
  44.     fmt.Println("main Named return:", Named(n)) //200
  45. }

因此传入指针等等，defer函数，有无名返回值均会影响main函数中接收到的最终return的值，请注意。

    • 调用os.Exit时defer不会被执行defer
    • 与panic进行配合处理异常

nil相关

nil代表某些数据类型的零值

不同类型0值

bool false

number 0

string ""

slice、map、channel、pointer、interface{} nil

如果是结构体，那么它的零值是，内部所有属性的零值的集合

nil 和empty的区别

这里分析了slice、map中的nil和empty的区别。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. type Student struct {
  6.     name string
  7.     age  int
  8. }
  9.  
  10. func main() {
  11.     // nil slice,其实可以创建，append对nil slice进行了处理，但是map就不行
  12.     var s1 []Student
  13.     //s1 = append(s1, Student{"Bob", 19})
  14.     fmt.Println(s1)
  15.     if s1 == nil {
  16.         fmt.Println("s1==nil")
  17.     }
  18.  
  19.     // 不是nil slice，其实本质上是创建了，内部ptr指向一个空间为0的数组
  20.     var s2 = make([]Student, 0)
  21.     if s2 == nil {
  22.         fmt.Println("s2==nil")
  23.     }
  24.  
  25.     // nil map
  26.     var m1 map[int]Student
  27.     if m1 == nil {
  28.         fmt.Println("m1==nil")
  29.     }
  30.     //可以查询,但是无法添加键值对,panic(assignment to entry in nil map)
  31.     //m1[1] = Student{"hhh", 123}
  32.     //if val, ok := m1[1]; ok {
  33.     //    fmt.Println("ok", val)
  34.     //} else {
  35.     //    fmt.Println("not ok")
  36.     //}
  37.     fmt.Println(m1)
  38.  
  39.     //不是nil map，已经初始化了，0个空间的map
  40.     var m2 = make(map[int]Student, 0)
  41.     //可以查询，插入数据了
  42.     m2[1] = Student{"hhh", 123}
  43.     if val, ok := m2[1]; ok {
  44.         fmt.Println("ok", val)
  45.     } else {
  46.         fmt.Println("not ok")
  47.     }
  48.     fmt.Println(m2)
  49.  
  50. }
本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号