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