Golang panic，defer，return 的返回

Golang返回过程-return,defer,panic

首先有以下几个原则：

1.  函数返回return是函数的返回标志，并不是真正的返回，不代表执行结束
2. 一个函数最多只会panic一次
3. defer按先进后出的形式执行，defer在return之后执行

return 和 defer

一个有返回值的函数，可以有2中表示

  func sum1(x,y int)int{
       s := x+y
       return s
    }

    func sum2(x,y int)(s int){
        s = x+y
        return
    }

    func main(){
        s1 := sum1(1,2)
        s2 := sum2(1,2)
        print(s1)   // 3
        print(s2)   // 3
    }

这sum1和sum2结果是一样的，但是组合上defer，会有不一样结果:
    

  func sum3(x,y int)int{
        s := x+y
        defer func(){
            s += 2
        }()
        return s
    }

    func sum4(x,y int)(s int){
        s = x+y
        defer func(){
            s += 2
        }()
        return
    }
    
    func main(){
        s3 := sum3(1,2)
        s4 := sum4(1,2)
        println(s3)   // 3
        println(s4)   // 5
    }

s3=3,s4=5，对于这个过程的理解是：

1. 函数在开始执行的时候，先初始化了它的返回值，如果位声明，随机一个temps,如果声明了，即s
2. 在执行到return（返回标志）的时候赋值。
   • sum3函数先在执行到return时候，将tempS赋值为s，即3。由于s和tempS3是不同的变量，defer中的s+2就与tempS3无关。 
   •  sum4函数由于声明了返回变量s，return时候，如果是 `return x+y`，其实将`x+y`复制给s，如果直接return，可以理解为跳过了复制操作。

在return之后的defer，s与sum3所谓的tempS3其实是一个，所以defer的操作是有效的。有些博客用作用域来解释这一现象，看起来比较抽象。

 defer 和 panic

func main() {
    	var a int
    	// fn1
    	defer func() {
    		a = 3
    		if err := recover(); err != nil {
    			a = 4
    			fmt.Println("++++")
    			f := err.(func() string)
    			fmt.Println(err, f(), reflect.TypeOf(err).Kind().String())
    		} else {
    			fmt.Println("fatal")
    		}
    	}()
        // fn2
    	defer func() {
    		a = 2
    		if r := recover(); r != nil {  // 这里的recover()去掉感受一下效果
    			panic(r)
    		}
    		panic(func() string {
    			return "defer panic"
    		})
    	}()
    	a = 1
    	panic("panic1")  // 这里的panic去掉感受一下效果
    	// panic("panic2")
    }

defer有栈deferStack，首先按顺序执行,fn1,进入deferStack，并标记有recover() ,fn2，进入deferStack，并标记有recover() ,

然后panic, panic("panic2")是执行不到的。在deferStack中栈顶发现recover()，执行他，继续panic，panic会沿着deferStack向下递交，在fn1中又发现recover(),执行之。但是现在发现，deferStack已经执行到栈底了，程序认为执行完毕，就不会执行fn2的panic了。