Go 学习笔记 06 | 函数详解

一、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