Go语言：遍历n个任意切片元素的所有可能组合

要实现逐个迭代生成结构体中所有切片字段的元素组合（笛卡尔积），可以借助Go的反射机制动态处理任意字段数量和类型的结构体，同时通过索引进位的方式逐个生成组合，避免预计算所有组合占用过多内存。

核心思路 #

1. 利用反射遍历结构体的所有可见字段，确认每个字段都是切片类型，并记录每个切片的长度。
2. 维护一个索引数组，记录当前组合在每个切片中的位置，通过类似进制加法的进位逻辑更新索引，生成下一个组合。
3. 每次迭代时，根据当前索引数组从各切片中取出对应元素，组装成目标结构体实例返回。

完整实现代码 #

package main

import (
	"fmt"
	"reflect"
)

// 定义迭代器类型，用于逐个生成组合
type CombinationIterator struct {
	fieldsInfo []fieldInfo // 每个字段的反射信息和切片长度
	resultType reflect.Type // 结果结构体的类型
	currentIdx []int        // 当前各字段的索引位置
	total      int          // 总组合数，用于判断是否迭代结束
	used       int          // 已生成的组合数
}

type fieldInfo struct {
	fieldIndex int          // 结构体字段的索引
	sliceValue reflect.Value // 切片字段的反射值
	length     int          // 切片长度
}

// 初始化迭代器，输入任意包含切片字段的结构体
func NewCombinationIterator(params interface{}) (*CombinationIterator, error) {
	paramsVal := reflect.ValueOf(params)
	if paramsVal.Kind() != reflect.Struct {
		return nil, fmt.Errorf("input must be a struct")
	}

	paramsType := paramsVal.Type()
	fieldsInfo := make([]fieldInfo, 0)
	total := 1

	// 遍历结构体所有可见字段
	for i := 0; i < paramsType.NumField(); i++ {
		field := paramsType.Field(i)
		fieldVal := paramsVal.Field(i)

		if fieldVal.Kind() != reflect.Slice {
			return nil, fmt.Errorf("field %s is not a slice", field.Name)
		}

		length := fieldVal.Len()
		if length == 0 {
			return nil, fmt.Errorf("field %s has empty slice", field.Name)
		}

		fieldsInfo = append(fieldsInfo, fieldInfo{
			fieldIndex: i,
			sliceValue: fieldVal,
			length:     length,
		})
		total *= length
	}

	if total == 0 {
		return nil, fmt.Errorf("no valid combinations")
	}

	return &CombinationIterator{
		fieldsInfo: fieldsInfo,
		resultType: paramsType,
		currentIdx: make([]int, len(fieldsInfo)),
		total:      total,
		used:       0,
	}, nil
}

// Next 生成下一个组合，返回是否还有下一个组合
func (iter *CombinationIterator) Next() bool {
	if iter.used >= iter.total {
		return false
	}
	iter.used++

	// 第一次调用直接返回初始索引（全0）
	if iter.used == 1 {
		return true
	}

	// 从最后一个字段开始进位更新索引
	for i := len(iter.currentIdx) - 1; i >= 0; i-- {
		iter.currentIdx[i]++
		if iter.currentIdx[i] < iter.fieldsInfo[i].length {
			break
		}
		iter.currentIdx[i] = 0
		// 如果是第一个字段进位后超出，说明所有组合已生成
		if i == 0 {
			return false
		}
	}

	return true
}

// Value 返回当前组合的结构体实例
func (iter *CombinationIterator) Value() interface{} {
	result := reflect.New(iter.resultType).Elem()

	for i, idx := range iter.currentIdx {
		info := iter.fieldsInfo[i]
		// 从切片中取出对应索引的元素，赋值给结果结构体的对应字段
		result.Field(info.fieldIndex).Set(info.sliceValue.Index(idx))
	}

	return result.Interface()
}

// 使用示例
func main() {
	parameters := struct {
		Parameters1 []int
		Parameters2 []byte
		Parameters3 [][]byte
	}{
		Parameters1: []int{1, 2, 4},
		Parameters2: []byte{0, 1},
		Parameters3: [][]byte{[]byte("hi"), []byte("goodbye")},
	}

	iter, err := NewCombinationIterator(parameters)
	if err != nil {
		fmt.Println("Error creating iterator:", err)
		return
	}

	for iter.Next() {
		comb := iter.Value().(struct {
			Parameters1 []int
			Parameters2 []byte
			Parameters3 [][]byte
		})
		fmt.Printf("%d, %d, %s\n", comb.Parameters1[0], comb.Parameters2[0], string(comb.Parameters3[0]))
	}
}

代码说明 #

• CombinationIterator：封装了迭代所需的所有状态，包括字段信息、当前索引、总组合数等。
• NewCombinationIterator：初始化迭代器时，检查输入是否为结构体、所有字段是否为切片，计算总组合数，初始化索引数组。
• Next：通过进位逻辑更新索引，控制迭代流程，返回是否还有下一个组合。
• Value：根据当前索引从各切片中取出元素，组装成结构体实例返回。
• 使用示例：演示了如何初始化迭代器并遍历所有组合，注意类型断言要与输入结构体一致。

注意事项 #

• 如果结构体中有非切片字段，初始化时会返回错误，可根据需求修改逻辑（比如忽略非切片字段）。
• 若某个切片长度为0，直接返回无有效组合，避免生成空组合。
• 迭代器是状态化的，每次调用Next()后，Value()返回当前最新的组合。

内容的提问来源于stack exchange，提问作者ibarrond