函式是組織好的、可重復使用的、用于執行指定任務的代碼塊，本文介紹了Go語言中函式的相關內容，

Go語言中支持函式、匿名函式和閉包，并且函式在Go語言中屬于“一等公民”，

函式定義

Go語言中定義函式使用func關鍵字，具體格式如下：

func 函式名(引數)(回傳值){
    函式體
}

其中：

函式名：由字母、數字、下劃線組成，但函式名的第一個字母不能是數字，在同一個包內，函式名也稱不能重名（包的概念詳見后文），
引數：引數由引數變數和引數變數的型別組成，多個引數之間使用,分隔，
回傳值：回傳值由回傳值變數和其變數型別組成，也可以只寫回傳值的型別，多個回傳值必須用()包裹，并用,分隔，
函式體：實作指定功能的代碼塊，

我們先來定義一個求兩個數之和的函式：

func intSum(x int, y int) int {
	return x + y
}

函式的引數和回傳值都是可選的，例如我們可以實作一個既不需要引數也沒有回傳值的函式：

func sayHello() {
	fmt.Println("Hello 沙河")
}

函式的呼叫

定義了函式之后，我們可以通過函式名()的方式呼叫函式，例如我們呼叫上面定義的兩個函式，代碼如下：

func main() {
	sayHello()
	ret := intSum(10, 20)
	fmt.Println(ret)
}

注意，呼叫有回傳值的函式時，可以不接收其回傳值，

引數

型別簡寫

函式的引數中如果相鄰變數的型別相同，則可以省略型別，例如：

func intSum(x, y int) int {
	return x + y
}

上面的代碼中，intSum函式有兩個引數，這兩個引數的型別均為int，因此可以省略x的型別，因為y后面有型別說明，x引數也是該型別，

可變引數

可變引數是指函式的引數數量不固定，Go語言中的可變引數通過在引數名后加...來標識，

注意：可變引數通常要作為函式的最后一個引數，

舉個例子：

func intSum2(x ...int) int {
	fmt.Println(x) //x是一個切片
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}

呼叫上面的函式：

ret1 := intSum2()
ret2 := intSum2(10)
ret3 := intSum2(10, 20)
ret4 := intSum2(10, 20, 30)
fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60

固定引數搭配可變引數使用時，可變引數要放在固定引數的后面，示例代碼如下：

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

呼叫上述函式：

ret5 := intSum3(100)
ret6 := intSum3(100, 10)
ret7 := intSum3(100, 10, 20)
ret8 := intSum3(100, 10, 20, 30)
fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160

本質上，函式的可變引數是通過切片來實作的，

回傳值

Go語言中通過return關鍵字向外輸出回傳值，

多回傳值

Go語言中函式支持多回傳值，函式如果有多個回傳值時必須用()將所有回傳值包裹起來，

舉個例子：

func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

回傳值命名

函式定義時可以給回傳值命名，并在函式體中直接使用這些變數，最后通過return關鍵字回傳，

例如：

func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

函式進階

變數作用域

全域變數

全域變數是定義在函式外部的變數，它在程式整個運行周期內都有效，在函式中可以訪問到全域變數，

package main

import "fmt"

//定義全域變數num
var num int64 = 10

func testGlobalVar() {
	fmt.Printf("num=%d\n", num) //函式中可以訪問全域變數num
}
func main() {
	testGlobalVar() //num=10
}

區域變數

區域變數又分為兩種：函式內定義的變數無法在該函式外使用，例如下面的示例代碼main函式中無法使用testLocalVar函式中定義的變數x：

func testLocalVar() {
	//定義一個函式區域變數x,僅在該函式內生效
	var x int64 = 100
	fmt.Printf("x=%d\n", x)
}

func main() {
	testLocalVar()
	fmt.Println(x) // 此時無法使用變數x
}

如果區域變數和全域變數重名，優先訪問區域變數，

package main

import "fmt"

//定義全域變數num
var num int64 = 10

func testNum() {
	num := 100
	fmt.Printf("num=%d\n", num) // 函式中優先使用區域變數
}
func main() {
	testNum() // num=100
}

接下來我們來看一下陳述句塊定義的變數，通常我們會在if條件判斷、for回圈、switch陳述句上使用這種定義變數的方式，

func testLocalVar2(x, y int) {
	fmt.Println(x, y) //函式的引數也是只在本函式中生效
	if x > 0 {
		z := 100 //變數z只在if陳述句塊生效
		fmt.Println(z)
	}
	//fmt.Println(z)//此處無法使用變數z
}

還有我們之前講過的for回圈陳述句中定義的變數，也是只在for陳述句塊中生效：

func testLocalVar3() {
	for i := 0; i < 10; i++ {
		fmt.Println(i) //變數i只在當前for陳述句塊中生效
	}
	//fmt.Println(i) //此處無法使用變數i
}

函式型別與變數

定義函式型別

我們可以使用type關鍵字來定義一個函式型別，具體格式如下：

type calculation func(int, int) int

上面陳述句定義了一個calculation型別，它是一種函式型別，這種函式接收兩個int型別的引數并且回傳一個int型別的回傳值，

簡單來說，凡是滿足這個條件的函式都是calculation型別的函式，例如下面的add和sub是calculation型別，

func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

add和sub都能賦值給calculation型別的變數，

var c calculation
c = add

函式型別變數

我們可以宣告函式型別的變數并且為該變數賦值：

func main() {
	var c calculation               // 宣告一個calculation型別的變數c
	c = add                         // 把add賦值給c
	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // 像呼叫add一樣呼叫c

	f := add                        // 將函式add賦值給變數f1
	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // 像呼叫add一樣呼叫f
}

高階函式

高階函式分為函式作為引數和函式作為回傳值兩部分，

函式作為引數

函式可以作為引數：

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

函式作為回傳值

函式也可以作為回傳值：

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("無法識別的運算子")
		return nil, err
	}
}

匿名函式和閉包

匿名函式

函式當然還可以作為回傳值，但是在Go語言中函式內部不能再像之前那樣定義函式了，只能定義匿名函式，匿名函式就是沒有函式名的函式，匿名函式的定義格式如下：

func(引數)(回傳值){
    函式體
}

匿名函式因為沒有函式名，所以沒辦法像普通函式那樣呼叫，所以匿名函式需要保存到某個變數或者作為立即執行函式:

func main() {
	// 將匿名函式保存到變數
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通過變數呼叫匿名函式

	//自執行函式：匿名函式定義完加()直接執行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

匿名函式多用于實作回呼函式和閉包，

閉包

閉包指的是一個函式和與其相關的參考環境組合而成的物體，簡單來說，閉包=函式+參考環境，首先我們來看一個例子：

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

變數f是一個函式并且它參考了其外部作用域中的x變數，此時f就是一個閉包，在f的生命周期內，變數x也一直有效，閉包進階示例1：

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder2(10)
	fmt.Println(f(10)) //20
	fmt.Println(f(20)) //40
	fmt.Println(f(30)) //70

	f1 := adder2(20)
	fmt.Println(f1(40)) //60
	fmt.Println(f1(50)) //110
}

閉包進階示例2：

func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func main() {
	jpgFunc := makeSuffixFunc(".jpg")
	txtFunc := makeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test")) //test.jpg
	fmt.Println(txtFunc("test")) //test.txt
}

閉包進階示例3：

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main() {
	f1, f2 := calc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

閉包其實并不復雜，只要牢記閉包=函式+參考環境，

defer陳述句

Go語言中的defer陳述句會將其后面跟隨的陳述句進行延遲處理，在defer歸屬的函式即將回傳時，將延遲處理的陳述句按defer定義的逆序進行執行，也就是說，先被defer的陳述句最后被執行，最后被defer的陳述句，最先被執行，

舉個例子：

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}

輸出結果：

start
end
3
2
1

由于defer陳述句延遲呼叫的特性，所以defer陳述句能非常方便的處理資源釋放問題，比如：資源清理、檔案關閉、解鎖及記錄時間等，

defer執行時機

在Go語言的函式中return陳述句在底層并不是原子操作，它分為給回傳值賦值和RET指令兩步，而defer陳述句執行的時機就在回傳值賦值操作后，RET指令執行前，具體如下圖所示：

defer經典案例

閱讀下面的代碼，寫出最后的列印結果，

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
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func main() {
	fmt.Println(f1())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

defer面試題

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

問，上面代碼的輸出結果是？（提示：defer注冊要延遲執行的函式時該函式所有的引數都需要確定其值）

內置函式介紹

內置函式	介紹
close	主要用來關閉channel
len	用來求長度，比如string、array、slice、map、channel
new	用來分配記憶體，主要用來分配值型別，比如int、struct，回傳的是指標
make	用來分配記憶體，主要用來分配參考型別，比如chan、map、slice
append	用來追加元素到陣列、slice中
panic和recover	用來做錯誤處理

panic/recover

Go語言中目前（Go1.12）是沒有例外機制，但是使用panic/recover模式來處理錯誤， panic可以在任何地方引發，但recover只有在defer呼叫的函式中有效，首先來看一個例子：

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

輸出：

func A
panic: panic in B

goroutine 1 [running]:
main.funcB(...)
        .../code/func/main.go:12
main.main()
        .../code/func/main.go:20 +0x98

程式運行期間funcB中引發了panic導致程式崩潰，例外退出了，這個時候我們就可以通過recover將程式恢復回來，繼續往后執行，

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//如果程式出出現了panic錯誤,可以通過recover恢復過來
		if err != nil {
			fmt.Println("recover in B")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

注意：

recover()必須搭配defer使用，
defer一定要在可能引發panic的陳述句之前定義，

練習題

分金幣

/*
你有50枚金幣，需要分配給以下幾個人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth，
分配規則如下：
a. 名字中每包含1個'e'或'E'分1枚金幣
b. 名字中每包含1個'i'或'I'分2枚金幣
c. 名字中每包含1個'o'或'O'分3枚金幣
d: 名字中每包含1個'u'或'U'分4枚金幣
寫一個程式，計算每個用戶分到多少金幣，以及最后剩余多少金幣？
程式結構如下，請實作 ‘dispatchCoin’ 函式
*/
var (
	coins = 50
	users = []string{
		"Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
	}
	distribution = make(map[string]int, len(users))
)

func main() {
	left := dispatchCoin()
	fmt.Println("剩下：", left)
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/43088.html

標籤：Go

上一篇：Go語言基礎之指標

下一篇：Go語言基礎之map

Go語言基礎之函式

函式定義

函式的呼叫

引數

型別簡寫

可變引數

回傳值

多回傳值

回傳值命名

函式進階

變數作用域

全域變數

區域變數

函式型別與變數

定義函式型別

函式型別變數

高階函式

函式作為引數

函式作為回傳值

匿名函式和閉包

匿名函式

閉包

defer陳述句

defer執行時機

defer經典案例

defer面試題

內置函式介紹

panic/recover

練習題