Golang – 函數與方法

主題：多重回傳值

簡介

在 Go 語言中，多重回傳值（multiple return values） 是一項核心特性，也是許多程式設計師在撰寫乾淨、可讀程式碼時最常依賴的工具。相較於其他語言必須透過結構體、指標或全域變數才能一次回傳多個資訊，Go 直接支援在函式宣告與呼叫時返回任意數量的值，讓錯誤處理、資料分解、以及 API 設計都變得更簡潔。

本篇文章將從概念說明、實作範例、常見陷阱與最佳實踐，逐步帶領讀者掌握多重回傳值的使用方式，並提供實務上的應用情境，幫助 初學者 與 中級開發者 能在日常開發中自然運用這項功能。

核心概念

1. 基本語法

在 Go 中，函式的回傳型別可以寫成一組用圓括號包住的型別列表，例如：

func Divide(a, b float64) (float64, error) {
    // ...
}

上述 Divide 函式會回傳商（float64）與 錯誤資訊（error）。呼叫時可以直接以多個變數接收：

quotient, err := Divide(10, 2)

如果只需要其中一個回傳值，亦可使用空白識別子 _ 來拋棄不需要的部分：

quotient, _ := Divide(10, 2)   // 忽略 error

2. 命名回傳值

Go 允許在函式宣告時為回傳值命名，這樣在函式內部就可以直接使用這些變數，並且在 return 時不必寫出具體的值，直接使用 return 即可返回目前的命名變數。

func Swap(a, b int) (x int, y int) {
    x = b
    y = a
    return          // 等同於 return x, y
}

小技巧：命名回傳值適合用在簡單的資料搬移或錯誤處理的情境，過度使用會降低可讀性，請斟酌使用。

3. 多重回傳值的實用範例

以下提供五個常見且實用的範例，說明多重回傳值在不同情境下的應用。

範例 1：除法與錯誤處理

// Divide 會回傳除法結果與可能的錯誤
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除數不能為 0")
    }
    return a / b, nil
}

// 呼叫端
quotient, err := Divide(10, 0)
if err != nil {
    fmt.Println("計算失敗:", err)
} else {
    fmt.Println("結果 =", quotient)
}

說明：利用多重回傳值，同時返回運算結果與錯誤資訊，呼叫端只要檢查 err 是否為 nil 即可。

範例 2：從字串切割取得兩個子字串

// SplitFirst 只切割一次，回傳前半段、後半段與是否成功的布林值
func SplitFirst(s, sep string) (string, string, bool) {
    idx := strings.Index(s, sep)
    if idx < 0 {
        return s, "", false
    }
    return s[:idx], s[idx+len(sep):], true
}

// 呼叫端
head, tail, ok := SplitFirst("golang:awesome", ":")
if ok {
    fmt.Printf("前半段: %s, 後半段: %s\n", head, tail)
}

說明：回傳三個值讓呼叫端同時取得切割結果與是否成功的旗標，避免額外的 if 判斷。

範例 3：從資料庫查詢返回值與錯誤

type User struct {
    ID   int
    Name string
}

// GetUserByID 從模擬資料庫取得使用者，若找不到則回傳 nil 與錯誤
func GetUserByID(id int) (*User, error) {
    // 假設有一個全域的 map 作為資料庫
    if u, ok := fakeDB[id]; ok {
        return &u, nil
    }
    return nil, fmt.Errorf("找不到 ID 為 %d 的使用者", id)
}

// 呼叫端
user, err := GetUserByID(42)
if err != nil {
    log.Println(err)
} else {
    fmt.Printf("使用者名稱: %s\n", user.Name)
}

說明：返回指標與錯誤，讓呼叫端可以直接使用 user，同時保有錯誤訊息。

範例 4：計算統計資訊（平均值、最大值、最小值）

func Stats(nums []float64) (avg, max, min float64) {
    if len(nums) == 0 {
        return 0, 0, 0
    }
    sum := 0.0
    max = nums[0]
    min = nums[0]
    for _, v := range nums {
        sum += v
        if v > max {
            max = v
        }
        if v < min {
            min = v
        }
    }
    avg = sum / float64(len(nums))
    return // 直接回傳 avg, max, min
}

// 呼叫端
average, maximum, minimum := Stats([]float64{1.2, 3.4, 5.6})
fmt.Printf("Avg=%.2f Max=%.2f Min=%.2f\n", average, maximum, minimum)

說明：一次回傳三個統計結果，使用 命名回傳值 讓 return 更簡潔。

範例 5：使用匿名回傳值與 defer 產生資源清理

func OpenFile(path string) (file *os.File, err error) {
    file, err = os.Open(path)
    if err != nil {
        return nil, err
    }
    // 使用 defer 於呼叫端自動關閉
    defer func() {
        if r := recover(); r != nil {
            file.Close()
            panic(r)
        }
    }()
    return // 回傳已開啟的 file 與 nil
}

// 呼叫端
f, err := OpenFile("data.txt")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
// 之後可以安全使用 f

說明：透過匿名回傳值 (file *os.File, err error) 搭配 defer，在資源取得失敗時自動清理，讓錯誤處理更一致。

4. 多重回傳值與解構賦值（Destructuring Assignment）

Go 允許在 同一行 同時宣告與賦值多個變數，這種寫法在處理多重回傳值時非常常見：

a, b, c := Foo()   // Foo 回傳三個值

若只想保留其中部分值，可使用 _：

_, middle, _ := Foo()   // 只取第二個回傳值

常見陷阱與最佳實踐

陷阱	說明	建議的做法
過度使用匿名回傳值	只回傳 `int, error` 等簡單型別時，若未命名會讓程式碼在閱讀時失去上下文。	為重要回傳值（尤其是錯誤）使用命名回傳值或在呼叫端加上註解。
忽略錯誤 (`_ = err`)	忽略錯誤會讓程式在執行時產生不可預期的行為。	永遠檢查 `error`，除非真的確定不會發生錯誤（如測試環境）。
回傳過多值	一次回傳太多資訊會讓呼叫端難以維護。	盡量保持回傳值在 2~3 個以內，若需要更多資訊，考慮使用結構體。
命名回傳值與局部變數衝突	若在函式內部重新宣告同名變數，會產生遮蔽（shadow）問題。	使用 `:=` 時注意不要遮蔽已命名的回傳值，必要時改用 `=`。
忘記 `defer` 關閉資源	多重回傳值常用於開啟檔案、資料庫連線等資源，忘記關閉會導致資源泄漏。	在取得資源後立即 `defer` 關閉，或在回傳前包裝清理邏輯。

最佳實踐：

錯誤永遠放最後：慣例上，回傳值的最後一個位置放 error，讓呼叫端可以一致使用 if err != nil 進行檢查。
使用命名回傳值提升可讀性：僅在簡單情況下使用，避免過度依賴。
適度使用 _：只在確定不需要的情況下拋棄回傳值，避免因為忽略重要資訊而產生 bug。
結構化回傳：若需要回傳 3 個以上的相關資料，建議定義結構體，讓 API 更具語意。

實際應用場景

Web API 的回傳
在撰寫 HTTP handler 時，常見的模式是回傳 statusCode int, response []byte, err error，讓上層統一處理 HTTP 狀態與錯誤訊息。
資料庫交易（Transaction）
BeginTx 會回傳 *sql.Tx, error，呼叫端可以直接檢查錯誤，若成功則使用交易物件進行後續操作。
檔案處理
os.Open、os.Create 等函式皆回傳 *File, error，配合 defer file.Close()，確保資源釋放。
演算法返回多個結果
例如排序演算法可能返回 sorted []int, swaps int，讓呼叫端同時取得排序結果與統計資訊。
測試與驗證
測試函式常使用 got, want, ok := compare(a, b)，直接得到比較結果與布林旗標，簡化測試程式碼。

總結

多重回傳值 是 Go 語言設計的核心亮點，讓錯誤處理與資料分解變得自然且一致。
透過 命名回傳值、匿名回傳值 與 解構賦值，開發者可以寫出簡潔、易讀的程式碼。
在實務開發中，適度使用 多重回傳值、遵守錯誤最後一位 的慣例、以及 避免過度返回，是提升程式品質的關鍵。
面對需要回傳多於兩個值的情境，結構體 是更好的抽象方式，能提供更清晰的語意與未來擴充性。

掌握了多重回傳值的正確用法後，你將能在 Web 服務、資料庫操作、演算法實作 等各種場景中寫出更具表現力且可靠的 Go 程式碼。祝你在 Golang 的學習之路上，持續發現語言的魅力與實務價值！