Go语言中实现泛型行为：接口与类型变量模拟

package main

import (
    "fmt"
    "reflect"
)

// MapFunc 定义了映射操作的函数类型
// 它接受一个interface{}类型的值，并返回一个interface{}类型的值
type MapFunc func(interface{}) interface{}

// Map 实现了对任意类型切片的映射操作
// 注意：此实现返回一个新的interface{}切片，需要后续的类型断言
func Map(inputSlice []interface{}, f MapFunc) []interface{} {
    result := make([]interface{}, len(inputSlice))
    for i, item := range inputSlice {
        result[i] = f(item)
    }
    return result
}

func main() {
    // 示例1: 整数切片映射
    intSlice := []interface{}{1, 2, 3, 4, 5}
    squareFunc := func(val interface{}) interface{} {
        return val.(int) * val.(int) // 需要类型断言
    }
    squaredInts := Map(intSlice, squareFunc)
    fmt.Println("原始整数切片:", intSlice)
    fmt.Println("平方后的整数切片:", squaredInts) // 输出: [1 4 9 16 25]

    // 示例2: 字符串切片映射
    stringSlice := []interface{}{"hello", "world"}
    upperFunc := func(val interface{}) interface{} {
        return fmt.Sprintf("%v!", val.(string)) // 需要类型断言
    }
    exclamatoryStrings := Map(stringSlice, upperFunc)
    fmt.Println("原始字符串切片:", stringSlice)
    fmt.Println("加感叹号的字符串切片:", exclamatoryStrings) // 输出: [hello! world!]

    // 示例3: 类型转换的映射
    floatSlice := []interface{}{1.1, 2.2, 3.3}
    toIntFunc := func(val interface{}) interface{} {
        return int(val.(float64)) // 浮点数转整数
    }
    intFromFloats := Map(floatSlice, toIntFunc)
    fmt.Println("原始浮点数切片:", floatSlice)
    fmt.Println("转换为整数的切片:", intFromFloats) // 输出: [1 2 3]

    // 如何将结果转换回特定类型切片 (重要!)
    // 假设我们知道 squaredInts 应该全是 int
    finalInts := make([]int, len(squaredInts))
    for i, v := range squaredInts {
        // 这里再次进行类型断言，并处理可能的错误
        if val, ok := v.(int); ok {
            finalInts[i] = val
        } else {
            fmt.Printf("警告: 元素 %v 不是 int 类型\n", v)
        }
    }
    fmt.Println("最终的int切片:", finalInts)
    fmt.Println("最终int切片的类型:", reflect.TypeOf(finalInts))
}

package main

import "fmt"

// Map 函数现在可以使用类型参数 T 和 U
// 它接受一个类型为 T 的切片，和一个将 T 映射到 U 的函数，并返回一个类型为 U 的切片
func Map[T any, U any](inputSlice []T, f func(T) U) []U {
    result := make([]U, len(inputSlice))
    for i, item := range inputSlice {
        result[i] = f(item)
    }
    return result
}

func main() {
    // 示例1: 整数切片映射
    intSlice := []int{1, 2, 3, 4, 5}
    squareFunc := func(val int) int {
        return val * val
    }
    squaredInts := Map(intSlice, squareFunc) // 编译器自动推断 T=int, U=int
    fmt.Println("平方后的整数切片:", squaredInts)

    // 示例2: 字符串切片映射
    stringSlice := []string{"hello", "world"}
    upperFunc := func(val string) string {
        return fmt.Sprintf("%s!", val)
    }
    exclamatoryStrings := Map(stringSlice, upperFunc) // 编译器自动推断 T=string, U=string
    fmt.Println("加感叹号的字符串切片:", exclamatoryStrings)

    // 示例3: 浮点数转整数的映射
    floatSlice := []float64{1.1, 2.2, 3.3}
    toIntFunc := func(val float64) int {
        return int(val)
    }
    intFromFloats := Map(floatSlice, toIntFunc) // 编译器自动推断 T=float64, U=int
    fmt.Println("转换为整数的切片:", intFromFloats)
}