Go 学习笔记 06 | 函数详解

谁践踏了优雅 2022-12-23 03:19 208阅读 0赞

## 一、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][Golang _ P24-P29]

[Golang _ P24-P29]: https://www.bilibili.com/video/BV1Vi4y1t71d?p=24