Go语言中模拟泛型：interface{} 与 reflect 包的实践指南

package main

import (
    "fmt"
)

// GetLastOfInterfaceSlice 获取 []interface{} 切片的最后一个元素
// 如果切片为空，返回 nil
func GetLastOfInterfaceSlice(s []interface{}) interface{} {
    if len(s) == 0 {
        return nil
    }
    return s[len(s)-1]
}

func main() {
    // 示例1: 使用 []interface{}
    myInts := []interface{}{1, 2, 3, 4, 5}
    lastInt := GetLastOfInterfaceSlice(myInts)
    if lastInt != nil {
        fmt.Printf("[]interface{} 切片的最后一个元素是: %v (类型: %T)\n", lastInt, lastInt)
        // 类型断言，将 interface{} 转换为具体类型
        if val, ok := lastInt.(int); ok {
            fmt.Printf("断言为 int 类型: %d\n", val)
        }
    }

    myStrings := []interface{}{"apple", "banana", "cherry"}
    lastString := GetLastOfInterfaceSlice(myStrings)
    if lastString != nil {
        fmt.Printf("[]interface{} 切片的最后一个元素是: %v (类型: %T)\n", lastString, lastString)
        if val, ok := lastString.(string); ok {
            fmt.Printf("断言为 string 类型: %s\n", val)
        }
    }
}

package main

import (
    "fmt"
    "reflect"
)

// GetLastElementOfAnySlice 使用反射获取任意类型切片的最后一个元素
// 参数必须是一个切片类型。如果不是切片或切片为空，返回 nil。
func GetLastElementOfAnySlice(slice interface{}) interface{} {
    // 将 interface{} 转换为 reflect.Value
    val := reflect.ValueOf(slice)

    // 检查传入的参数是否是切片类型
    if val.Kind() != reflect.Slice {
        fmt.Printf("错误: 参数不是切片类型，而是 %s\n", val.Kind())
        return nil
    }

    // 检查切片是否为空
    if val.Len() == 0 {
        return nil
    }

    // 获取切片的最后一个元素
    lastElement := val.Index(val.Len() - 1)

    // 将 reflect.Value 转换回 interface{}
    return lastElement.Interface()
}

func main() {
    // 示例2: 使用 reflect 处理任意切片类型
    intSlice := []int{10, 20, 30}
    lastIntReflect := GetLastElementOfAnySlice(intSlice)
    if lastIntReflect != nil {
        fmt.Printf("int 切片的最后一个元素是: %v (类型: %T)\n", lastIntReflect, lastIntReflect)
        if val, ok := lastIntReflect.(int); ok {
            fmt.Printf("断言为 int 类型: %d\n", val)
        }
    }

    stringSlice := []string{"alpha", "beta", "gamma"}
    lastStringReflect := GetLastElementOfAnySlice(stringSlice)
    if lastStringReflect != nil {
        fmt.Printf("string 切片的最后一个元素是: %v (类型: %T)\n", lastStringReflect, lastStringReflect)
        if val, ok := lastStringReflect.(string); ok {
            fmt.Printf("断言为 string 类型: %s\n", val)
        }
    }

    // 传入非切片类型
    nonSlice := 123
    lastNonSlice := GetLastElementOfAnySlice(nonSlice)
    if lastNonSlice == nil {
        fmt.Println("成功处理非切片输入")
    }

    emptySlice := []float64{}
    lastEmpty := GetLastElementOfAnySlice(emptySlice)
    if lastEmpty == nil {
        fmt.Println("成功处理空切片输入")
    }
}

package main

import "fmt"

// GetLastElement 获取任意类型切片的最后一个元素 (Go 1.18+ 泛型)
// T 是一个类型参数，表示切片元素的类型
func GetLastElement[T any](s []T) (T, bool) {
    if len(s) == 0 {
        var zero T // 返回该类型的零值
        return zero, false
    }
    return s[len(s)-1], true
}

func main() {
    intSlice := []int{1, 2, 3, 4, 5}
    lastInt, ok := GetLastElement(intSlice)
    if ok {
        fmt.Printf("泛型 int 切片的最后一个元素是: %v (类型: %T)\n", lastInt, lastInt)
    }

    stringSlice := []string{"A", "B", "C"}
    lastString, ok := GetLastElement(stringSlice)
    if ok {
        fmt.Printf("泛型 string 切片的最后一个元素是: %v (类型: %T)\n", lastString, lastString)
    }

    emptySlice := []float64{}
    _, ok = GetLastElement(emptySlice)
    if !ok {
        fmt.Println("泛型成功处理空切片")
    }
}