Golang如何通过反射遍历切片元素_Golang 切片元素遍历实践

package main

import (
    "fmt"
    "reflect"
)

// ReflectAndIterateSlice 演示如何使用反射遍历切片
func ReflectAndIterateSlice(slice interface{}) {
    v := reflect.ValueOf(slice)

    // 检查传入的是否是切片，以及是否为nil
    if v.Kind() != reflect.Slice {
        fmt.Printf("错误：传入的不是一个切片，而是 %s\n", v.Kind())
        return
    }
    if v.IsNil() {
        fmt.Println("传入了一个nil切片，无需遍历。")
        return
    }

    fmt.Printf("开始遍历切片，类型为：%s，长度为：%d\n", v.Type(), v.Len())

    for i := 0; i < v.Len(); i++ {
        elem := v.Index(i)
        fmt.Printf("  索引 %d: 类型 %s, 值 %v\n", i, elem.Type(), elem.Interface())
        // 如果需要对元素进行进一步操作，例如修改，需要确保元素是可设置的
        // if elem.CanSet() {
        //    // 假设我们想把所有int类型的元素加1
        //    if elem.Kind() == reflect.Int {
        //        elem.SetInt(elem.Int() + 1)
        //    }
        // }
    }
}

func main() {
    myIntSlice := []int{10, 20, 30}
    ReflectAndIterateSlice(myIntSlice)

    myStringSlice := []string{"hello", "world", "golang"}
    ReflectAndIterateSlice(myStringSlice)

    var nilSlice []float64
    ReflectAndIterateSlice(nilSlice)

    emptySlice := []bool{}
    ReflectAndIterateSlice(emptySlice)

    // 尝试传入非切片类型
    ReflectAndIterateSlice(42)
}

// ...在ReflectAndIterateSlice函数内部，迭代循环中...
        elem := v.Index(i)
        fmt.Printf("  索引 %d: 类型 %s, 值 %v", i, elem.Type(), elem.Interface())

        switch elem.Kind() {
        case reflect.Int:
            fmt.Printf(" (这是一个整数，值：%d)\n", elem.Int())
        case reflect.String:
            fmt.Printf(" (这是一个字符串，值：%s)\n", elem.String())
        case reflect.Struct:
            fmt.Printf(" (这是一个结构体，字段数：%d)\n", elem.NumField())
            // 如果是结构体，还可以进一步遍历其字段
            for j := 0; j < elem.NumField(); j++ {
                field := elem.Field(j)
                fmt.Printf("    字段 %s: 类型 %s, 值 %v\n", elem.Type().Field(j).Name, field.Type(), field.Interface())
            }
        default:
            fmt.Printf("\n")
        }
// ...

// 假设有一个递归函数来处理任意切片或可遍历的元素
func deepReflectAndIterate(val reflect.Value, indent string) {
    if val.Kind() == reflect.Ptr {
        val = val.Elem() // 如果是指针，获取其指向的值
    }

    if val.Kind() == reflect.Slice {
        if val.IsNil() {
            fmt.Printf("%s[nil slice]\n", indent)
            return
        }
        if val.Len() == 0 {
            fmt.Printf("%s[empty slice]\n", indent)
            return
        }
        fmt.Printf("%s[slice of %s, len=%d]\n", indent, val.Type().Elem(), val.Len())
        for i := 0; i < val.Len(); i++ {
            elem := val.Index(i)
            fmt.Printf("%s  [%d]: ", indent, i)
            deepReflectAndIterate(elem, indent+"    ") // 递归调用
        }
    } else if val.Kind() == reflect.Struct {
        fmt.Printf("%s{struct %s}\n", indent, val.Type())
        for i := 0; i < val.NumField(); i++ {
            field := val.Field(i)
            fieldType := val.Type().Field(i)
            fmt.Printf("%s  %s: ", indent, fieldType.Name)
            deepReflectAndIterate(field, indent+"    ") // 递归处理结构体字段
        }
    } else {
        fmt.Printf("%s%v (%s)\n", indent, val.Interface(), val.Kind())
    }
}

// 调用示例
func main() {
    nestedSlice := [][]string{
        {"a", "b"},
        {"c", "d", "e"},
    }
    deepReflectAndIterate(reflect.ValueOf(nestedSlice), "")
}

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func iterateStructSlice(slice interface{}) {
    v := reflect.ValueOf(slice)
    if v.Kind() != reflect.Slice {
        fmt.Println("Not a slice.")
        return
    }

    for i := 0; i < v.Len(); i++ {
        elem := v.Index(i) // 可能是结构体值或结构体指针
        if elem.Kind() == reflect.Ptr {
            elem = elem.Elem() // 如果是指针，解引用
        }

        if elem.Kind() == reflect.Struct {
            fmt.Printf("处理结构体 %s (索引 %d):\n", elem.Type(), i)
            for j := 0; j < elem.NumField(); j++ {
                field := elem.Field(j)
                fieldType := elem.Type().Field(j)
                fmt.Printf("  字段名: %s, 类型: %s, 值: %v, Tag: %s\n",
                    fieldType.Name, field.Type(), field.Interface(), fieldType.Tag.Get("json"))

                // 尝试修改字段值 (需要CanSet()为true)
                if field.CanSet() && field.Kind() == reflect.String {
                    // 假设我们想把所有string类型的字段都加上"_modified"
                    field.SetString(field.String() + "_modified")
                }
            }
        }
    }
}

func main() {
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
    }
    // 如果要修改，需要传入指针切片，或者原始切片就是可寻址的
    // 这里为了演示修改，我需要一个 *Person 的切片，或者对原始切片进行特殊处理
    // 但直接传入 []Person 是无法修改其内部元素的，因为 Index(i) 返回的是副本
    // 所以，如果需要修改，通常我们会这么做：
    peoplePtrs := []*Person{
        {"Alice", 30},
        {"Bob", 25},
    }
    iterateStructSlice(peoplePtrs)
    fmt.Println("修改后的peoplePtrs:", peoplePtrs) // 验证修改
}