大家好，我是Golang語言社群主編彬哥，本篇給大家帶來的是關於Go語言中的函式呼叫相關。

函式呼叫非常方便，只要事先匯入該函式所在的包，就可以呼叫了：

import "mymath"
c := mymath.Add(1,2)

注意：小寫字母開頭的函式只在本包內可見，大寫字母開頭的函式才能被其它包使用。

不定引數

例如：

func foo(args ...int) {　　// 接受不定數量的引數，這些引數都是int型別
    for _, arg := range args {
        fmt.Println(arg) 
    }
}

foo(2,3,4)
foo(1,3,7,13)   
 

形如"...type"格式的型別只能作為函式的引數型別存在，並且必須是最後一個引數。

"...type"本質上是一個數組切片，也就是[]type，這也是為什麼上面的引數args可以用for迴圈來獲得每個傳入的引數。

如果希望不定引數傳任意型別，可以指定型別為interface{}，如標準庫中的fmt.Printf()的函式原型：

func Printf(format string, args ...interface{}) {
    ...
}

例如：

func foo(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 float32:
                fmt.Println(arg, "is a float32 value.") 
            default:
                fmt.Println(arg, "is an unknown type.") 
        }
    }
}
 

匿名函式與閉包

匿名函式可以直接賦值給一個變數，例如：

f := func(x, y int) int {
    return x+y
}

或者直接執行一個匿名函式：

func(ch chan int) {
    ch <- ACK
} (reply_chan)    // 花括號後面直接跟引數列表表示函式呼叫

閉包：當一個函式內部巢狀另一個函式定義時，內部的函式體可以訪問外部函式的區域性變數。

a := func() (func()) {
    var i int = 10 
    return func(){
        fmt.Printf("i=%dn", i)
        i++
    }
}

c1 := a() 
c2 := a() 
c1()        // 10
c1()        // 11
c1()        // 12
c2()        // 10
 

c1和c2是建立在同一個函式上，但作用在同一個區域性變數的不同例項上的兩個不同的閉包。

錯誤處理

Go語言引入了一個錯誤處理的標準模式，即error介面，該介面定義如下：

type error interface {
    Error() string
}

對於大多數函式，如果要返回錯誤，可以將error作為多返回值的最後一個：

func foo(param int)(ret int, err error)
{
  ...  
}

呼叫時的程式碼：

n, err := foo(0)
if err != nil {
    //  錯誤處理
} else {
    // 使用返回值n
}