Go基础(函数)

package main

import (
    "errors"
    "fmt"
)

// 1. 无返回值的函数
func f1() {
    fmt.Println("Hello World!")
}

// 2. 有返回值；多个形参类型一致，可简写
func f2(x, y int) int {
    return x + y
}

// 3. 可变参数 固定参数搭配可变参数使用时，可变参数要放在固定参数的后面
func f3(x string, y ...int) {
    s := 0
    for _, v := range y {
        s += v
    }
    fmt.Println(x, y, s) // hello [1 2 3] 6
}

// 4. 多返回值 返回值指定了 sum、sub， return 后可不跟返回值
func f4(x, y int) (sum, sub int) {
    sum = x + y
    sub = x - y
    fmt.Println(sum, sub)
    return
}

// 5. 函数类型与变量
type calc func(int, int) int // 定义一个函数类型 calc

func f5(x, y int) int {
    return x + y
}
func f6(x, y int) int {
    return x - y
}

// 6. 函数作为参数
func f7(x, y int, op func(int, int) int) int {
    return op(x, y)
}

// 7. 函数作为返回值
func f8(s string) (func(int, int) int, error) {
    switch s {
    case "+":
        return f5, nil
    case "-":
        return f6, nil
    default:
        err := errors.New("无法识别的操作符!")
        return nil, err
    }
}

// 8. 匿名函数
func f9() {
    // 匿名函数保存到变量里
    add := func(x, y int) {
        fmt.Println(x + y)
    }
    add(20, 20)

    // 立即执行函数
    func(x, y int) {
        fmt.Println(x + y)
    }(20, 20)
}

// 9. 闭包
func f10(base int) (func(int) int, func(int) int) {
    add := func(i int) int {
        base += i
        return base
    }

    sub := func(i int) int {
        base -= i
        return base
    }
    return add, sub
}

// 10. defer
func f13() {
    fmt.Println("start")
    defer fmt.Println(1)
    defer fmt.Println(2)
    defer fmt.Println(3)
    fmt.Println("end")

    // start
    // end
    // 3
    // 2
    // 1
}

// 11 panic/recover
func funcA() {
    fmt.Println("func A")
}

func funcB() {
    defer func() {
        err := recover()
        // 如果程序出出现了panic错误,可以通过recover恢复过来
        if err != nil {
            fmt.Println("recover in B")
        }
    }()
    fmt.Println(123)
    panic("panic in B")
}

func funcC() {
    fmt.Println("func C")
}

func main() {
    f1()

    f2(1, 2)

    f3("hello", 1, 2, 3)

    f4(3, 2)

    var c calc
    c = f5
    fmt.Printf("Type of c: %T\n", c) // Type of c: main.calc
    fmt.Println(c(1, 2))
    c1 := f5
    fmt.Printf("Type of c: %T\n", c1) // Type of c: func(int, int) int
    fmt.Println(c1(1, 2))

    fmt.Println(f7(1, 2, f5))

    c2, _ := f8("+")
    fmt.Println(c2(20, 10))

    f9()

    f11, f12 := f10(10)
    fmt.Println(f11(1), f12(2)) //11 9
    fmt.Println(f11(3), f12(4)) //12 8
    fmt.Println(f11(5), f12(6)) //13 7

    f13()

    funcA()
    funcB()
    funcC()
    // func A
    // 123
    // recover in B
    // func C

}