Go reflect.Value.Seq 怎样遍历数组或切片

如果手里拿到的是运行时才知道类型的数组或切片，reflect.Value.Seq 可以把它转换成 iter.Seq[reflect.Value]，然后继续使用 Go 的 range 遍历。最小写法是先用 reflect.ValueOf 得到值，再确认 CanSeq()，最后读取每个元素的 Interface()。

Value.Seq 能遍历哪些值

Value.Seq() 返回一个单值迭代器。官方文档列出的直接支持范围包括数组、切片、字符串、映射、通道、整数类型，以及满足约定的函数值；指向数组的指针也有专门边界。本文只展开数组和切片，因为这两类最适合把反射字段统一转换成元素序列。

调用前可以使用 CanSeq() 做能力判断。它只说明当前类型是否可以使用 Value.Seq，并不替你处理元素的具体类型。

用 reflect.Value.Seq 遍历数组或切片

下面的函数接收任意数组或切片，把每个元素按顺序打印出来。代码中的 Interface() 会把可导出的元素转回接口值，便于继续做类型断言或格式化。

package main

import (
    "fmt"
    "reflect"
)

// printSequence 只处理可以由 Value.Seq 遍历的数组或切片。
func printSequence(input any) {
    value := reflect.ValueOf(input)
    if !value.IsValid() || !value.CanSeq() {
        // nil 或不支持的 Kind 不直接调用 Seq，避免运行时 panic。
        fmt.Println("value cannot be iterated by Value.Seq")
        return
    }

    for element := range value.Seq() {
        // Interface 把当前 reflect.Value 还原成普通 Go 值。
        fmt.Printf("%v (kind=%s)\n", element.Interface(), element.Kind())
    }
}

func main() {
    printSequence([]string{"Go", "reflect", "Seq"})
    printSequence([3]int{10, 20, 30})
}

这里的关键不是把切片转换成另一份切片，而是得到一个延迟产生 reflect.Value 的序列。遍历顺序仍然与数组或切片的索引顺序一致，元素本身的反射类型也会保留。

读取元素时要区分 Kind 和具体类型

Seq 只负责提供元素，后续如何读取仍取决于每个元素的 Kind。若输入是 []int，可以调用 Int()；若输入是结构体切片，则可以继续调用字段访问方法。不要假定所有元素都能安全调用同一个读取方法。

func sumInts(input any) (int64, error) {
    value := reflect.ValueOf(input)
    if !value.IsValid() || !value.CanSeq() {
        return 0, fmt.Errorf("input is not a sequence")
    }

    var total int64
    for element := range value.Seq() {
        if element.Kind() != reflect.Int {
            // 先判断 Kind，避免用 Int 读取非整数元素。
            return 0, fmt.Errorf("unexpected element kind: %s", element.Kind())
        }
        total += element.Int()
    }
    return total, nil
}

对于不同宽度的有符号整数，可以按需要扩展 Kind 判断；浮点数、字符串和结构体则应选择对应的读取或转换路径。反射代码的安全边界应放在序列消费处，而不是假设调用方传入了统一类型。

零值、指向数组的指针和不支持类型

reflect.ValueOf(nil) 返回无效的零值，不能直接调用 CanSeq 以外的普通方法。对外部输入做反射遍历时，先用 IsValid() 排除它。一个指向数组的指针可以被 Seq 处理，但普通指针、布尔值或结构体本身不在数组/切片这条使用路径中。

func canIterate(input any) bool {
    value := reflect.ValueOf(input)
    if !value.IsValid() {
        // nil 没有 Kind，也没有可遍历的序列。
        return false
    }
    // CanSeq 是调用 Seq 前的能力检查，不代表元素都可 Interface。
    return value.CanSeq()
}

如果已经确定输入就是数组或切片，也可以直接调用 Seq；但公共工具函数通常还需要保留这层防护。对不适用的值直接调用 Seq 会触发运行时 panic，应该把它转换为返回错误或跳过处理。

Seq 和 Seq2 有什么区别

Seq 返回单值序列，适合数组、切片等“只关心元素”的遍历；Seq2 返回双值序列，适合需要同时拿到键和值的映射或字符串索引场景。把两者混用会让代码表达的任务边界变得模糊。

常见问题

Value.Seq 会复制原数组或切片吗？

它提供的是迭代序列，不是把元素重新复制成一个普通切片。是否产生额外分配还取决于你的消费逻辑，不应把它当作复制 API。

为什么调用 Seq 会 panic？

通常是当前 reflect.Value 的 Kind 不在支持范围，或者把无效值当成了有效值。进入序列前检查 IsValid 和 CanSeq。

为什么不用普通 range？

当编译期已经知道是数组或切片时，普通 range 更简单；Value.Seq 的价值在于输入类型只有运行时才确定的通用反射工具。

总结：先用 reflect.ValueOf 获取值，再用 IsValid 和 CanSeq 确认边界，最后通过 range value.Seq() 消费元素。消费阶段继续检查每个元素的 Kind，就能把反射遍历写得清晰且可控。