Go語言基礎之函數

時間 2019-11-07

標籤語言基礎函數简体版

原文原文鏈接

Go語言基礎之函數

函數是組織好的、可重複使用的、用於執行指定任務的代碼塊。本文介紹了Go語言中函數的相關內容。面試

一、函數

Go語言中支持函數、匿名函數和閉包，而且函數在Go語言中屬於「一等公民」。數組

1.1 函數定義

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

func 函數名(參數)(返回值){
    函數體
}

其中：閉包

函數名：由字母、數字、下劃線組成。但函數名的第一個字母不能是數字。在同一個包內，函數名也稱不能重名（包的概念詳見後文）。
參數：參數由參數變量和參數變量的類型組成，多個參數之間使用,分隔。
返回值：返回值由返回值變量和其變量類型組成，也能夠只寫返回值的類型，多個返回值必須用()包裹，並用,分隔。
函數體：實現指定功能的代碼塊。

咱們先來定義一個求兩個數之和的函數：app

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

函數的參數和返回值都是可選的，例如咱們能夠實現一個既不須要參數也沒有返回值的函數：函數

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

1.2 函數的調用

定義了函數以後，咱們能夠經過函數名()的方式調用函數。例如咱們調用上面定義的兩個函數，代碼以下：spa

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

注意，調用有返回值的函數時，能夠不接收其返回值。指針

1.3 參數

1.3.1 類型簡寫

函數的參數中若是相鄰變量的類型相同，則能夠省略類型，例如：code

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

上面的代碼中，intSum函數有兩個參數，這兩個參數的類型均爲int，所以能夠省略x的類型，由於y後面有類型說明，x參數也是該類型。blog

1.3.2 可變參數

可變參數是指函數的參數數量不固定。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

本質上，函數的可變參數是經過切片來實現的。

1.4 返回值

Go語言中經過return關鍵字向外輸出返回值。

1.4.1 多返回值

Go語言中函數支持多返回值，函數若是有多個返回值時必須用()將全部返回值包裹起來。

舉個例子：

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

1.4.2 返回值命名

函數定義時能夠給返回值命名，並在函數體中直接使用這些變量，最後經過return關鍵字返回。

例如：

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

二、函數進階

2.1 變量做用域

2.1.1 全局變量

全局變量是定義在函數外部的變量，它在程序整個運行週期內都有效。在函數中能夠訪問到全局變量。

package main

import "fmt"

//定義全局變量num
var num int64 = 10

func testGlobalVar() {
    fmt.Printf("num=%d\n", num) //函數中能夠訪問全局變量num
}
func main() {
    testGlobalVar() //num=10
}

2.1.2 局部變量

局部變量又分爲兩種：函數內定義的變量沒法在該函數外使用，例以下面的示例代碼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
}

2.2 函數類型與變量

2.2.1 定義函數類型

咱們可使用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

2.2.2 函數類型變量

咱們能夠聲明函數類型的變量而且爲該變量賦值：

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
}

2.3 高階函數

高階函數分爲函數做爲參數和函數做爲返回值兩部分。

2.3.1 函數做爲參數

函數能夠做爲參數：

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
}

2.3.2 函數做爲返回值

函數也能夠做爲返回值：

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
    }
}

2.4 匿名函數和閉包

2.4.1 匿名函數

函數固然還能夠做爲返回值，可是在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)
}

匿名函數多用於實現回調函數和閉包。

2.4.2 閉包

閉包指的是一個函數和與其相關的引用環境組合而成的實體。簡單來講，閉包=函數+引用環境。首先咱們來看一個例子：

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
}

閉包其實並不複雜，只要牢記閉包=函數+引用環境。

2.5 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語句能很是方便的處理資源釋放問題。好比：資源清理、文件關閉、解鎖及記錄時間等。

2.5.1 defer執行時機

在Go語言的函數中return語句在底層並非原子操做，它分爲給返回值賦值和RET指令兩步。而defer語句執行的時機就在返回值賦值操做後，RET指令執行前。具體以下圖所示：

2.5.2 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())
}

2.5.3 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註冊要延遲執行的函數時該函數全部的參數都須要肯定其值）

3、內置函數介紹

內置函數	介紹
close	主要用來關閉channel
len	用來求長度，好比string、array、slice、map、channel
new	用來分配內存，主要用來分配值類型，好比int、struct。返回的是指針
make	用來分配內存，主要用來分配引用類型，好比chan、map、slice
append	用來追加元素到數組、slice中
panic和recover	用來作錯誤處理

3.1 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的語句以前定義。

4、練習題

分金幣

/*
你有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)
}