Golang

單元：函數與方法

主題：方法（methods）與接收者（receiver）

---

簡介

在 Go 語言中，方法是與特定型別（type）緊密結合的函式，它讓我們能夠以「物件導向」的方式操作資料。雖然 Go 並不像 Java 或 C# 那樣提供完整的類別繼承機制，但透過 接收者（receiver），我們可以為自訂結構（struct）或其他型別添加行為，實現封裝、抽象與多型等概念。

掌握方法與接收者的使用，不僅能讓程式碼更具可讀性與可維護性，還能在設計 API、實作介面（interface）或撰寫測試時，提供更自然且安全的抽象層。對於剛踏入 Go 的新手以及想要提升程式設計技巧的中級開發者而言，這是必學的核心概念。

---

核心概念

1. 方法與普通函式的差別

項目	普通函式	方法
定義位置	任意 package 內	必須與型別（receiver）綁定
呼叫方式	Func(arg1, arg2)	value.Method(arg1, arg2)
可實作介面	否（除非使用函式型別）	是（符合介面方法簽名）

重點：方法的第一個參數是 接收者，它決定了方法屬於哪個型別。

2. 接收者的兩種形式：值接收者 vs. 指標接收者

type Counter struct {
    value int
}

// 值接收者：會在呼叫時複製一份 Counter
func (c Counter) Increment() {
    c.value++          // 只改變複製本，呼叫者的 value 不變
}

// 指標接收者：直接操作原始資料
func (c *Counter) Add(delta int) {
    c.value += delta   // 直接修改原始 Counter
}

• 值接收者：適用於不會改變內部狀態的只讀操作，或是結構體本身很小（如基本型別或小型 struct）時使用，以避免不必要的指標操作。
• 指標接收者：適用於需要修改內部欄位、或是結構體較大、複製成本高的情況。大多數情況下，建議統一使用指標接收者，以避免混淆。

技巧：若同一型別同時有值接收者與指標接收者的方法，Go 會自動在呼叫時做指標/值的轉換（只要方法集合不衝突），但為了程式碼一致性，仍建議保持同一接收者類型。

3. 方法與介面的關係

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Rectangle struct {
    Width, Height float64
}

// Rectangle 實作 Shape 介面
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

只要型別實作了介面所要求的所有方法，即可自動視為該介面的實作者，不需要額外宣告。這使得 Go 的介面非常靈活，常用於 依賴注入 與 測試 double（mock）等情境。

4. 方法的可見性（導出與未導出）

• 方法名稱首字母大寫 → 導出，在其他 package 可見。
• 方法名稱首字母小寫 → 未導出，僅在同一 package 內可見。

type user struct {
    name string
}

// Exported method
func (u *user) GetName() string { return u.name }

// Unexported method
func (u *user) setName(n string) { u.name = n }

5. 方法的多載（Overloading）與預設參數

Go 不支援方法多載，同一接收者下只能有一個同名方法。若需要類似功能，可透過 可變參數 或 不同名稱的輔助方法 來實現。

// 使用可變參數模擬多載
func (c *Counter) Add(deltas ...int) {
    for _, d := range deltas {
        c.value += d
    }
}

---

程式碼範例

以下提供 5 個實用範例，展示方法與接收者在不同情境下的寫法與意義。每段程式碼皆附上說明註解。

範例 1：基本的值接收者與指標接收者

package main

import "fmt"

type Point struct {
    X, Y int
}

// 值接收者：不會改變原始資料，只回傳計算結果
func (p Point) DistanceFromOrigin() float64 {
    return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}

// 指標接收者：修改座標位置
func (p *Point) Translate(dx, dy int) {
    p.X += dx
    p.Y += dy
}

func main() {
    p := Point{3, 4}
    fmt.Println("距離原點:", p.DistanceFromOrigin()) // 5

    p.Translate(1, -2)
    fmt.Printf("平移後座標: (%d, %d)\n", p.X, p.Y)   // (4, 2)
}

說明：DistanceFromOrigin 為只讀操作，使用值接收者即可；Translate 需要改變結構體內容，採用指標接收者。

範例 2：實作介面以支援多型

package main

import "fmt"

type Greeter interface {
    Greet() string
}

type English struct{}
type Chinese struct{}

// English 實作 Greeter
func (e English) Greet() string { return "Hello!" }

// Chinese 實作 Greeter
func (c Chinese) Greet() string { return "你好！" }

func Say(g Greeter) {
    fmt.Println(g.Greet())
}

func main() {
    Say(English{}) // Hello!
    Say(Chinese{}) // 你好！
}

說明：English 與 Chinese 只要實作 Greet 方法，就自動符合 Greeter 介面，無需顯式宣告。

範例 3：指標接收者與同步（Concurrency）

package main

import (
    "fmt"
    "sync"
)

type SafeCounter struct {
    mu    sync.Mutex
    value int
}

// 使用指標接收者保證同一個實例被多個 goroutine 共用
func (c *SafeCounter) Inc() {
    c.mu.Lock()
    c.value++
    c.mu.Unlock()
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func main() {
    var wg sync.WaitGroup
    counter := &SafeCounter{}

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Inc()
        }()
    }
    wg.Wait()
    fmt.Println("最終計數:", counter.Value()) // 1000
}

說明：指標接收者讓所有 goroutine 操作同一個 SafeCounter 實例，並透過 sync.Mutex 確保執行緒安全。

範例 4：方法鏈（Method Chaining）

package main

import "fmt"

type Builder struct {
    parts []string
}

// 每個方法回傳指標，允許串接呼叫
func (b *Builder) Add(part string) *Builder {
    b.parts = append(b.parts, part)
    return b
}
func (b *Builder) Build() string {
    return fmt.Sprintf("<%s>", strings.Join(b.parts, " "))
}

func main() {
    result := (&Builder{}).
        Add("golang").
        Add("method").
        Add("chaining").
        Build()
    fmt.Println(result) // <golang method chaining>
}

說明：返回 *Builder 使得呼叫可以像流式 API（fluent interface）般連續寫，提升可讀性。

範例 5：自訂類型的內建方法（Stringer）

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

// 實作 fmt.Stringer 介面，讓 fmt.Print 自動使用此方法
func (p Person) String() string {
    return fmt.Sprintf("%s (%d歲)", p.Name, p.Age)
}

func main() {
    p := Person{Name: "阿明", Age: 28}
    fmt.Println(p) // 阿明 (28歲)
}

說明：只要實作 String() string 方法，即可自訂類型在印出時的格式，這是 Go 常見的 內建介面 用法。

---

常見陷阱與最佳實踐

陷阱	可能的問題	建議的解決方式
混用值接收者與指標接收者	同一型別同時提供兩種接收者，呼叫者可能因自動轉換而產生意外行為（如不小心複製資料）	統一使用指標接收者，除非確定方法不會改變狀態且結構體非常小
忘記在介面實作時使用指標	介面要求的方法是指標接收者，但實作時用了值接收者，導致型別不符合介面	確認介面方法簽名與實作完全一致，必要時使用 var _ Interface = (*Type)(nil) 進行編譯時檢查
在方法內部修改切片或 map 的指標	直接改變切片或 map 的底層資料會影響呼叫者，可能不符合預期的「不可變」設計	若需要保護資料，請在方法內部 複製 這些可變容器，或將方法設為值接收者
忘記鎖定共享資源	在多 goroutine 中使用指標接收者的結構體，未加同步機制會導致 race condition	使用 sync.Mutex、sync.RWMutex 或 atomic 包，並在方法中正確加解鎖
過度暴露方法	將所有欄位的 getter/setter 都寫成公開方法，破壞封裝	只公開必要的行為，盡量讓資料保持 私有，透過語意明確的操作方法來修改狀態

最佳實踐

1. 一致性：同一型別的所有方法盡量使用相同的接收者類型（大多指標）。
2. 介面導向設計：先定義介面，再讓結構體實作，這樣可以在測試時輕鬆替換實作。
3. 避免過度設計：如果方法只是一個簡單的函式，且不需要存取結構體內部，則保持為普通函式即可。
4. 使用 go vet 與 golint：這些工具會提醒你指標 vs. 值接收者的潛在問題。
5. 編寫測試：特別是涉及指標接收者修改狀態的情況，寫單元測試可以確保行為符合預期。

---

實際應用場景

場景	為什麼需要方法與接收者
Web 框架的控制器（Controller）	每個控制器結構體保存請求上下文、資料庫連線等，使用指標接收者的 ServeHTTP 方法可以直接修改回應內容。
資料模型（Model）	例如 ORM 中的 User 結構體提供 Save() error、Delete() error 等方法，讓資料操作封裝在模型內，呼叫者只需要 user.Save()。
並行安全的計數器	如前範例 SafeCounter，指標接收者搭配 sync.Mutex，確保多 goroutine 同時遞增不會出錯。
自訂日誌（Logger）	Logger 結構體持有輸出目的地與設定，方法 Info(msg string)、Error(err error) 直接寫入日誌檔案或遠端服務。
多態渲染（Renderer）	定義 Renderer 介面，讓 JSONRenderer、XMLRenderer 各自實作 Render(v interface{}) ([]byte, error)，在 HTTP 回應時只需要呼叫 renderer.Render(data)。

---

總結

• 方法是與型別綁定的函式，透過 接收者（值或指標）決定其行為範圍與可變性。
• 指標接收者是最常見的選擇，因為它能避免不必要的複製、允許修改內部狀態，且在多執行緒環境下更容易加上同步保護。
• 介面讓方法成為多型的基礎，只要符合介面的簽名，即可自動視為實作，這是 Go 設計上最靈活的部分。
• 實務開發中，應該根據 封裝需求、效能考量與併發安全 來選擇接收者類型，並遵循 一致性、介面導向與最小公開原則。

掌握了方法與接收者的正確用法，你就能在 Go 中寫出 清晰、可維護且具擴充性的程式碼，無論是構建微服務、開發 CLI 工具，或是實作底層庫，都能得心應手。祝你寫程式快樂，持續探索 Go 的更多可能！