6.2 函式引數與返回值

函式能夠接收引數供自己使用，也可以返回零個或多個值（我們通常把返回多個值稱為返回一組值）。相比與 C、C++、Java 和 C#，多值返回是 Go 的一大特性，為我們判斷一個函式是否正常執行（參考 第 5.2 節）提供了方便。

我們通過 return 關鍵字返回一組值。事實上，任何一個有返回值（單個或多個）的函式都必須以 return 或 panic（參考第 13 章）結尾。

在函式塊裡面，return 之後的語句都不會執行。如果一個函式需要返回值，那麼這個函式裡面的每一個程式碼分支（code-path）都要有 return 語句。

問題 6.1：下面的函式將不會被編譯，為什麼呢？大家可以試著糾正過來。

func (st *Stack) Pop() int {
    v := 0
    for ix := len(st) - 1; ix >= 0; ix-- {
        if v = st[ix]; v != 0 {
            st[ix] = 0
            return v
        }
    }
}    

函式定義時，它的形參一般是有名字的，不過我們也可以定義沒有形參名的函式，只有相應的形參型別，就像這樣：func f(int, int, float64)。

沒有引數的函式通常被稱為 niladic 函式（niladic function），就像 main.main()。

6.2.1 按值傳遞（call by value） 按引用傳遞（call by reference）

Go 預設使用按值傳遞來傳遞引數，也就是傳遞引數的副本。函式接收引數副本之後，在使用變數的過程中可能對副本的值進行更改，但不會影響到原來的變數，比如 Function(arg1)。

如果你希望函式可以直接修改引數的值，而不是對引數的副本進行操作，你需要將引數的地址（變數名前面新增&符號，比如 &variable）傳遞給函式，這就是按引用傳遞，比如 Function(&arg1)，此時傳遞給函式的是一個指標。如果傳遞給函式的是一個指標，指標的值（一個地址）會被複制，但指標的值所指向的地址上的值不會被複制；我們可以通過這個指標的值來修改這個值所指向的地址上的值。（譯者注：指標也是變數型別，有自己的地址和值，通常指標的值指向一個變數的地址。所以，按引用傳遞也是按值傳遞。）

幾乎在任何情況下，傳遞指標（一個32位或者64位的值）的消耗都比傳遞副本來得少。

在函式呼叫時，像切片（slice）、字典（map）、介面（interface）、通道（channel）這樣的引用型別都是預設使用引用傳遞（即使沒有顯式的指出指標）。

有些函式只是完成一個任務，並沒有返回值。我們僅僅是利用了這種函式的副作用，就像輸出文字到終端，傳送一個郵件或者是記錄一個錯誤等。

但是絕大部分的函式還是帶有返回值的。

如下，simple_function.go 裡的 MultiPly3Nums 函式帶有三個形參，分別是 a、b、c，還有一個 int 型別的返回值（被註釋的程式碼具有和未註釋部分同樣的功能，只是多引入了一個本地變數）：

示例 6.2 simple_function.go

package main

import "fmt"

func main() {
    fmt.Printf("Multiply 2 * 5 * 6 = %d\n", MultiPly3Nums(2, 5, 6))
    // var i1 int = MultiPly3Nums(2, 5, 6)
    // fmt.Printf("MultiPly 2 * 5 * 6 = %d\n", i1)
}

func MultiPly3Nums(a int, b int, c int) int {
    // var product int = a * b * c
    // return product
    return a * b * c
}

輸出顯示：

Multiply 2 * 5 * 6 = 60

如果一個函式需要返回四到五個值，我們可以傳遞一個切片給函式（如果返回值具有相同型別）或者是傳遞一個結構體（如果返回值具有不同的型別）。因為傳遞一個指標允許直接修改變數的值，消耗也更少。

問題 6.2：

如下的兩個函式呼叫有什麼不同：

(A) func DoSomething(a *A) {
        b = a
    }

(B) func DoSomething(a A) {
        b = &a
    }

6.2.2 命名的返回值（named return variables）

如下，multiple_return.go 裡的函式帶有一個 int 引數，返回兩個 int 值；其中一個函式的返回值在函式呼叫時就已經被賦予了一個初始零值。

getX2AndX3 與 getX2AndX3_2 兩個函式演示瞭如何使用非命名返回值與命名返回值的特性。當需要返回多個非命名返回值時，需要使用 () 把它們括起來，比如 (int, int)。

命名返回值作為結果形參（result parameters）被初始化為相應型別的零值，當需要返回的時候，我們只需要一條簡單的不帶引數的return語句。需要注意的是，即使只有一個命名返回值，也需要使用 () 括起來（參考 第 6.6 節的 fibonacci.go 函式）。

示例 6.3 multiple_return.go

package main

import "fmt"

var num int = 10
var numx2, numx3 int

func main() {
    numx2, numx3 = getX2AndX3(num)
    PrintValues()
    numx2, numx3 = getX2AndX3_2(num)
    PrintValues()
}

func PrintValues() {
    fmt.Printf("num = %d, 2x num = %d, 3x num = %d\n", num, numx2, numx3)
}

func getX2AndX3(input int) (int, int) {
    return 2 * input, 3 * input
}

func getX2AndX3_2(input int) (x2 int, x3 int) {
    x2 = 2 * input
    x3 = 3 * input
    // return x2, x3
    return
}

輸出結果：

num = 10, 2x num = 20, 3x num = 30    
num = 10, 2x num = 20, 3x num = 30 

警告：

• return 或 return var 都是可以的。
• 不過 return var = expression（表示式） 會引發一個編譯錯誤：syntax error: unexpected =, expecting semicolon or newline or }。

即使函式使用了命名返回值，你依舊可以無視它而返回明確的值。

任何一個非命名返回值（使用非命名返回值是很糟的程式設計習慣）在 return 語句裡面都要明確指出包含返回值的變數或是一個可計算的值（就像上面警告所指出的那樣）。

儘量使用命名返回值：會使程式碼更清晰、更簡短，同時更加容易讀懂。

練習 6.1 mult_returnval.go

編寫一個函式，接收兩個整數，然後返回它們的和、積與差。編寫兩個版本，一個是非命名返回值，一個是命名返回值。

練習 6.2 error_returnval.go

編寫一個名字為 MySqrt 的函式，計算一個 float64 型別浮點數的平方根，如果引數是一個負數的話將返回一個錯誤。編寫兩個版本，一個是非命名返回值，一個是命名返回值。

6.2.3 空白符（blank identifier）

空白符用來匹配一些不需要的值，然後丟棄掉，下面的 blank_identifier.go 就是很好的例子。

ThreeValues 是擁有三個返回值的不需要任何引數的函式，在下面的例子中，我們將第一個與第三個返回值賦給了 i1 與f1。第二個返回值賦給了空白符 _，然後自動丟棄掉。

示例 6.4 blank_identifier.go

package main

import "fmt"

func main() {
    var i1 int
    var f1 float32
    i1, _, f1 = ThreeValues()
    fmt.Printf("The int: %d, the float: %f \n", i1, f1)
}

func ThreeValues() (int, int, float32) {
    return 5, 6, 7.5
}

輸出結果：

The int: 5, the float: 7.500000

另外一個示例，函式接收兩個引數，比較它們的大小，然後按小-大的順序返回這兩個數，示例程式碼為minmax.go。

示例 6.5 minmax.go

package main

import "fmt"

func main() {
    var min, max int
    min, max = MinMax(78, 65)
    fmt.Printf("Minmium is: %d, Maximum is: %d\n", min, max)
}

func MinMax(a int, b int) (min int, max int) {
    if a < b {
        min = a
        max = b
    } else { // a = b or a < b
        min = b
        max = a
    }
    return
}

輸出結果：

Minimum is: 65, Maximum is 78

6.2.4 改變外部變數（outside variable）

傳遞指標給函式不但可以節省記憶體（因為沒有複製變數的值），而且賦予了函式直接修改外部變數的能力，所以被修改的變數不再需要使用 return 返回。如下的例子，reply 是一個指向 int 變數的指標，通過這個指標，我們在函式內修改了這個int 變數的數值。

示例 6.6 side_effect.go

package main

import (
    "fmt"
)

// this function changes reply:
func Multiply(a, b int, reply *int) {
    *reply = a * b
}

func main() {
    n := 0
    reply := &n
    Multiply(10, 5, reply)
    fmt.Println("Multiply:", *reply) // Multiply: 50
}

這僅僅是個指導性的例子，當需要在函式內改變一個佔用記憶體比較大的變數時，效能優勢就更加明顯了。然而，如果不小心使用的話，傳遞一個指標很容易引發一些不確定的事，所以，我們要十分小心那些可以改變外部變數的函式，在必要時，需要新增註釋以便其他人能夠更加清楚的知道函式裡面到底發生了什麼。