深入理解Go语言函数参数中的接口与类型断言

type Sorter interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

func SortData(data Sorter) {
    // 可以在这里调用 data.Len(), data.Less(), data.Swap() 等方法
    // 例如：
    // for i := 0; i < data.Len()-1; i++ {
    //     for j := i + 1; j < data.Len(); j++ {
    //         if data.Less(j, i) {
    //             data.Swap(i, j)
    //         }
    //     }
    // }
}

func ProcessAnything(value interface{}) {
    // 在这里，value 可以是任何类型
    // 但你不能直接调用 value 的方法，因为 interface{} 没有定义任何方法
    fmt.Printf("Received a value of type: %T, value: %v\n", value, value)
}

value, ok := interfaceValue.(ConcreteType)

package main

import "fmt"

type ContactRecord struct {
    sortKey string
    // 其他字段...
}

// 模拟原始问题中的 Less 方法
// 这个方法接收一个 interface{} 参数，并期望它是一个 *ContactRecord
func (rec *ContactRecord) Less(other interface{}) bool {
    // 使用类型断言将 other 转换为 *ContactRecord
    // 注意：这里假设 other 总是 *ContactRecord，如果不是会 panic
    // 在实际应用中，通常会使用带 ok 的断言进行安全检查
    otherRecord := other.(*ContactRecord)
    return rec.sortKey < otherRecord.sortKey // 简单比较
}

func main() {
    var myInterface interface{}

    // 存储一个字符串
    myInterface = "Hello, Go!"
    if s, ok := myInterface.(string); ok {
        fmt.Printf("断言成功：这是一个字符串，值：%s\n", s)
    } else {
        fmt.Println("断言失败：这不是一个字符串")
    }

    // 存储一个整数
    myInterface = 123
    if i, ok := myInterface.(int); ok {
        fmt.Printf("断言成功：这是一个整数，值：%d\n", i)
    } else {
        fmt.Println("断言失败：这不是一个整数")
    }

    // 尝试断言为错误的类型
    if b, ok := myInterface.(bool); ok {
        fmt.Printf("断言成功：这是一个布尔值，值：%t\n", b)
    } else {
        fmt.Println("断言失败：这不是一个布尔值")
    }

    // 原始问题中的 Less 方法应用
    record1 := &ContactRecord{sortKey: "Alice"}
    record2 := &ContactRecord{sortKey: "Bob"}

    // 调用 Less 方法，传入 interface{} 参数
    // 内部会进行类型断言
    if record1.Less(record2) {
        fmt.Printf("%s 在 %s 之前\n", record1.sortKey, record2.sortKey)
    } else {
        fmt.Printf("%s 在 %s 之后\n", record1.sortKey, record2.sortKey)
    }

    // 演示不安全的类型断言 (会 panic)
    // var someInt interface{} = 10
    // s := someInt.(string) // 运行时 panic: interface conversion: interface {} is int, not string
    // fmt.Println(s)
}