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
}
這僅僅是個指導性的例子，當需要在函數內改變一個佔用內存比較大的變量時，性能優勢就更加明顯了。然而，如果不小心使用的話，傳遞一個指針很容易引發一些不確定的事，所以，我們要十分小心那些可以改變外部變量的函數，在必要時，需要添加註釋以便其他人能夠更加清楚的知道函數裏面到底發生了什麼。