Go 裡的函式

阿新 • • 發佈：2020-09-01

1. 關於函式

函式是基於功能或邏輯進行封裝的可複用的程式碼結構。將一段功能複雜、很長的一段程式碼封裝成多個程式碼片段（即函式），有助於提高程式碼可讀性和可維護性。

在 Go 語言中，函式可以分為兩種：

帶有名字的普通函式
沒有名字的匿名函式

由於 Go語言是編譯型語言，所以函式編寫的順序是無關緊要的，它不像 Python 那樣，函式在位置上需要定義在呼叫之前。

2. 函式的宣告

函式的宣告，使用 func 關鍵字，後面依次接函式名，引數列表，返回值列表，用 {} 包裹的程式碼邏輯體

func 函式名(形式引數列表)(返回值列表){
    函式體
}

形式引數列表描述了函式的引數名以及引數型別，這些引數作為區域性變數，其值由引數呼叫者提供
返回值列表描述了函式返回值的變數名以及型別，如果函式返回一個無名變數或者沒有返回值，返回值列表的括號是可以省略的。

舉個例子，定義一個 sum 函式，接收兩個 int 型別的引數，在執行中，將其值分別賦值給 a，b，並規定必須返回一個int型別的值。

func sum(a int, b int) (int){
    return a + b
}
func main() {
    fmt.Println(sum(1,2))
}

3. 函式實現可變引數

上面舉的例子，引數個數都是固定的，這很好理解，指定什麼型別的引數就傳入什麼型別的變數，數量上，不能多一個，也不能少一個。（好像沒有可選引數）。

在 Python 中我們可以使用 *args 和 **kw ，還實現可變引數的函式。

可變引數分為幾種：

多個型別一致的引數
多個型別不一致的引數

多個型別一致的引數

首先是多個型別一致的引數。

這邊定義一個可以對多個數值進行求和的函式，

使用...int，表示一個元素為int型別的切片，用來接收呼叫者傳入的引數。

// 使用 ...型別，表示一個元素為int型別的切片
func sum(args ...int) int {
    var sum int
    for _, v := range args {
        sum += v
    }
    return sum
}
func main() {
    fmt.Println(sum( 
1, 2, 3))
}

// output: 6

其中...是 Go 語言為了方便程式設計師寫程式碼而實現的語法糖，如果該函式下會多個型別的函式，這個語法糖必須得是最後一個引數。

同時這個語法糖，只能在定義函式時使用。

多個型別不一致的引數

上面那個例子中，我們的引數型別都是 int，如果你希望傳多個引數且這些引數的型別都不一樣，可以指定型別為...interface{}，然後再遍歷。

比如下面這段程式碼，是Go語言標準庫中 fmt.Printf() 的函式原型：

import "fmt"
func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
                fmt.Println(arg, "is an int value.")
            case string:
                fmt.Println(arg, "is a string value.")
            case int64:
                fmt.Println(arg, "is an int64 value.")
            default:
                fmt.Println(arg, "is an unknown type.")
        }
    }
}

func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello"
    var v4 float32 = 1.234
    MyPrintf(v1, v2, v3, v4)
}

在某些情況下，我們需要定義一個引數個數可變的函式，具體傳入幾個引數，由呼叫者自己決定，但不管傳入幾個引數，函式都能夠處理。

比如這邊實現一個累加

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

4. 多個可變引數函式傳遞引數

上面提到了可以使用...來接收多個引數，除此之外，它還有一個用法，就是用來解序列，將函式的可變引數（一個切片）一個一個取出來，傳遞給另一個可變引數的函式，而不是傳遞可變引數變數本身。

同樣這個用法，也只能在給函式傳遞引數裡使用。

例子如下：

import "fmt"

func sum(args ...int) int {
    var result int
    for _, v := range args {
        result += v
    }
    return result
}

func Sum(args ...int) int {
    // 利用 ... 來解序列
    result := sum(args...)
    return result
}
func main() {
    fmt.Println(sum(1, 2, 3))
}

5. 函式的返回值

Go語言中的函式，在你定義的時候，就規定了此函式

有沒有返回值？

當沒有指明返回值的型別時, 函式體也可以有 return，但Go並不像 Python 那樣沒有return值，外部仍可以用變數來接收空值

返回幾個值？

Go 支援一個函式返回多個值

func double(a int) (int, int) {
   b := a * 2
   return a, b
}
func main() {
   // 接收引數用逗號分隔
   a, b := double(2)
   fmt.Println(a, b)
}

怎麼返回值?

Go支援返回帶有變數名的值

func double(a int) (b int) {
   // 不能使用 := ,因為在返回值哪裡已經聲明瞭為int
   b = a * 2
   // 不需要指明寫回哪個變數,在返回值型別那裡已經指定了
   return
}
func main() {
   fmt.Println(double(2))
}
// output: 4

6. 方法與函式

那方法和函式有什麼區別？為防有朋友第一次接觸面向物件，這裡多嘴一句。

方法，是一種特殊的函式。當你一個函式和物件/結構體進行繫結的時候，我們就稱這個函式是一個方法。

7. 匿名函式的使用

所謂匿名函式，就是沒有名字的函式，它只有函式邏輯體，而沒有函式名。

定義的格式如下

func(引數列表)(返回引數列表){
    函式體
}

一個名字實際上並沒有多大區別，所有使用匿名函式都可以改成普通有名函式，那麼什麼情況下，會使用匿名函式呢？

定義變數名，是一個不難但是還費腦子的事情，對於那到只使用一次的函式，是沒必要擁有姓名的。這才有了匿名函式。

有了這個背景，決定了匿名函式只有擁有短暫的生命，一般都是定義後立即使用。

就像這樣，定義後立馬執行（這裡只是舉例，實際程式碼沒有意義）。

func(data int) {
    fmt.Println("hello", data)
}(100)

亦或是做為回撥函式使用

// 第二個引數為函式
func visit(list []int, f func(int)) {
    for _, v := range list {
        // 執行回撥函式
        f(v)
    }
}
func main() {
    // 使用匿名函式直接做為引數
    visit([]int{1, 2, 3, 4}, func(v int) {
        fmt.Println(v)
    })
}