Golang如何使用reflect操作切片元素_Golang reflect切片操作实践

package main

import (
    "fmt"
    "reflect"
)

func main() {
    mySlice := []int{1, 2, 3}
    // 如果需要修改原始切片（如append操作），需要传入指针
    slicePtrValue := reflect.ValueOf(&mySlice)
    sliceValue := slicePtrValue.Elem() // 获取切片本身的Value

    fmt.Printf("原始切片: %v, 类型: %v, 长度: %d, 容量: %d\n", mySlice, sliceValue.Type(), sliceValue.Len(), sliceValue.Cap())

    // 2. 访问切片元素
    if sliceValue.Kind() == reflect.Slice {
        for i := 0; i < sliceValue.Len(); i++ {
            elem := sliceValue.Index(i)
            fmt.Printf("索引 %d 的元素: %v (类型: %v)\n", i, elem.Interface(), elem.Type())
        }
    }

    // 3. 修改切片元素
    // 注意：要修改元素，该元素的reflect.Value必须是可设置的（CanSet()返回true）。
    // 通过sliceValue.Index(i)获取的元素通常是可设置的，因为它是从一个可寻址的Value中获取的。
    if sliceValue.Index(0).CanSet() {
        newVal := reflect.ValueOf(100)
        if newVal.Type().AssignableTo(sliceValue.Index(0).Type()) { // 检查类型是否兼容
            sliceValue.Index(0).Set(newVal)
            fmt.Printf("修改后切片: %v\n", mySlice) // mySlice现在是[100 2 3]
        }
    } else {
        fmt.Println("元素不可设置")
    }

    // 4. 向切片追加元素
    // reflect.Append会返回一个新的reflect.Value，代表新的切片。
    // 如果要让原始变量反映这个变化，需要将这个新的Value设置回去。
    newElement := reflect.ValueOf(4)
    newSliceValue := reflect.Append(sliceValue, newElement)
    // 将新的切片Value设置回原始切片变量
    if slicePtrValue.Elem().CanSet() { // 确保原始切片变量是可设置的
        slicePtrValue.Elem().Set(newSliceValue)
        fmt.Printf("追加元素后切片: %v\n", mySlice) // mySlice现在是[100 2 3 4]
    } else {
        fmt.Println("原始切片变量不可设置，追加操作无法反映到原变量")
    }

    // 5. 追加另一个切片
    anotherSlice := []int{5, 6}
    anotherSliceValue := reflect.ValueOf(anotherSlice)
    combinedSliceValue := reflect.AppendSlice(slicePtrValue.Elem(), anotherSliceValue)
    if slicePtrValue.Elem().CanSet() {
        slicePtrValue.Elem().Set(combinedSliceValue)
        fmt.Printf("追加另一个切片后: %v\n", mySlice) // mySlice现在是[100 2 3 4 5 6]
    }
}

package main

import (
    "fmt"
    "reflect"
)

// AppendUnique 尝试向一个切片中追加一个元素，如果元素已存在则不追加。
// slicePtr 必须是一个指向切片的指针。
// elem 是要追加的元素。
// 返回一个bool，表示是否成功追加。
func AppendUnique(slicePtr interface{}, elem interface{}) (bool, error) {
    slicePtrValue := reflect.ValueOf(slicePtr)
    if slicePtrValue.Kind() != reflect.Ptr || slicePtrValue.Elem().Kind() != reflect.Slice {
        return false, fmt.Errorf("slicePtr must be a pointer to a slice, got %v", slicePtrValue.Type())
    }

    sliceValue := slicePtrValue.Elem()
    elemValue := reflect.ValueOf(elem)

    // 检查元素类型是否与切片元素类型兼容
    if !elemValue.Type().AssignableTo(sliceValue.Type().Elem()) {
        return false, fmt.Errorf("element type %v is not assignable to slice element type %v", elemValue.Type(), sliceValue.Type().Elem())
    }

    // 检查是否已存在
    for i := 0; i < sliceValue.Len(); i++ {
        if reflect.DeepEqual(sliceValue.Index(i).Interface(), elem) {
            return false, nil // 元素已存在，不追加
        }
    }

    // 追加元素
    newSliceValue := reflect.Append(sliceValue, elemValue)
    slicePtrValue.Elem().Set(newSliceValue) // 将新切片设置回原始变量
    return true, nil
}

func main() {
    myInts := []int{1, 2, 3}
    added, err := AppendUnique(&myInts, 4)
    fmt.Printf("追加 4: %v, myInts: %v, err: %v\n", added, myInts, err) // true, [1 2 3 4]

    added, err = AppendUnique(&myInts, 2)
    fmt.Printf("追加 2: %v, myInts: %v, err: %v\n", added, myInts, err) // false, [1 2 3 4]

    myStrings := []string{"a", "b"}
    added, err = AppendUnique(&myStrings, "c")
    fmt.Printf("追加 c: %v, myStrings: %v, err: %v\n", added, myStrings, err) // true, [a b c]

    // 错误示例：类型不匹配
    _, err = AppendUnique(&myInts, "hello")
    fmt.Printf("追加 \"hello\" (错误): %v\n", err) // element type string is not assignable to slice element type int
}