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
40defer
表示延迟执行函数。
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-d-d d:d:d", 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
到此这篇关于“Go 学习笔记 06 | 函数详解”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！您可能感兴趣的文章：
想系统学习GO语言(Golang
Golang学习笔记（五）：Go语言与C语言的区别
Golang笔记：语法，并发思想，web开发，Go微服务相关
Go 语言数据类型：byte、rune与字符串
14. Go 语言中的类型断言是什么？
go 语言学习历程
12. Go 语言流程控制：defer 延迟语句
与 Jupyter 交互的 Go 编程
[Go学习] 并发控制之WaitGroup计数信号量
2018年最全Go语言教程零基础入门到进阶实战视频