Golang基础3-函数、nil相关

函数

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

简单demo

package main

import "fmt"

//测试函数
func test(x, y int, s string) (int, string) {
    n := x + y
    return n, fmt.Sprintf("%s,%d\n", s, n)
}
func main() {
    a, b := test(1, 2, "你好")
    // _可以忽略某些值的返回
    fmt.Println(a)
    fmt.Println(b)

}

回调函数demo

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

package main

import "fmt"

// 回调函数1
func testFunc(fn func() int) int {
    return fn()
}

// 定义函数类型
type FormatFunc func(s string, x, y int) string

func format(fn FormatFunc, s string, x, y int) string {
    return fn(s, x, y)
}

func formatHelper(s string, x, y int) string {
    return fmt.Sprintf(s, x, y)
}

func main() {
    s1 := testFunc(func() int {
        return 100
    })
    fmt.Println(s1) //100

    //匿名函数,回调进行格式化返回string
    //s2 := format(func(s string, x, y int) string {
    //    return fmt.Sprintf(s, x, y)
    //}, "%d %d", 10, 20)
    s2 := format(formatHelper, "%d %d", 10, 20)
    fmt.Println(s2)
}

闭包demo

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

https://juejin.cn/post/6844903793771937805

package main

import (
    "fmt"
)

//返回函数指针 func()int
func a() func() int {
    i := 0
    b := func() int {
        i++
        fmt.Println(i)
        return i
    }
    return b
}

func main() {
    //a执行完返回func() int 的这个函数指针,其中赋值给c,
    //那么这里面保存有这个b匿名函数的所有信息,实现了自增,可以不用定义全局变量
    c := a()
    c()
    c()
    c()
    //因为这个是函数指针
    a() //不会输出i
}

递归demo

package main

import "fmt"

// 递归1,求阶乘
func Factorial(n int) int {
    if n <= 1 {
        return 1
    }
    return n * Factorial(n-1)
}

// 递归2,斐波那契数列
func Fibonaci(n int) int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 1
    }
    return Fibonaci(n-1) + Fibonaci(n-2)
}
func main() {
    fmt.Println("5!=", Factorial(5))

    fmt.Println("前10项斐波那契数列:")
    for i := 0; i < 10; i++ {
        fmt.Printf("%d\t", Fibonaci(i))
    }
}

异常处理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

package main

import "fmt"

// painc部分后面代码不执行
func test() {
    defer func() {
        if err := recover(); err != nil {
            println("recover panic:", err.(string))
        }
    }()
    panic("panic错误测试!")
    //panic后的代码不执行
    //fmt.Println("panic后代码")
}

func main() {
    test()
    fmt.Println("main")
}

error处理 demo
package main

import (
    "errors"
    "fmt"
)

func A() (int, error) {
    return 2, errors.New("this is an error")

}

func main() {
    if _, err := A(); err != nil {
        fmt.Println(err)
    }
}

recover捕获panic的demo

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

package main

import "fmt"

func except() {
    fmt.Println("except延迟函数调用!")
    fmt.Println("except延迟函数recover:", recover())
}

func recoveryDemo() {

    //等效于下面的匿名延迟函数
    defer except()

    //延迟调用,recover在函数内部
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("有效", err.(string))
        }
    }()

    //defer recover()              //无效,不是延迟调用,nil
    defer fmt.Println(recover()) //无效,空

    defer func() {
        func() {
            fmt.Println("defer inner")
            fmt.Println("defer inner", recover()) //无效
        }()

    }()

    panic("panic错误测试!")
    //不会执行
    fmt.Println("End of test!")
}

func main() {
    recoveryDemo()
    fmt.Println("main")
}

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

defer的使用

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

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

多个defer满足后进先出

defer跟无参、有参函数、方法
package main

import "fmt"
//无返回值
func test(a int) {
    defer fmt.Println("defer1 = ", a)//方法
    defer func(v int) {
        fmt.Println("defer2 = ", v)
    }(a)//有参函数
    defer func() {
        fmt.Println("defer3 = ", a)
    }()//无参函数
    a += 100
}

func main() {
    test(0)
}

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

可读取函数返回值(return返回机制)

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

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

无名有名返回值defer的demo

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

package main

import "fmt"

// 无名返回值
func UnNamed(n int) int {
    n += 100

    defer func() {
        n += 100
        fmt.Println("UnNamed defer1", n)
    }()

    return n
}

// 有名返回值
func Named(n int) (res int) {
    res = n + 100

    defer func() {
        res += 100
        fmt.Println("UnNamed defer1", res)
    }()
    // 返回res局部变量,因此受defer中的res的逻辑影响
    return res
}

func main() {
    n := 0
    fmt.Println("main UnNamed return:", UnNamed(n))

    fmt.Println("main Named return:", Named(n))
}

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

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

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

package main

import "fmt"

// 无名返回值
func UnNamed(n int) int {
    n += 100

    defer func(n int) { //传入100,输出110
        n += 10
        fmt.Println("UnNamed defer2", n)
    }(n)

    defer func() { //200
        n += 100
        fmt.Println("UnNamed defer1", n)
    }()

    return n //100
}

// 有名返回值
func Named(n int) (res int) {
    res = n + 100 //100

    defer func(res int) { //传入100并且注意是值拷贝,并且入栈,110
        res += 10
        fmt.Println("UnNamed defer2", res)
    }(res)

    defer func() { //入栈
        res += 100
        fmt.Println("UnNamed defer1", res)
    }()

    return res //100->200
}

func main() {
    n := 0
    fmt.Println("main UnNamed return:", UnNamed(n)) //100

    fmt.Println()
    fmt.Println("main Named return:", Named(n)) //200
}

因此传入指针等等,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的区别。

package main

import "fmt"

type Student struct {
    name string
    age  int
}

func main() {
    // nil slice,其实可以创建,append对nil slice进行了处理,但是map就不行
    var s1 []Student
    //s1 = append(s1, Student{"Bob", 19})
    fmt.Println(s1)
    if s1 == nil {
        fmt.Println("s1==nil")
    }

    // 不是nil slice,其实本质上是创建了,内部ptr指向一个空间为0的数组
    var s2 = make([]Student, 0)
    if s2 == nil {
        fmt.Println("s2==nil")
    }

    // nil map
    var m1 map[int]Student
    if m1 == nil {
        fmt.Println("m1==nil")
    }
    //可以查询,但是无法添加键值对,panic(assignment to entry in nil map)
    //m1[1] = Student{"hhh", 123}
    //if val, ok := m1[1]; ok {
    //    fmt.Println("ok", val)
    //} else {
    //    fmt.Println("not ok")
    //}
    fmt.Println(m1)

    //不是nil map,已经初始化了,0个空间的map
    var m2 = make(map[int]Student, 0)
    //可以查询,插入数据了
    m2[1] = Student{"hhh", 123}
    if val, ok := m2[1]; ok {
        fmt.Println("ok", val)
    } else {
        fmt.Println("not ok")
    }
    fmt.Println(m2)

}
  • 28
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值