Go语言中泛型切片安全索引的实现：从反射到类型参数

func tryIndexString(arr []string, index int, def string) string {
    if index >= 0 && index < len(arr) { // 确保索引在有效范围内
        return arr[index]
    }
    return def
}

// 示例用法
func main() {
    s := []string{"apple", "banana", "cherry"}
    fmt.Println(tryIndexString(s, 1, "default")) // 输出: banana
    fmt.Println(tryIndexString(s, 5, "default")) // 输出: default
}

// 这种尝试在Go语言中是错误的
/*
func (i []interface{}) TryIndex(index int, def interface{}) interface{} {
    if index >= 0 && index < len(i) {
        return i[index]
    }
    return def
}
*/

package main

import "fmt"

// TryIndex 是一个泛型函数，用于安全地访问切片元素。
// T 是一个类型参数，表示切片中元素的类型。
// any 是 Go 1.18 引入的预声明接口类型，等同于 interface{}，表示任何类型。
func TryIndex[T any](arr []T, index int, def T) T {
    if index >= 0 && index < len(arr) {
        return arr[index]
    }
    return def
}

func main() {
    // 示例 1: []string 类型
    aArr := []string{"al", "ba", "ca"}
    fmt.Printf("aArr[1]: %s\n", TryIndex(aArr, 1, "00"))  // 输出: ba
    fmt.Printf("aArr[5]: %s\n", TryIndex(aArr, 5, "00"))  // 输出: 00

    // 示例 2: []int 类型
    bArr := []int{10, 20, 30}
    fmt.Printf("bArr[0]: %d\n", TryIndex(bArr, 0, 99))    // 输出: 10
    fmt.Printf("bArr[3]: %d\n", TryIndex(bArr, 3, 99))    // 输出: 99

    // 示例 3: 自定义结构体类型
    type Person struct {
        Name string
        Age  int
    }
    people := []Person{{"Alice", 30}, {"Bob", 25}}
    defaultPerson := Person{"Unknown", 0}
    fmt.Printf("people[0]: %+v\n", TryIndex(people, 0, defaultPerson)) // 输出: {Name:Alice Age:30}
    fmt.Printf("people[2]: %+v\n", TryIndex(people, 2, defaultPerson)) // 输出: {Name:Unknown Age:0}
}

package main

import (
    "fmt"
    "reflect"
)

// TryIndexReflect 使用反射机制实现通用切片安全索引。
// 它接受一个 interface{} 类型的切片，并返回一个 interface{} 类型的元素。
func TryIndexReflect(slice interface{}, index int, def interface{}) interface{} {
    v := reflect.ValueOf(slice)

    // 检查传入的参数是否是切片类型
    if v.Kind() != reflect.Slice {
        panic("TryIndexReflect: slice参数必须是切片类型")
    }

    // 检查索引是否在有效范围内
    if index >= 0 && index < v.Len() {
        return v.Index(index).Interface() // 返回切片元素，类型为 interface{}
    }

    return def // 返回默认值
}

func main() {
    // 示例 1: []string 类型
    aArr := []string{"al", "ba", "ca"}
    fmt.Printf("aArr[1]: %s\n", TryIndexReflect(aArr, 1, "00").(string)) // 需要类型断言
    fmt.Printf("aArr[5]: %s\n", TryIndexReflect(aArr, 5, "00").(string)) // 需要类型断言

    // 示例 2: []int 类型
    bArr := []int{10, 20, 30}
    fmt.Printf("bArr[0]: %d\n", TryIndexReflect(bArr, 0, 99).(int))    // 需要类型断言
    fmt.Printf("bArr[3]: %d\n", TryIndexReflect(bArr, 3, 99).(int))    // 需要类型断言

    // 注意事项：如果默认值类型与切片元素类型不匹配，会导致运行时panic
    // fmt.Printf("aArr[5]: %s\n", TryIndexReflect(aArr, 5, 123).(string)) // 运行时panic
}