一、Golang 函数

... 表示可变参数

package main

import (
    "fmt"
)


func sumFn1(x int, y ...int) int {
    fmt.Println(x, y)
    sum := x
    for _, v := range y {
        sum += v
    }
    return sum
}


func main() {
    sum1 := sumFn1(100, 1, 2, 3, 4)
    fmt.Println(sum1)
}

return 可以一次返回多个值

返回类型要一致，返回多个值的时候需要使用 ()

package main

import (
    "fmt"
)


func calc(x, y int) (int, int) {  // 返回多个值的时候需要使用 ()
    sum := x + y
    sub := x - y
    return sum, sub  // 返回类型要与上面 (int, int) 一致
}


func main() {
    a, b := calc(10, 2)
    fmt.Println(a, b)
}

返回值命名

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过 return 关键字返回。

package main

import (
    "fmt"
)


func calc1(x, y int) (sum int, sub int) {  // 返回多个值的时候需要使用 ()
    fmt.Println(sum, sub)
    sum = x + y
    sub = x - y
    fmt.Println(sum, sub)
    return
}


func main() {
    a, b := calc1(10, 2)
    fmt.Println(a, b)
}

二、匿名函数

package main

import (
    "fmt"
)

func main() {
    // 匿名函数 匿名自执行函数
    func() {
        fmt.Println("test")
    }()

    // 匿名函数
    var fn = func(x, y int) int {
        return x * y
    }

    fmt.Println(fn(2, 3))

    // 匿名自执行函数接收参数
    func(x, y int) {
        fmt.Println(x + y)
    }(10, 20)
}

全局变量特点：

  • 常驻内存
  • 污染全局

局部变量特点：

  • 不常驻内存
  • 不污染全局

闭包：

  • 可以让一个变量常驻内存
  • 可以让一个变量不污染全局 
package main

import (
    "fmt"
)

// 闭包写法：函数里面嵌套一个函数，最后返回里面的函数
func adder1() func() int {
    var i = 10
    return func() int {
        return i + 1
    }
}

func adder2() func(y int) int {
    var i = 10
    return func(y int) int {
        i += y
        return i
    }
}


func main() {
    var fn1 = adder1()
    fmt.Println(fn1())
    fmt.Println(fn1())
    fmt.Println(fn1())

    var fn2 = adder2()
    fmt.Println(fn2(10))
    fmt.Println(fn2(10))
    fmt.Println(fn2(10))
}

输出：

10
10
10
20
30
40

defer

表示延迟执行函数。

package main

import (
    "fmt"
)

func f1() {
    fmt.Println("开始")

    defer func() {
        fmt.Println("aaa")
    }()  // 必须是匿名自执行函数，带()
    fmt.Println("结束")
}

func main(){
    f1()
}

输出：

开始
结束
aaa

函数中 return 语句底层实现：先返回值 = x，再 RET 指令。

带 defer 的 return 语句底层实现：先返回值 = x，再运行 defer，最后 RET 指令。

package main

import (
    "fmt"
)

// 匿名返回值，操作变量不影响返回值
func f1() int{
    x := 5
    defer func() {
        x++
    }()  // 必须是匿名自执行函数，带()
    return x
}

// 命名返回值，返回值是操作以后的值
func f2() (x int){
    defer func() {
        x++
    }()  // 必须是匿名自执行函数，带()
    return 5
}

// 命名返回值
func f3() (y int){
    x := 5
    defer func() {
        x++
    }()  // 必须是匿名自执行函数，带()
    return x  // 返回的值相当于赋值给 y
}

// 命名返回值
func f4() (x int){  // x 一开始值为 0
    defer func(y int) {
        y++  // 这是一个局部变量
    }(x)  // defer 注册要延迟执行的函数时该函数所有的参数都需要确定其值
    return 5
}

func main(){
    fmt.Println(f1())
    fmt.Println(f2())
    fmt.Println(f3())
    fmt.Println(f4())
}

输出：

5
6
5
5

三、异常机制

Golang 目前（Go1.12）没有异常机制，但是使用 panic/recover 模式来处理错误。

panic 可以在任何地方引发，但是 recover 只有在 defer 调用的函数中有效。

package main

import (
    "fmt"
)

func fn1() {
    fmt.Println("fn1")
}

func fn2() {
    defer func() {
        err := recover()
        if err != nil{  // 有异常
            fmt.Println("err:", err)  // 抛出一个异常 是在这里打印出来的
        }
    }()
    panic("抛出一个异常")
}

func main() {
    fn1()
    fn2()
    fmt.Println("结束")
}

输出：

fn1
err: 抛出一个异常
结束

Golang 在实际中处理异常

package main

import (
    "fmt"
)

func fn1(a int, b int) int {
    defer func() {
        err := recover()
        if err != nil{  // 有异常
            fmt.Println("error:", err)  // error: runtime error: integer divide by zero
        }
    }()
    return a/b
}

func main() {
    fmt.Println(fn1(10, 0))
    fmt.Println("结束")
    fmt.Println(fn1(10, 2))
}

输出：

error: runtime error: integer divide by zero
0
结束
5

四、time 包

package main

import (
    "fmt"
    "time"
)

func main() {
    timeObj := time.Now()

    fmt.Println(timeObj)

    year := timeObj.Year()
    month := timeObj.Month()
    day := timeObj.Day()
    hour := timeObj.Hour()
    minute := timeObj.Minute()
    second := timeObj.Second()
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second)
}

输出：

2020-11-05 16:44:20.8303316 +0800 CST m=+0.001994801
2020-11-05 16:44:20

五、参考教程

Golang 教程 P24-P29