(7) go 函数

 

一、函数返回指针

func test() *int {
    i := 3
    return &i
}

func main() {
    i := test()
    println(i)
    println(*i)
}

 

二、传递函数

func a() {
    println("abc")
}

func b(f func()) {
    f()
}
func main() {
    fff := a
    b(fff)
}

 

三、参数

1.连续参数

func a(x, y int, _ int) {
    println(x)
    println(y)
    //println(z)
}

func main() {
    a(3, 6, 9)
}

 

2.二级指针

func a(x **int) {
    o := 10
    *x = &o
    println(&o)
}

func main() {
    //定义一个指针
    var i *int
    //把指针的地址传给函数
    a(&i)
    println(i)
}

 

3.可变参数

func a(str string, a ...int) {
    for _, j := range a {
        print(j)
    }
}

func main() {
    a("abc", 1, 2, 3, 4)
}

 

四、返回值

1.普通

func a() string {
    return "abc"
}

2.返回多值

func a() (string, error) {
    return "abc", errors.New("错误")
}

func main() {
    var str string
    str, _ = a()
    print(str)
}

3.命名返回值

给返回参数加一个名称，方便见名知意

func a() (s string, i int) {
    return "abc", 10
}

func main() {
    var str string
    var i int
    str, i = a()
    print(str, i)
}

4.隐式return

func a() (s string, i int) {
    s = "abc"
    i = 3
    return
}

 

五、匿名函数

1.直接执行 

func main() {
    func(s string) {
        println(s)
    }("hello")
}

2.赋值变量

func main() {
    add := func(x, y int) int {
        return x + y
    }
    print(add(1, 3))
}

3.作为参数

func test(f func()) {
    f()
}

func main() {
    test(func() {
        print("hello")
    })
}

4.作为返回值

func test() func(int, int) int {
    return func(x, y int) int {
        return x + y
    }
}

func main() {
    add := test()
    print(add(3, 4))
}

 

六、闭包

 匿名函数有动态创建的特性，该特性使得匿名函数不用通过参数传递的方式，就可以直接引用外部的变量

func main() {
    n := 0
    f := func() int {
        n += 100
        return n
    }
    println(f())
}

 累加器

func test() func(int) int {

    n := 100
    return func(i int) int {
        n = i + n
        return n
    }
}

func main() {
    //f里的n变量只初始化一次
    //n和return的函数构成了一个闭包
    f := test()
    println(f(1)) //101
    println(f(2)) //103
}

 

七、延迟调用

defer 在函数结束时才被执行

1.

import (
    "log"
    "os"
)

func test() {

    f, err := os.Open("./main.go")
    if err != nil {
        log.Fatalln(err)
    }

    defer f.Close()
}

func main() {
    test()
}

 2.

func main() {
    x, y := 1, 2
    defer func(a int) {
        println("defer a ", a, "  ", y)
        println("defer x ", x, "  ", y)
    }(x)
    x += 100
    y += 100
    println(x, "  ", y)
}

 3.

多个defer的调用顺序：先入后出

 

八、错误处理

1.一般

import "errors"

var errZero = errors.New("err")

func test(x, y int) (int, error) {
    if y == 0 {
        return 0, errZero
    }
    return x / y, nil
}
func main() {
    z, err := test(3, 0)
    if err == errZero {
        println("除0错误")
    }
    println(z)
}

2.自定义类型

 

3.defer，recover

（1）defer，recover 错误处理

import "fmt"

func test(x, y int) int {
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println(err)
        }
    }()
    return x / y
}
func main() {
    z := test(3, 0)
    println(z)
}

 

4.panic

会打印错误并终止程序

func main() {
    panic("err")
    println("abc")
}

 

 

panic  抛出错误， recover在defer时捕获 最后一个panic错误。这样程序就可以不停止了

import "fmt"

func f() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    panic("error")
}

func main() {
    f()
    println("abc")
}