Go 语言切片与接口类型转换：深入理解原理与实现策略

package main

import "fmt"

// Statement 接口定义了一个 Say() 方法
type Statement interface {
    Say() string
}

// Quote 结构体实现了 Statement 接口
type Quote struct {
    quote string
}

func (q Quote) Say() string {
    return q.quote
}

// Replay 函数接受一个 Statement 接口切片
func Replay(conversation []Statement) {
    for _, statement := range conversation {
        fmt.Println(statement.Say())
    }
}

func main() {
    quotes := []Quote{
        {"Nice Guy Eddie: C'mon, throw in a buck!"},
        {"Mr. Pink: Uh-uh, I don't tip."},
    }

    // 尝试直接调用 Replay 函数，这将导致编译错误
    // Replay(quotes) // 编译错误: cannot use quotes (type []Quote) as type []Statement in argument to Replay
}

package main

import "fmt"

// Statement 接口和 Quote 结构体定义同上
type Statement interface {
    Say() string
}

type Quote struct {
    quote string
}

func (q Quote) Say() string {
    return q.quote
}

func Replay(conversation []Statement) {
    for _, statement := range conversation {
        fmt.Println(statement.Say())
    }
}

func main() {
    quotes := []Quote{
        {"Nice Guy Eddie: C'mon, throw in a buck!"},
        {"Mr. Pink: Uh-uh, I don't tip."},
        {"Nice Guy Eddie: You don't believe in tipping?"},
    }

    // 显式创建 []Statement 切片并进行逐元素转换
    statements := make([]Statement, len(quotes))
    for i, quote := range quotes {
        statements[i] = quote // 在这里，Go 将 Quote 隐式转换为 Statement 接口
    }

    // 现在可以成功调用 Replay 函数
    Replay(statements)
}

package main

import (
    "fmt"
    "reflect"
)

// Statement 接口和 Quote 结构体定义同上
type Statement interface {
    Say() string
}

type Quote struct {
    quote string
}

func (q Quote) Say() string {
    return q.quote
}

// ConvertToStatements 是一个通用函数，将任意实现 Statement 接口的切片转换为 []Statement
func ConvertToStatements(its interface{}) ([]Statement, error) {
    itsValue := reflect.ValueOf(its) // 获取输入参数的反射值
    itsKind := itsValue.Kind()       // 获取其类型种类

    // 检查输入是否为数组或切片
    if itsKind != reflect.Array && itsKind != reflect.Slice {
        return nil, fmt.Errorf("期望输入为数组或切片类型，实际为 %s", itsKind)
    }

    itsLength := itsValue.Len()
    statements := make([]Statement, itsLength) // 创建目标 []Statement 切片

    // 遍历输入切片的每个元素
    for i := 0; i < itsLength; i++ {
        itsItem := itsValue.Index(i) // 获取当前元素的反射值
        // 将反射值转换为其底层接口类型，然后进行类型断言
        if item, ok := itsItem.Interface().(Statement); ok {
            statements[i] = item // 赋值给目标切片
        } else {
            return nil, fmt.Errorf("元素 #%d (%v) 未实现 Statement 接口", i, itsItem.Type())
        }
    }
    return statements, nil
}

// ReplayGeneric 函数现在可以接受任何实现了 Statement 接口的切片或数组
func ReplayGeneric(its interface{}) {
    conversation, err := ConvertToStatements(its)
    if err != nil {
        fmt.Printf("转换失败: %v\n", err)
        return
    }
    for _, statement := range conversation {
        fmt.Println(statement.Say())
    }
}

func main() {
    quotes := []Quote{
        {"Nice Guy Eddie: C'mon, throw in a buck!"},
        {"Mr. Pink: Uh-uh, I don't tip."},
    }

    // 现在可以直接传递 []Quote 给 ReplayGeneric
    ReplayGeneric(quotes)

    fmt.Println("\n--- 另一个实现了 Statement 接口的类型 ---")

    type Question struct {
        text string
    }
    func (q Question) Say() string {
        return "Q: " + q.text
    }

    questions := []Question{
        {"What's your name?"},
        {"How old are you?"},
    }

    // ReplayGeneric 同样可以处理 []Question
    ReplayGeneric(questions)
}