Go语言反射：正确处理动态类型切片的通用函数设计

func maxer(s interface{}) interface{} {
    v := reflect.ValueOf(s)
    t := v.Type() // t 是一个 reflect.Type 变量

    maxval := s.(t)[0] // 错误发生在这里：t 不是一个编译时类型
    // ...
    return maxval
}

package main

import (
    "fmt"
    "reflect"
)

// maxerReflect 查找任意数字类型切片中的最大值
func maxerReflect(s interface{}) (interface{}, error) {
    v := reflect.ValueOf(s)

    // 1. 检查输入是否为切片
    if v.Kind() != reflect.Slice {
        return nil, fmt.Errorf("输入不是切片类型，实际类型为: %v", v.Kind())
    }
    if v.Len() == 0 {
        return nil, fmt.Errorf("切片为空")
    }

    // 2. 获取第一个元素作为初始最大值
    maxVal := v.Index(0)
    maxKind := maxVal.Kind()

    // 3. 遍历切片并比较元素
    for i := 1; i < v.Len(); i++ {
        currentVal := v.Index(i)

        // 确保所有元素类型一致，或至少是可比较的数字类型
        if currentVal.Kind() != maxKind {
            return nil, fmt.Errorf("切片中存在不同类型的元素: %v 和 %v", maxKind, currentVal.Kind())
        }

        // 根据底层类型进行比较
        switch maxKind {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            if currentVal.Int() > maxVal.Int() {
                maxVal = currentVal
            }
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
            if currentVal.Uint() > maxVal.Uint() {
                maxVal = currentVal
            }
        case reflect.Float32, reflect.Float64:
            if currentVal.Float() > maxVal.Float() {
                maxVal = currentVal
            }
        // 如果需要支持其他可比较类型（如string），则需在此处添加逻辑
        // case reflect.String:
        //     if currentVal.String() > maxVal.String() {
        //         maxVal = currentVal
        //     }
        default:
            return nil, fmt.Errorf("不支持的切片元素类型进行比较: %v", maxKind)
        }
    }

    return maxVal.Interface(), nil // 返回最大值的实际接口类型
}

func main() {
    // 测试 []int
    if res, err := maxerReflect([]int{1, 2, 3, 4}); err == nil {
        fmt.Printf("[]int 的最大值: %v (类型: %T)\n", res, res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试 []float32
    if res, err := maxerReflect([]float32{1.1, 2.1, 3.14, 0.1, 2.4}); err == nil {
        fmt.Printf("[]float32 的最大值: %v (类型: %T)\n", res, res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试 []int64
    if res, err := maxerReflect([]int64{100, 200, 50, 300}); err == nil {
        fmt.Printf("[]int64 的最大值: %v (类型: %T)\n", res, res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试空切片
    if res, err := maxerReflect([]int{}); err == nil {
        fmt.Printf("空切片的最大值: %v\n", res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试不支持的类型
    if res, err := maxerReflect([]string{"apple", "banana"}); err == nil {
        fmt.Printf("[]string 的最大值: %v\n", res)
    } else {
        fmt.Println("错误:", err) // 预期输出错误
    }
}

package main

import "fmt"

// maxerTypeSwitch 查找已知类型切片中的最大值
func maxerTypeSwitch(s interface{}) (interface{}, error) {
    switch sl := s.(type) {
    case []int:
        if len(sl) == 0 {
            return nil, fmt.Errorf("[]int 切片为空")
        }
        maxVal := sl[0]
        for _, v := range sl[1:] {
            if v > maxVal {
                maxVal = v
            }
        }
        return maxVal, nil
    case []float32:
        if len(sl) == 0 {
            return nil, fmt.Errorf("[]float32 切片为空")
        }
        maxVal := sl[0]
        for _, v := range sl[1:] {
            if v > maxVal {
                maxVal = v
            }
        }
        return maxVal, nil
    // 如果需要支持其他类型，可以在此处添加更多 case
    // case []string:
    //     if len(sl) == 0 { return nil, fmt.Errorf("[]string 切片为空") }
    //     maxVal := sl[0]
    //     for _, v := range sl[1:] { if v > maxVal { maxVal = v } }
    //     return maxVal, nil
    default:
        return nil, fmt.Errorf("不支持的切片类型: %T", s)
    }
}

func main() {
    // 测试 []int
    if res, err := maxerTypeSwitch([]int{1, 2, 3, 4}); err == nil {
        fmt.Printf("[]int 的最大值: %v (类型: %T)\n", res, res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试 []float32
    if res, err := maxerTypeSwitch([]float32{1.1, 2.1, 3.14, 0.1, 2.4}); err == nil {
        fmt.Printf("[]float32 的最大值: %v (类型: %T)\n", res, res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试空切片
    if res, err := maxerTypeSwitch([]int{}); err == nil {
        fmt.Printf("空切片的最大值: %v\n", res)
    } else {
        fmt.Println("错误:", err)
    }

    // 测试不支持的类型
    if res, err := maxerTypeSwitch([]string{"apple", "banana"}); err == nil {
        fmt.Printf("[]string 的最大值: %v\n", res)
    } else {
        fmt.Println("错误:", err) // 预期输出错误
    }
}