如何用Golang通过反射操作结构体切片_Golang 结构体切片操作实践

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
    Age  int
    // 注意：私有字段无法通过反射设置
    id string
}

func processUserSlice(data interface{}) {
    val := reflect.ValueOf(data)

    // 如果传入的是切片指针，我们需要先解引用
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    if val.Kind() != reflect.Slice {
        fmt.Println("Error: Not a slice")
        return
    }

    fmt.Printf("切片类型: %s, 元素数量: %d\n", val.Type(), val.Len())

    for i := 0; i < val.Len(); i++ {
        elem := val.Index(i) // 获取切片中的第i个元素

        // 如果切片元素是结构体指针，需要解引用才能访问其字段
        if elem.Kind() == reflect.Ptr {
            elem = elem.Elem()
        }

        if elem.Kind() != reflect.Struct {
            fmt.Printf("元素 %d 不是结构体，跳过\n", i)
            continue
        }

        // 读取字段
        nameField := elem.FieldByName("Name")
        if nameField.IsValid() && nameField.Kind() == reflect.String {
            fmt.Printf("用户 %d 名字: %s\n", i, nameField.String())
        }

        // 尝试修改Age字段
        ageField := elem.FieldByName("Age")
        if ageField.IsValid() && ageField.CanSet() && ageField.Kind() == reflect.Int {
            fmt.Printf("修改用户 %d 的年龄从 %d 到 %d\n", i, ageField.Int(), ageField.Int()+5)
            ageField.SetInt(ageField.Int() + 5)
        } else {
            // 这里很关键，如果CanSet()为false，通常是因为字段未导出或elem本身不可设置
            fmt.Printf("无法修改用户 %d 的年龄字段 (CanSet: %t)\n", i, ageField.CanSet())
        }
    }
}

func main() {
    users := []User{
        {Name: "Alice", Age: 30},
        {Name: "Bob", Age: 25},
    }

    fmt.Println("--- 原始数据 ---")
    fmt.Printf("%+v\n", users)

    fmt.Println("\n--- 通过反射处理 ---")
    // 注意：这里传递的是切片的指针，以便在processUserSlice内部可以修改切片元素
    processUserSlice(&users)

    fmt.Println("\n--- 处理后数据 ---")
    fmt.Printf("%+v\n", users)

    // 尝试处理一个包含结构体指针的切片
    ptrUsers := []*User{
        {Name: "Charlie", Age: 40},
        {Name: "David", Age: 35},
    }
    fmt.Println("\n--- 原始指针切片数据 ---")
    fmt.Printf("%+v\n", ptrUsers)

    fmt.Println("\n--- 通过反射处理指针切片 ---")
    processUserSlice(&ptrUsers) // 同样传递指针的指针
    fmt.Println("\n--- 处理后指针切片数据 ---")
    // 遍历打印，因为指针切片的值被修改了
    for _, u := range ptrUsers {
        fmt.Printf("%+v\n", u)
    }
}

// 假设这是我们之前定义的User结构体
// type User struct {
//  Name string
//  Age  int
// }

func modifyUserSliceFields(slicePtr interface{}, fieldName string, newValue interface{}) {
    val := reflect.ValueOf(slicePtr)
    if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Slice {
        fmt.Println("Error: Expected a pointer to a slice.")
        return
    }

    sliceVal := val.Elem() // 获取切片本身的可设置Value

    for i := 0; i < sliceVal.Len(); i++ {
        elem := sliceVal.Index(i)
        // 再次检查并解引用，确保我们拿到的是可设置的结构体Value
        if elem.Kind() == reflect.Ptr {
            elem = elem.Elem()
        }

        if elem.Kind() != reflect.Struct {
            fmt.Printf("Element %d is not a struct, skipping.\n", i)
            continue
        }

        field := elem.FieldByName(fieldName)
        if !field.IsValid() {
            fmt.Printf("Field '%s' not found in element %d.\n", fieldName, i)
            continue
        }

        if !field.CanSet() {
            fmt.Printf("Field '%s' in element %d is not settable (e.g., unexported or not addressable).\n", fieldName, i)
            continue
        }

        // 根据新值的类型进行设置
        newValReflect := reflect.ValueOf(newValue)
        if field.Type() != newValReflect.Type() {
            fmt.Printf("Type mismatch for field '%s' in element %d: expected %s, got %s.\n",
                fieldName, i, field.Type(), newValReflect.Type())
            continue
        }

        field.Set(newValReflect) // 使用通用的Set方法
        fmt.Printf("Successfully updated field '%s' in element %d.\n", fieldName, i)
    }
}

// 示例调用
// func main() {
//  users := []User{
//      {Name: "Alice", Age: 30},
//      {Name: "Bob", Age: 25},
//  }
//  fmt.Println("Before modification:", users)
//  modifyUserSliceFields(&users, "Age", 35) // 将所有Age字段改为35
//  fmt.Println("After modification:", users)
// }

func appendToSlice(slicePtr interface{}, newElemVal reflect.Value) {
    val := reflect.ValueOf(slicePtr)
    if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Slice {
        fmt.Println("Error: Expected a pointer to a slice.")
        return
    }

    sliceVal := val.Elem() // 获取切片本身的可设置Value

    // 检查新元素的类型是否与切片元素类型匹配
    if newElemVal.Type() != sliceVal.Type().Elem() {
        fmt.Printf("Error: New element type %s does not match slice element type %s.\n",
            newElemVal.Type(), sliceVal.Type().Elem())
        return
    }

    newSliceVal := reflect.Append(sliceVal, newElemVal)
    sliceVal.Set(newSlice