Go语言中泛型编程的实现策略：interface{}与反射的应用

package main

import "fmt"

// PrintAnything 接受一个 interface{} 类型参数并打印其值和类型
func PrintAnything(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)

    // 可以尝试进行类型断言，根据具体类型执行不同操作
    if s, ok := v.(string); ok {
        fmt.Printf("  (It's a string: %s)\n", s)
    } else if i, ok := v.(int); ok {
        fmt.Printf("  (It's an int: %d)\n", i)
    }
}

func main() {
    PrintAnything(123)
    PrintAnything("hello Go")
    PrintAnything(3.14)
    PrintAnything(true)

    type MyStruct struct {
        Name string
    }
    PrintAnything(MyStruct{Name: "Alice"})
}

package main

import "fmt"

// ProcessGenericSlice 接受一个 []interface{} 切片并处理其元素
func ProcessGenericSlice(elements []interface{}) {
    fmt.Println("Processing []interface{} slice:")
    for i, v := range elements {
        fmt.Printf("  Element %d: %v (Original Type: %T)\n", i, v, v)
        // 再次强调，需要类型断言来操作具体类型
        if s, ok := v.(string); ok {
            fmt.Printf("    (Asserted as string: %s, length: %d)\n", s, len(s))
        } else if i, ok := v.(int); ok {
            fmt.Printf("    (Asserted as int: %d, multiplied by 2: %d)\n", i, i*2)
        }
    }
    fmt.Println()
}

func main() {
    // 创建一个包含不同类型元素的 []interface{} 切片
    mixedSlice := []interface{}{10, "hello", 3.14, true, struct{ ID int }{ID: 1}}
    ProcessGenericSlice(mixedSlice)

    // 注意：[]int 和 []interface{} 是不同的类型，不能直接赋值。
    // 如果你有一个 []int 类型的切片，并想将其作为 []interface{} 传递，你需要手动转换：
    intSlice := []int{1, 2, 3}
    genericIntSlice := make([]interface{}, len(intSlice))
    for i, v := range intSlice {
        genericIntSlice[i] = v
    }
    fmt.Println("Processing converted []int to []interface{} slice:")
    ProcessGenericSlice(genericIntSlice)
}

package main

import (
    "fmt"
    "reflect"
)

// GetLastElement 获取任意类型切片的最后一个元素。
// 参数v必须是一个切片（slice）类型。
// 如果v不是切片或切片为空，则返回nil。
func GetLastElement(v interface{}) interface{} {
    val := reflect.ValueOf(v) // 获取v的反射值

    // 1. 检查v是否为切片类型
    if val.Kind() != reflect.Slice {
        fmt.Printf("Error: Input is not a slice, but a %s\n", val.Kind())
        return nil
    }

    // 2. 检查切片是否为空
    if val.Len() == 0 {
        fmt.Println("Error: Slice is empty.")
        return nil
    }

    // 3. 获取最后一个元素并返回其接口值
    // val.Len() - 1 得到最后一个元素的索引
    // val.Index(idx) 获取该索引处的反射值
    // .Interface() 将反射值转换回 interface{} 类型
    return val.Index(val.Len() - 1).Interface()
}

func main() {
    // 示例1: int切片
    intSlice := []int{10, 20, 30, 40, 50}
    lastInt := GetLastElement(intSlice)
    if lastInt != nil {
        fmt.Printf("Last element of intSlice: %v (Type: %T)\n", lastInt, lastInt)
    }

    // 示例2: string切片
    stringSlice := []string{"apple", "banana", "cherry"}
    lastString := GetLastElement(stringSlice)
    if lastString != nil {
        fmt.Printf("Last element of stringSlice: %v (Type: %T)\n", lastString, lastString)
    }

    // 示例3: 浮点数切片
    floatSlice := []float64{1.1, 2.2, 3.3}
    lastFloat := GetLastElement(floatSlice)
    if lastFloat != nil {
        fmt.Printf("Last element of floatSlice: %v (Type: %T)\n", lastFloat, lastFloat)
    }

    // 示例4: 空切片
    emptySlice := []bool{}
    lastEmpty := GetLastElement(emptySlice)
    if lastEmpty == nil {
        fmt.Println("Handled empty slice correctly.")
    }

    // 示例5: 非切片类型
    notASlice := "hello world"
    lastNotASlice := GetLastElement(notASlice)
    if lastNotASlice == nil {
        fmt.Println("Handled non-slice input correctly.")
    }
}