package main

import "fmt"

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    a := 1
    b := 2
    defer calc("1", a, calc("10", a, b))

    a = 0
    defer calc("2", a, calc("20", a, b))

    b = 1
}

defer在定义的时候会计算好调用函数的参数，所以会优先输出10、20这两个参数，之后就是根据定义的顺序倒序执行。

package main

import (
    "fmt"
)

func main() {
    fmt.Println(a())    // 1 0 1
    fmt.Println(c())    // 2
    fmt.Println(f0())   // 6
    fmt.Println(f1())   // 1
    fmt.Println(*f1p()) // 6
    fmt.Println(f2())   // 1
    fmt.Println(f3())   // 6
    fmt.Println(f40())  // 1
    fmt.Println(f4())   // 0
}

/**
 * 当defer被声明时，其参数就会被实时解析
 * defer执行顺序为先进后出
 */
func a() int {
    i := 0
    defer fmt.Println(i) //输出0，因为i此时就是0
    i++
    defer fmt.Println(i) //输出1，因为i此时就是1
    return i
}

/**
 * 当执行return 1时，1先赋值给i.然后defer代码块开始执行，对i进行自增操作。 因此输出2
 */
func c() (i int) {
    defer func() {
        i++
    }()
    return 1
}

func f0() (t int) {
    t = 1
    defer func() {
        t = t + 5
    }()
    return t
}

/**
 * t先赋值给r,然后执行defer,虽然t被改了,由于值传递返回值仍然是1
 */
func f1() (r int) {
    t := 1
    defer func() {
        t = t + 5
    }()
    return t
}

/**
 * t先赋值给r,然后执行defer,t被改了,由于传的是地址,返回值是6
 */
func f1p() (r *int) {
    t := 1
    defer func() {
        t = t + 5
    }()
    return &t
}

/**
 * r默认值是0,作为参数传入了defer不会修改r的值,1会赋值给r,返回值为1
 */
func f2() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}

/**
 * 1赋值给r,然后执行defer,此时r被修改为6,返回的r值为6
 */
func f3() (r int) {
    defer func() {
        r = r + 5
    }()
    return 1
}

/**
 * 0赋值给result,然后defer执行,result值自增变为1,返回值为1
 */
func f40() (result int) {
    defer func() {
        result++
    }()
    return 0
}

/**
 * return不写返回变量,声明的变量名字也会被返回0
 */
func f4() (result int) {
    result = 0
    return
}

/**
 * 传入地址,i的值最终被改为了15,但是返回值是10
 */
func f5(i *int) int {
    *i = 10
    defer func() {
        *i = 15
    }()
    return *i
}

最后更新于 2022-01-04 10:23:58 并被添加「」标签，已有 557 位童鞋阅读过。