golang关键字之函数定义

在函数定义的时候，涉及到两个关键字，func与defer。其中func则是常规的使用，定义普通函数、匿名函数（闭包）、成员函数，与其他语言无甚区别。defer则是一个好东西，实现一个退出处理的能力。

// 普通函数
func nameFunction() {
   fmt.Println("有名函数")
}

type Hero struct {
   name string
}

// 成员函数
func (h *Hero) getName() string {
   return h.name
}

func main() {
   a := func() int { // 匿名函数
      return 10
   }()
   fmt.Println(a)
}

func相关

成员函数带*和不带有什么区别？

type Hero struct {
   name string
}

// 成员函数
func (h Hero) setName(newName string) {
   h.name = newName
}

func main() {
   h := Hero{name: "flynn"}
   h.setName("vivi")
   fmt.Println(h)
}

能否修改成功？

不能，因为setName的调用方式是值，会构建一个临时对象进行处理，不会影响到外部h。

那h是指针呢？是否能修改成功？

type Hero struct {
   name string
}

// 成员函数
func (h Hero) setName(newName string) {
   h.name = newName
}

func main() {
   h := &Hero{name: "flynn"}
   h.setName("vivi")
   fmt.Println(h)
}

依然失败。道理还是那个道理，这里只是看起来是一个指针，但是在调用setName的时候，还是搞了一个临时对象，这里依然是一个语法糖。

那把成员函数改成引用调用呢？

type Hero struct {
   name string
}

// 成员函数
func (h *Hero) setName(newName string) {
   h.name = newName
}

func main() {
   h := &Hero{name: "flynn"}
   h.setName("vivi")
   fmt.Println(h)
}

修改成功了，符合直观的预期，h是引用，setName也是引用调用。那把h改成值呢？

type Hero struct {
   name string
}

// 成员函数
func (h *Hero) setName(newName string) {
   h.name = newName
}

func main() {
   h := Hero{name: "flynn"}
   h.setName("vivi")
   fmt.Println(h)
}

也能成功，还是语法糖，哎，没必要，你就严肃一点能咋。

总结起来：

成员函数带*，即表明是引用调用，对于变量的修改是可以体现到调用方，无论调用方的成员是引用还是值。
成员函数不带*，即表明是值调用，对于变量的修改是不能体现到调用方，无论调用方的成员是引用还是值

函数返回值有名的问题

下面代码是否可以编译通过？

package main
/*
    下面代码是否编译通过?
*/
func myFunc(x,y int)(sum int,error){
    return x+y,nil
}
func main() {
    num, err := myFunc(1, 2)
    fmt.Println("num = ", num)
}

# command-line-arguments
./test1.go:6:21: syntax error: mixed named and unnamed function parameters

结果：编译出错。

在函数有多个返回值时，只要有一个返回值有指定命名，其他的也必须有命名。如果返回值有有多个返回值必须加上括号；如果只有一个返回值并且有命名也需要加上括号；此处函数第一个返回值有sum名称，第二个未命名，所以错误。

defer相关

defer函数参数、内部变量的初始化问题

defer函数参数的初始化，是在defer这行代码执行的时候就初始化，无论是变量传参还是函数传参，参考知识点7和补充1

defer内变量的值，如果defer函数内部使用了"作用域范围之外"的变量，那么其值是在整个函数执行结束后，才决定内容，参考补充2

知识点1：defer的执行顺序

多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚。

会在当前函数的return之后，返回到上一个函数栈之前，参考知识点4。

知识点2: defer与return谁先谁后

defer在return之后执行

return之后的语句先执行，defer后的语句后执行

示例代码

package main

import "fmt"

func deferFunc() int {
    fmt.Println("defer func called")
    return 0
}

func returnFunc() int {
    fmt.Println("return func called")
    return 0
}

func returnAndDefer() int {

    defer deferFunc()

    return returnFunc()
}

func main() {
    returnAndDefer()
}

执行结果为：

return func called
defer func called

知识点3：函数的返回值初始化

该知识点不属于defer本身，但是调用的场景却与defer有联系，所以也算是defer必备了解的知识点之一。

如： func DeferFunc1(i int) (t int) {} 其中返回值t int，这个t会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。

示例代码

package main

import "fmt"

func DeferFunc1(i int) (t int) {

    fmt.Println("t = ", t)

    return 2
}

func main() {
    DeferFunc11(10)
}

结果

t =  0

证明，只要声明函数的返回值变量名称，就会在函数初始化时候为之赋值为0，而且在函数体作用域可见。

知识点4: 有名函数返回值遇见defer情况

在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。

我们通过知识点2得知，先return，再defer，所以在执行完return之后，还要再执行defer里的语句，依然可以修改本应该返回的结果。

package main

import "fmt"

func returnButDefer() (t int) {  //t初始化0， 并且作用域为该函数全域

    defer func() {
        t = t * 10
    }()

    return 1
}

func main() {
    fmt.Println(returnButDefer())
}

该returnButDefer()本应的返回值是1，但是在return之后，又被defer的匿名func函数执行，所以t=t*10被执行，最后returnButDefer()返回给上层main()的结果为10

$ go run test.go
10

实际的执行顺序：

在 returnButDefer 开始的时候，t = 0
在 return 的时候，t = 1
之后调用 defer t = 10
之后回到main，返回值为 10
最终输出为10

知识点5: defer遇见panic

我们知道，能够触发defer的是遇见return(或函数体到末尾)和遇见panic。

根据知识点2，我们知道，defer遇见return情况如下：

那么，遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中:遇到recover则停止panic，返回recover处继续往下执行。如果没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。

A. defer遇见panic，但是并不捕获异常的情况

test10.go

package main

import (
    "fmt"
)

func main() {
    defer_call()

    fmt.Println("main 正常结束")
}

func defer_call() {
    defer func() { fmt.Println("defer: panic 之前1") }()
    defer func() { fmt.Println("defer: panic 之前2") }()

    panic("异常内容")  //触发defer出栈

    defer func() { fmt.Println("defer: panic 之后，永远执行不到") }()
}

结果

defer: panic 之前2
defer: panic 之前1
panic: 异常内容
//... 异常堆栈信息

B. defer遇见panic，并捕获异常

package main

import (
    "fmt"
)

func main() {
    defer_call()

    fmt.Println("main 正常结束")
}

func defer_call() {

    defer func() {
        fmt.Println("defer: panic 之前1, 捕获异常")
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()

    defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()

    panic("异常内容")  //触发defer出栈

    defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()
}

结果

defer: panic 之前2, 不捕获
defer: panic 之前1, 捕获异常
异常内容
main 正常结束

defer 最大的功能是 panic 后依然有效 所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。

知识点6: defer中包含panic

编译执行下面代码会出现什么?

test16.go

package main

import (
    "fmt"
)

func main()  {

    defer func() {
       if err := recover(); err != nil{
           fmt.Println(err)
       }else {
           fmt.Println("fatal")
       }
    }()

    defer func() {
        panic("defer panic")
    }()

    panic("panic")
}

结果

defer panic

分析

panic仅有最后一个可以被revover捕获。

触发panic("panic")后defer顺序出栈执行，第一个被执行的defer中会有panic("defer panic")异常语句，这个异常将会覆盖掉main中的异常panic("panic")，最后这个异常被第二个执行的defer捕获到。

知识点7: defer下的函数参数包含子函数非常有迷惑性

package main

import "fmt"

func function(index int, value int) int {

    fmt.Println(index)

    return index
}

func main() {
    defer function(1, function(3, 0))
    defer function(2, function(4, 0))
}

这里，有4个函数，他们的index序号分别为1，2，3，4。

那么这4个函数的先后执行顺序是什么呢？这里面有两个defer，所以defer一共会压栈两次，先进栈1，后进栈2。那么在压栈function1的时候，需要连同函数地址、函数形参一同进栈，那么为了得到function1的第二个参数的结果，所以就需要先执行function3将第二个参数算出，那么function3就被第一个执行。同理压栈function2，就需要执行function4算出function2第二个参数的值。然后函数结束，先出栈fuction2、再出栈function1.

所以顺序如下：

defer压栈function1，压栈函数地址、形参1、形参2(调用function3) —> 打印3
defer压栈function2，压栈函数地址、形参1、形参2(调用function4) —> 打印4
defer出栈function2, 调用function2 —> 打印2
defer出栈function1, 调用function1—> 打印1

也就是defer如果有入参，入参是调用了其他函数，那么会先执行函数获取结果，才能成功入栈。

为什么这样设计？而不是在真正调用的时候再进行入参函数的调用？

补充1：defer的参数构造时机

package main

import (
   "fmt"
)

func function(value int) {
   fmt.Println(value)
}

func main() {
   x := 10
   defer function(x)
   x = 20
   defer function(x)
}

输出
20
10

补充2：defer内变量的值是何时确定的？

package main

import (
   "fmt"
)

func main() {
   x := 10
   defer func() {
      fmt.Println(x)
   }()
   x = 20
   defer func() {
      fmt.Println(x)
   }()
}

输出
20
20

#golang工程师##golang#