type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string { return "Woof!" }

type Robot struct{}

func (r Robot) Speak() string { return "Beep boop" }

// 無(wú)需顯式聲明實(shí)現(xiàn)
func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    MakeSound(Dog{})    // 輸出: Woof!
    MakeSound(Robot{})  // 輸出: Beep boop
}

type iface struct {
    tab  *itab      // 類(lèi)型和方法表指針
    data unsafe.Pointer // 實(shí)際數(shù)據(jù)指針
}

type itab struct {
    inter *interfacetype // 接口類(lèi)型信息
    _type *_type         // 具體類(lèi)型信息
    hash  uint32         // 類(lèi)型哈希值
    _     [4]byte
    fun   [1]uintptr     // 方法地址數(shù)組
}

type eface struct {
    _type *_type         // 類(lèi)型信息
    data  unsafe.Pointer // 數(shù)據(jù)指針
}

func BenchmarkValue(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 直接使用結(jié)構(gòu)體
        v := MyStruct{ID: i}
        _ = v
    }
}

func BenchmarkInterface(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 通過(guò)接口包裝
        var iface interface{} = MyStruct{ID: i}
        _ = iface
    }
}

type Worker interface {
    Work()
}

type ConcreteWorker struct{}

func (w ConcreteWorker) Work() {}

func DirectCall(w ConcreteWorker) {
    w.Work()
}

func InterfaceCall(w Worker) {
    w.Work()
}

; 直接調(diào)用
MOVQ    "".w+8(SP), AX
CALL    "".ConcreteWorker.Work(SB)  ; 靜態(tài)地址調(diào)用

; 接口調(diào)用
MOVQ    16(SP), AX          ; 獲取itab
MOVQ    24(AX), AX          ; 獲取方法地址
CALL    AX                  ; 動(dòng)態(tài)調(diào)用

func TypeAssert(v interface{}) {
    if s, ok := v.(string); ok {
        _ = s
    }
}

func DirectUse(s string) {
    _ = s
}

BenchmarkDirectUse-8     0.3 ns/op
BenchmarkTypeAssert-8    5.1 ns/op

// 錯(cuò)誤示范：interface{}黑洞
func parseJSON(data []byte) {
    var result map[string]interface{}
    json.Unmarshal(data, &result) // 遞歸interface{}地獄
    
    // 類(lèi)型斷言層層嵌套
    if user, ok := result["user"].(map[string]interface{}); ok {
        if name, ok := user["name"].(string); ok {
            fmt.Println(name)
        }
    }
}

// 正確做法：定義具體結(jié)構(gòu)
type User struct {
    Name string `json:"name"`
}

type Response struct {
    User User `json:"user"`
}

func parseJSONRight(data []byte) {
    var resp Response
    json.Unmarshal(data, &resp) // 無(wú)類(lèi)型斷言
    fmt.Println(resp.User.Name)
}

// 錯(cuò)誤：通用容器
type Container struct {
    items []interface{}
}

// 每次添加都引發(fā)堆分配
func (c *Container) Add(item interface{}) {
    c.items = append(c.items, item)
}

// 正確：泛型容器（Go 1.18+）
type Container[T any] struct {
    items []T
}

// 無(wú)額外分配
func (c *Container[T]) Add(item T) {
    c.items = append(c.items, item)
}

// 存儲(chǔ)1000個(gè)int
Interface container: 16,000 B/op  1000 allocs/op
Generic container:       0 B/op     0 allocs/op

// 反模式
func Process(val interface{}) {
    // 類(lèi)型斷言地獄...
}

// 改進(jìn)方案
type Processor interface {
    Process()
}

// 具體類(lèi)型實(shí)現(xiàn)Processor
type MyType struct{}
func (m MyType) Process() {}

func ProcessRight(p Processor) {
    p.Process() // 靜態(tài)派發(fā)
}

// 臃腫接口
type Monster interface {
    Walk()
    Run()
    Attack()
    Defend()
    Heal()
}

// 拆分為小接口
type Mover interface { Walk(); Run() }
type Fighter interface { Attack(); Defend() }
type Healer interface { Heal() }

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

// 組合接口
type ReadWriter interface {
    Reader
    Writer
}

// 實(shí)現(xiàn)時(shí)只需嵌入
type File struct{}

func (f File) Read(p []byte) (int, error)  { /* ... */ }
func (f File) Write(p []byte) (int, error) { /* ... */ }

// 通過(guò)指針避免值復(fù)制
type BigStruct struct { data [1024]byte }

type Processor interface {
    Process()
}

// 實(shí)現(xiàn)接口用指針接收者
func (b *BigStruct) Process() {}

func main() {
    var p Processor = &BigStruct{} // 只復(fù)制指針
}

type PaymentMethod interface {
    Pay(amount float64) error
}

// 多種支付方式實(shí)現(xiàn)
type CreditCard struct{ /* ... */ }
type PayPal struct{ /* ... */ }

// 數(shù)據(jù)庫(kù)存儲(chǔ)抽象
type UserStore interface {
    GetUser(id int) (*User, error)
}

func NewUserService(store UserStore) *UserService {
    return &UserService{store: store}
}

// 外部包的類(lèi)型
type ThirdPartyLogger struct{ /* ... */ }

// 實(shí)現(xiàn)我們的接口
func (l *ThirdPartyLogger) Log(msg string) {
    // 適配邏輯
}

// 高頻調(diào)用的函數(shù)
func processBatch(data []ConcreteType) { // 具體類(lèi)型
    for i := range data {
        // 直接操作，避免接口開(kāi)銷(xiāo)
    }
}

// 包內(nèi)部使用具體類(lèi)型
type internalProcessor struct {
    // 直接包含依賴(lài)項(xiàng)
    db *sql.DB
    cache *lru.Cache
}

// 使用泛型替代interface{}
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// 直接調(diào)用可內(nèi)聯(lián)
func add(a, b int) int { return a + b }

// 接口調(diào)用無(wú)法內(nèi)聯(lián)
var adder interface{} = add
adder.(func(int, int) int)(1, 2)

// 測(cè)試函數(shù)
func BenchmarkDirect(b *testing.B) {
    s := MyStruct{ID: 42}
    for i := 0; i < b.N; i++ {
        s.Process()
    }
}

func BenchmarkInterface(b *testing.B) {
    var iface Processor = MyStruct{ID: 42}
    for i := 0; i < b.N; i++ {
        iface.Process()
    }
}

// 好的小接口
type Stringer interface { String() string }

// 代替 interface{}
func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Println(v)
    }
}