Go语言中接口作为函数参数的深入理解与实践

package main

import "fmt"

// 定义一个名为 'Shape' 的接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 定义一个结构体 'Circle'
type Circle struct {
    Radius float64
}

// Circle 类型实现 Shape 接口的 Area 方法
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

// Circle 类型实现 Shape 接口的 Perimeter 方法
func (c Circle) Perimeter() float64 {
    return 2 * 3.14 * c.Radius
}

// 定义一个函数，接受 'Shape' 接口作为参数
func Measure(s Shape) {
    fmt.Printf("Type: %T\n", s)
    fmt.Printf("Area: %.2f\n", s.Area())
    fmt.Printf("Perimeter: %.2f\n", s.Perimeter())
}

func main() {
    c := Circle{Radius: 5}
    Measure(c) // 将 Circle 类型的实例传递给接受 Shape 接口的函数
}

package main

import "fmt"

// 定义一个函数，接受空接口作为参数
func PrintAnything(val interface{}) {
    fmt.Printf("Received value: %v, Type: %T\n", val, val)
}

func main() {
    PrintAnything(100)           // 整数
    PrintAnything("Hello Go")    // 字符串
    PrintAnything(true)          // 布尔值
    PrintAnything([]int{1, 2, 3}) // 切片
}

func (rec *ContactRecord) Less(other interface{}) bool {
  return rec.sortKey.Less(other.(*ContactRecord).sortKey);
}

package main

import "fmt"

// 假设有一个 ContactRecord 结构体
type ContactRecord struct {
    Name    string
    sortKey int // 用于排序的键
}

// Less 方法，比较两个 ContactRecord 的 sortKey
func (rec *ContactRecord) Less(other interface{}) bool {
    // 使用类型断言将 other 转换为 *ContactRecord 类型
    // 这里假设 other 总是 *ContactRecord 类型，如果不是，会发生 panic
    otherContact := other.(*ContactRecord) 
    return rec.sortKey < otherContact.sortKey
}

func main() {
    record1 := &ContactRecord{Name: "Alice", sortKey: 10}
    record2 := &ContactRecord{Name: "Bob", sortKey: 20}
    record3 := &ContactRecord{Name: "Charlie", sortKey: 5}

    fmt.Printf("record1 less than record2: %t\n", record1.Less(record2)) // true
    fmt.Printf("record2 less than record3: %t\n", record2.Less(record3)) // false (20 < 5 是 false)
    fmt.Printf("record3 less than record1: %t\n", record3.Less(record1)) // true

    // 尝试传入非 *ContactRecord 类型，将导致 panic
    // var invalid interface{} = "hello"
    // fmt.Println(record1.Less(invalid)) 
}

package main

import "fmt"

// ContactRecord 结构体同上
type ContactRecord struct {
    Name    string
    sortKey int
}

func (rec *ContactRecord) SafeLess(other interface{}) (bool, error) {
    // 使用带 ok 的类型断言
    otherContact, ok := other.(*ContactRecord)
    if !ok {
        return false, fmt.Errorf("类型不匹配: 期望 *ContactRecord, 得到 %T", other)
    }
    return rec.sortKey < otherContact.sortKey, nil
}

func main() {
    record1 := &ContactRecord{Name: "Alice", sortKey: 10}
    record2 := &ContactRecord{Name: "Bob", sortKey: 20}

    // 有效的比较
    isLess, err := record1.SafeLess(record2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("record1 less than record2: %t\n", isLess)
    }

    // 传入不匹配的类型
    var invalidParam interface{} = "not a ContactRecord"
    isLess, err = record1.SafeLess(invalidParam)
    if err != nil {
        fmt.Println("Error:", err) // 输出: Error: 类型不匹配: 期望 *ContactRecord, 得到 string
    } else {
        fmt.Printf("record1 less than invalidParam: %t\n", isLess)
    }
}