站長資訊網(wǎng)
Go語言支持普通函數(shù)、匿名函數(shù)和閉包，從設計上對函數(shù)進行了優(yōu)化和改進，讓函數(shù)使用起來更加方便。在Go語言中，定義函數(shù)使用func關鍵字，語法“func 函數(shù)名(參數(shù))(返回值){函數(shù)體}”；定義了函數(shù)之后，我們可以通過“函數(shù)名()”的方式調用函數(shù)。
php入門到就業(yè)線上直播課：進入學習
Apipost = Postman + Swagger + Mock + Jmeter 超好用的API調試工具：點擊使用
本教程操作環(huán)境：windows7系統(tǒng)、GO 1.18版本、Dell G3電腦。
函數(shù)是組織好的、可重復使用的、用來實現(xiàn)單一或相關聯(lián)功能的代碼段，其可以提高應用的模塊性和代碼的重復利用率。
Go 語言支持普通函數(shù)、匿名函數(shù)和閉包，從設計上對函數(shù)進行了優(yōu)化和改進，讓函數(shù)使用起來更加方便。
Go 語言的函數(shù)屬于“一等公民”（first-class），也就是說：
-
函數(shù)本身可以作為值進行傳遞。
-
支持匿名函數(shù)和閉包（closure）。
-
函數(shù)可以滿足接口。
函數(shù)定義
Go語言中定義函數(shù)使用func關鍵字，具體格式如下：
func 函數(shù)名(參數(shù))(返回值){ 函數(shù)體 }
其中：
- 函數(shù)名：由字母、數(shù)字、下劃線組成。但函數(shù)名的第一個字母不能是數(shù)字。在同一個包內，函數(shù)名也稱不能重名（包的概念詳見后文）。
- 參數(shù)：參數(shù)由參數(shù)變量和參數(shù)變量的類型組成，多個參數(shù)之間使用
,分隔。 - 返回值：返回值由返回值變量和其變量類型組成，也可以只寫返回值的類型，多個返回值必須用
()包裹，并用,分隔。 - 函數(shù)體：實現(xiàn)指定功能的代碼塊。
我們先來定義一個求兩個數(shù)之和的函數(shù)：
func intSum(x int, y int) int { return x + y }
函數(shù)的參數(shù)和返回值都是可選的，例如我們可以實現(xiàn)一個既不需要參數(shù)也沒有返回值的函數(shù)：
func sayHello() { fmt.Println("Hello 沙河") }
函數(shù)的調用
定義了函數(shù)之后，我們可以通過函數(shù)名()的方式調用函數(shù)。 例如我們調用上面定義的兩個函數(shù)，代碼如下：
func main() { sayHello() ret := intSum(10, 20) fmt.Println(ret) }
注意，調用有返回值的函數(shù)時，可以不接收其返回值。
參數(shù)
類型簡寫
函數(shù)的參數(shù)中如果相鄰變量的類型相同，則可以省略類型，例如：
func intSum(x, y int) int { return x + y }
上面的代碼中，intSum函數(shù)有兩個參數(shù)，這兩個參數(shù)的類型均為int，因此可以省略x的類型，因為y后面有類型說明，x參數(shù)也是該類型。
可變參數(shù)
可變參數(shù)是指函數(shù)的參數(shù)數(shù)量不固定。Go語言中的可變參數(shù)通過在參數(shù)名后加...來標識。
注意：可變參數(shù)通常要作為函數(shù)的最后一個參數(shù)。
舉個例子：
func intSum2(x ...int) int { fmt.Println(x) //x是一個切片 sum := 0 for _, v := range x { sum = sum + v } return sum }
調用上面的函數(shù)：
ret1 := intSum2() ret2 := intSum2(10) ret3 := intSum2(10, 20) ret4 := intSum2(10, 20, 30) fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
固定參數(shù)搭配可變參數(shù)使用時，可變參數(shù)要放在固定參數(shù)的后面，示例代碼如下：
func intSum3(x int, y ...int) int { fmt.Println(x, y) sum := x for _, v := range y { sum = sum + v } return sum }
調用上述函數(shù)：
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
本質上，函數(shù)的可變參數(shù)是通過切片來實現(xiàn)的。
函數(shù)返回值
Go語言中通過return關鍵字向外輸出返回值。
多返回值
Go語言中函數(shù)支持多返回值，函數(shù)如果有多個返回值時必須用()將所有返回值包裹起來。
舉個例子：
func calc(x, y int) (int, int) { sum := x + y sub := x - y return sum, sub }
返回值命名
函數(shù)定義時可以給返回值命名，并在函數(shù)體中直接使用這些變量，最后通過return關鍵字返回。
例如：
func calc(x, y int) (sum, sub int) { sum = x + y sub = x - y return }
返回值補充
當我們的一個函數(shù)返回值類型為slice時，nil可以看做是一個有效的slice，沒必要顯示返回一個長度為0的切片。
func someFunc(x string) []int { if x == "" { return nil // 沒必要返回[]int{} } ... }
變量作用域
全局變量
全局變量是定義在函數(shù)外部的變量，它在程序整個運行周期內都有效。 在函數(shù)中可以訪問到全局變量。
package main import "fmt" //定義全局變量num var num int64 = 10 func testGlobalVar() { fmt.Printf("num=%dn", num) //函數(shù)中可以訪問全局變量num } func main() { testGlobalVar() //num=10 }
局部變量
局部變量又分為兩種： 函數(shù)內定義的變量無法在該函數(shù)外使用，例如下面的示例代碼main函數(shù)中無法使用testLocalVar函數(shù)中定義的變量x：
func testLocalVar() { //定義一個函數(shù)局部變量x,僅在該函數(shù)內生效 var x int64 = 100 fmt.Printf("x=%dn", x) } func main() { testLocalVar() fmt.Println(x) // 此時無法使用變量x }
如果局部變量和全局變量重名，優(yōu)先訪問局部變量。
package main import "fmt" //定義全局變量num var num int64 = 10 func testNum() { num := 100 fmt.Printf("num=%dn", num) // 函數(shù)中優(yōu)先使用局部變量 } func main() { testNum() // num=100 }
接下來我們來看一下語句塊定義的變量，通常我們會在if條件判斷、for循環(huán)、switch語句上使用這種定義變量的方式。
func testLocalVar2(x, y int) { fmt.Println(x, y) //函數(shù)的參數(shù)也是只在本函數(shù)中生效 if x > 0 { z := 100 //變量z只在if語句塊生效 fmt.Println(z) } //fmt.Println(z)//此處無法使用變量z }
還有我們之前講過的for循環(huán)語句中定義的變量，也是只在for語句塊中生效：
func testLocalVar3() { for i := 0; i < 10; i++ { fmt.Println(i) //變量i只在當前for語句塊中生效 } //fmt.Println(i) //此處無法使用變量i }
函數(shù)類型與變量
定義函數(shù)類型
我們可以使用type關鍵字來定義一個函數(shù)類型，具體格式如下：
type calculation func(int, int) int
上面語句定義了一個calculation類型，它是一種函數(shù)類型，這種函數(shù)接收兩個int類型的參數(shù)并且返回一個int類型的返回值。
簡單來說，凡是滿足這個條件的函數(shù)都是calculation類型的函數(shù)，例如下面的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
函數(shù)類型變量
我們可以聲明函數(shù)類型的變量并且為該變量賦值：
func main() { var c calculation // 聲明一個calculation類型的變量c c = add // 把add賦值給c fmt.Printf("type of c:%Tn", c) // type of c:main.calculation fmt.Println(c(1, 2)) // 像調用add一樣調用c f := add // 將函數(shù)add賦值給變量f1 fmt.Printf("type of f:%Tn", f) // type of f:func(int, int) int fmt.Println(f(10, 20)) // 像調用add一樣調用f }
高階函數(shù)
高階函數(shù)分為函數(shù)作為參數(shù)和函數(shù)作為返回值兩部分。
函數(shù)作為參數(shù)
函數(shù)可以作為參數(shù)：
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 }
函數(shù)作為返回值
函數(shù)也可以作為返回值：
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 } }
匿名函數(shù)和閉包
匿名函數(shù)
函數(shù)當然還可以作為返回值，但是在Go語言中函數(shù)內部不能再像之前那樣定義函數(shù)了，只能定義匿名函數(shù)。匿名函數(shù)就是沒有函數(shù)名的函數(shù)，匿名函數(shù)的定義格式如下：
func(參數(shù))(返回值){ 函數(shù)體 }
匿名函數(shù)因為沒有函數(shù)名，所以沒辦法像普通函數(shù)那樣調用，所以匿名函數(shù)需要保存到某個變量或者作為立即執(zhí)行函數(shù):
func main() { // 將匿名函數(shù)保存到變量 add := func(x, y int) { fmt.Println(x + y) } add(10, 20) // 通過變量調用匿名函數(shù) //自執(zhí)行函數(shù)：匿名函數(shù)定義完加()直接執(zhí)行 func(x, y int) { fmt.Println(x + y) }(10, 20) }
匿名函數(shù)多用于實現(xiàn)回調函數(shù)和閉包。
閉包
閉包指的是一個函數(shù)和與其相關的引用環(huán)境組合而成的實體。簡單來說，閉包=函數(shù)+引用環(huán)境。 首先我們來看一個例子：
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是一個函數(shù)并且它引用了其外部作用域中的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 }
閉包其實并不復雜，只要牢記閉包=函數(shù)+引用環(huán)境。
defer語句
Go語言中的defer語句會將其后面跟隨的語句進行延遲處理。在defer歸屬的函數(shù)即將返回時，將延遲處理的語句按defer定義的逆序進行執(zhí)行，也就是說，先被defer的語句最后被執(zhí)行，最后被defer的語句，最先被執(zhí)行。
舉個例子：
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執(zhí)行時機
在Go語言的函數(shù)中return語句在底層并不是原子操作，它分為給返回值賦值和RET指令兩步。而defer語句執(zhí)行的時機就在返回值賦值操作后，RET指令執(zhí)行前。具體如下圖所示：
defer經(jīng)典案例
閱讀下面的代碼，寫出最后的打印結果。
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注冊要延遲執(zhí)行的函數(shù)時該函數(shù)所有的參數(shù)都需要確定其值）
擴展知識：
內置函數(shù)介紹
| 內置函數(shù) | 介紹 |
|---|---|
| close | 主要用來關閉channel |
| len | 用來求長度，比如string、array、slice、map、channel |
| new | 用來分配內存，主要用來分配值類型，比如int、struct。返回的是指針 |
| make | 用來分配內存，主要用來分配引用類型，比如chan、map、slice |
| append | 用來追加元素到數(shù)組、slice中 |
| panic和recover | 用來做錯誤處理 |
panic/recover
Go語言中目前（Go1.12）是沒有異常機制，但是使用panic/recover模式來處理錯誤。 panic可以在任何地方引發(fā)，但recover只有在defer調用的函數(shù)中有效。 首先來看一個例子：
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中引發(fā)了panic導致程序崩潰，異常退出了。這個時候我們就可以通過recover將程序恢復回來，繼續(xù)往后執(zhí)行。
func funcA() { fmt.Println("func A") } func funcB() { defer func() { err := recover() //如果程序出出現(xiàn)了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 recover一定要在可能引發(fā)panic的語句之前定義。
練習題
-
分金幣
/* 你有50枚金幣，需要分配給以下幾個人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。 分配規(guī)則如下： a. 名字中每包含1個'e'或'E'分1枚金幣 b. 名字中每包含1個'i'或'I'分2枚金幣 c. 名字中每包含1個'o'或'O'分3枚金幣 d: 名字中每包含1個'u'或'U'分4枚金幣 寫一個程序，計算每個用戶分到多少金幣，以及最后剩余多少金幣？ 程序結構如下，請實現(xiàn) ‘dispatchCoin’ 函數(shù) */ 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) } */ func main() { for _, v := range users { distribution[v] = 0 for _, k := range v { if k == 'e' || k == 'E' { distribution[v]++ } if k == 'i' || k == 'I' { distribution[v] += 2 } if k == 'o' || k == 'O' { distribution[v] += 3 } if k == 'u' || k == 'U' { distribution[v] += 4 } } } pay := 0 for i, v := range distribution { fmt.Printf("%s 分到:%dn", i, v) pay += v } fmt.Printf("剩余：%d", (coins - pay)) }
【
