Golang

單元：結構與介面

主題：介面的組合與型態轉換

---

簡介

在 Go 語言裡，**介面（interface）**是實作多型（polymorphism）的核心機制。它不僅讓程式碼更具彈性，也能降低耦合度，使系統更容易擴充與維護。
本單元聚焦於 介面的組合（interface embedding） 與 型態轉換（type assertion / type switch），兩者是日常開發中最常碰到、也是最能展現 Go 介面威力的技巧。

掌握這些概念後，你將能：

• 以小而簡潔的介面構建大型抽象層
• 在執行期安全地取得底層具體型別
• 以「組合」取代「繼承」的設計方式，寫出更具可測試性的程式

以下內容以 初學者到中級開發者 為目標，透過大量實作範例一步步說明，並提供常見陷阱與最佳實踐，幫助你在實務專案中快速上手。

---

核心概念

1. 介面的組合（Embedding Interface）

Go 的介面可以 嵌入（embed） 其他介面，形成「介面的組合」。被嵌入的介面所宣告的方法會自動成為外層介面的一部份，等同於「繼承」但沒有繼承的副作用。

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 組合兩個介面成為 ReadWriter
type ReadWriter interface {
    Reader   // ← 嵌入 Reader
    Writer   // ← 嵌入 Writer
}

• 好處
  • 單一職責：每個小介面只負責一件事，組合後即可形成更完整的抽象。
  • 彈性擴充：未來若要加入 Closer，只要在 ReadWriter 中再嵌入即可，既不破壞舊有實作，也不需要修改使用者程式碼。

範例 1：自訂緩衝區實作 ReadWriter

package main

import (
    "bytes"
    "fmt"
)

// 自訂緩衝區，同時支援讀寫
type Buffer struct {
    data bytes.Buffer
}

// 實作 Reader
func (b *Buffer) Read(p []byte) (int, error) {
    return b.data.Read(p)
}

// 實作 Writer
func (b *Buffer) Write(p []byte) (int, error) {
    return b.data.Write(p)
}

// 確認 Buffer 同時滿足 Reader、Writer、ReadWriter
func main() {
    var rw ReadWriter = &Buffer{} // 直接以組合介面指派
    rw.Write([]byte("Hello, Go!"))
    buf := make([]byte, 20)
    n, _ := rw.Read(buf)
    fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

重點：只要 Buffer 實作了 Reader 與 Writer，它自動符合 ReadWriter，不需要額外的程式碼。

---

2. 介面的組合與多層嵌入

介面可以多層嵌入，形成階層化的抽象。

type Closer interface {
    Close() error
}

// 多層組合：ReadWriteCloser 同時具備讀、寫、關閉功能
type ReadWriteCloser interface {
    ReadWriter // ← 已包含 Reader、Writer
    Closer    // ← 再加入 Close
}

範例 2：使用標準庫 os.File 作為 ReadWriteCloser

package main

import (
    "fmt"
    "os"
)

func copyFile(src, dst string) error {
    // os.Open 會回傳 *os.File，已實作 ReadWriteCloser
    in, err := os.Open(src)
    if err != nil {
        return err
    }
    defer in.Close()

    out, err := os.Create(dst)
    if err != nil {
        return err
    }
    defer out.Close()

    // 直接以 ReadWriteCloser 介面操作
    var rwc ReadWriteCloser = out
    _, err = io.Copy(rwc, in) // io.Copy 需要 Reader 與 Writer
    return err
}

func main() {
    if err := copyFile("a.txt", "b.txt"); err != nil {
        fmt.Println("copy error:", err)
    } else {
        fmt.Println("copy success")
    }
}

技巧：即使 *os.File 並未顯式宣告 ReadWriteCloser，只要它滿足所有嵌入方法，就能被隱式視為該介面。

---

3. 型態轉換（Type Assertion）

當你拿到一個介面變數時，常會需要取得其底層具體型別，以使用特有的方法或屬性。這時就用 型態斷言（type assertion）或 型態切換（type switch）。

3.1 單一型態斷言

var i interface{} = "Golang"
s, ok := i.(string) // 若 i 真的是 string，ok 為 true，s 為底層值
if ok {
    fmt.Println("string length:", len(s))
}

若斷言失敗，ok 為 false，而 s 為型別的零值，程式不會 panic。

3.2 必須成功的斷言（會 panic）

s := i.(string) // 若 i 不是 string，程式直接 panic

建議：在不確定型別時，使用帶 ok 的斷言，避免意外崩潰。

3.3 型態切換（type switch）

func describe(v interface{}) {
    switch t := v.(type) {
    case int:
        fmt.Printf("整數 %d\n", t)
    case string:
        fmt.Printf("字串 %q，長度 %d\n", t, len(t))
    case fmt.Stringer:
        fmt.Printf("實作 String() 的型別：%s\n", t.String())
    default:
        fmt.Printf("未知型別 %T\n", t)
    }
}

---

4. 介面組合與型態轉換的實務結合

當一個介面嵌入多個小介面時，我們常會在執行期檢查「是否同時支援某些額外功能」。

範例 3：自訂 Logger，支援 io.Writer 與 fmt.Stringer

package main

import (
    "fmt"
    "io"
    "os"
)

// 基本 Logger 只需要 Write 方法
type Logger interface {
    io.Writer
}

// 進階 Logger 同時支援 String 方法，方便直接印出設定資訊
type AdvancedLogger interface {
    Logger
    fmt.Stringer
}

// 實作一個簡易的 FileLogger
type FileLogger struct {
    file *os.File
}

// 實作 Writer
func (fl *FileLogger) Write(p []byte) (int, error) {
    return fl.file.Write(p)
}

// 實作 Stringer
func (fl *FileLogger) String() string {
    return fmt.Sprintf("FileLogger{path:%s}", fl.file.Name())
}

// 建立 Logger，並在需要時取得 Stringer 功能
func NewLogger(path string) (AdvancedLogger, error) {
    f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        return nil, err
    }
    return &FileLogger{file: f}, nil
}

func main() {
    logger, err := NewLogger("app.log")
    if err != nil {
        panic(err)
    }

    // 直接使用 Writer 功能
    fmt.Fprintln(logger, "程式啟動")

    // 透過型態斷言取得 Stringer，印出設定資訊
    if s, ok := logger.(fmt.Stringer); ok {
        fmt.Println("Logger 設定:", s.String())
    }
}

重點：AdvancedLogger 透過 介面組合 同時要求 io.Writer 與 fmt.Stringer，在使用端只要斷言 fmt.Stringer 就能安全取得額外資訊。

---

常見陷阱與最佳實踐

陷阱	說明	解決方案
斷言失敗導致 panic	使用 v.(T) 而未檢查 ok，在型別不匹配時直接崩潰。	永遠使用 v, ok := i.(T) 或 type switch，除非你確定型別一定正確。
介面組合忘記方法衝突	兩個嵌入介面宣告相同方法，但簽名不同，會在編譯時產生衝突。	在設計介面時保持 方法簽名唯一，或使用 別名（例如 ReadFrom、ReadInto）避免衝突。
空介面 (interface{}) 濫用	為了「方便」把所有資料放進 interface{}，結果失去型別安全，程式碼變得難以維護。	盡量使用具體介面，只在真的需要接受任意型別的情況下才使用 interface{}。
忘記 defer 關閉資源	在取得 ReadWriteCloser 後忘記呼叫 Close()，導致檔案、網路連線資源泄漏。	統一使用 defer rc.Close() 於取得資源的同一層級。
介面值與指標值混用	實作介面的方法使用指標接收者，但在宣告變數時使用值，會導致介面不符合預期。	根據方法集 判斷：若介面需要指標方法，宣告時務必使用 &Struct{}；若只需要值方法，直接使用 Struct{}。

最佳實踐

1. 小介面優先：先定義「單一職責」的微型介面（如 Reader、Writer），再透過組合形成大介面。
2. 明確文件化：在介面註解中說明每個方法的語意與使用限制，避免未來實作者產生歧義。
3. 型態斷言只在邊界層：盡量把斷言的邏輯封裝在「適配器」或「工廠」層，讓核心業務程式碼只操作介面。
4. 使用 type switch 處理多型：當需要根據底層型別做不同處理時，type switch 是最乾淨、可讀性最高的寫法。
5. 測試介面組合：寫測試時，使用 var _ Interface = (*Concrete)(nil) 來確保實作符合介面，避免因方法簽名變更而未被發現。

---

實際應用場景

場景	為何需要介面組合與型態轉換	範例說明
日誌框架	同時支援寫入檔案、輸出至 console、以及結構化 JSON。	透過 io.Writer、fmt.Stringer、自訂 JSONMarshaler 組合成 Logger，在執行期根據設定斷言取得 JSONMarshaler。
資料庫抽象層	不同資料庫驅動提供相同的 Query、Exec 方法，但有些支援交易（Tx）或批次寫入。	定義 Querier、Execer、Txer，組合成 DB；在需要交易時，用 if tx, ok := db.(Txer); ok { tx.Begin() }。
網路協定解析	同一個 Message 介面可能同時實作 io.Reader（讀取原始位元組）與 proto.Message（ProtoBuf 序列化）。	解析器接受 Message，根據實作的 proto.Message 斷言呼叫 proto.Marshal，若只需要原始位元組則直接使用 Read。
插件系統	主程式只知道 Plugin 介面，但插件可能同時提供 HealthChecker、MetricsCollector。	主程式使用 type switch 檢測插件是否實作額外介面，若有則自動註冊健康檢查或度量收集。

---

總結

• 介面組合 讓我們能以「小介面」拼湊出「大介面」，避免巨型、難以維護的單一介面。
• 型態斷言 與 型態切換 為取得底層具體型別的安全機制，配合介面組合可在執行期彈性擴充功能。
• 避免常見的斷言 panic、方法衝突與資源泄漏，遵循「小介面優先」與「斷言只在邊界」的最佳實踐，能讓程式碼更健壯、可測。
• 在日誌、資料庫、網路協定、插件等實務情境中，介面組合與型態轉換已成為設計彈性、可擴充系統的關鍵技巧。

掌握了這兩項核心概念，你就能在 Go 專案中寫出 高內聚、低耦合 的程式碼，並在面對需求變更時快速調整而不必大幅重構。祝你在 Golang 的旅程中，玩得開心、寫得更好！