本文介绍一种基于 channel 管道链的优雅方案，用动态构建的 goroutine 流水线替代固定层数的嵌套 for 循环，实现任意深度 d 的笛卡尔积式迭代器，输出形如 "1,1,1" 到 "59,59,59" 的字符串序列。
本文介绍一种基于 channel 管道链的优雅方案，用动态构建的 goroutine 流水线替代固定层数的嵌套 for 循环，实现任意深度 d 的笛卡尔积式迭代器，输出形如 "1,1,1" 到 "59,59,59" 的字符串序列。
在 Go 中，若需生成深度为 d 的嵌套遍历（即 d 维笛卡尔积，每维取值范围为 [1, 59)），直观写法是嵌套 d 层 for 循环——但这要求编译期已知 d，无法支持运行时动态指定。真正的通用解法是将迭代过程建模为数据流管道（pipeline）：每一级 goroutine 接收前一级生成的前缀字符串，再将其与当前维度的所有可能值拼接，逐级传递，最终形成完整序列。
核心思想是：
- 深度 1 时，仅生成 "1", "2", ..., "59"；
- 深度 d > 1 时，将 d−1 层输出作为前缀，对每个前缀重复拼接 1..59，构成新一层输出。
以下是生产就绪的实现：
package main
import "fmt"
const ITER_N = 60 // 范围：1 到 ITER_N-1（即 1~59）
// 初始层：生成单元素字符串
func startStage(out chan<- string) {
for i := 1; i < ITER_N; i++ {
out <- fmt.Sprintf("%d", i)
}
close(out)
}
// 中间/末尾层：接收前缀，拼接新维度
func expandStage(in <-chan string, out chan<- string) {
for prefix := range in {
for i := 1; i < ITER_N; i++ {
out <- fmt.Sprintf("%s,%d", prefix, i)
}
}
close(out)
}
// 主入口：动态构建 d 层管道
func IterDepth(d int) <-chan string {
if d <= 0 {
ch := make(chan string)
close(ch)
return ch
}
// 第一层：独立启动
stage := make(chan string)
go startStage(stage)
// 后续 d-1 层：逐级串联
for depth := 2; depth <= d; depth++ {
next := make(chan string)
go expandStage(stage, next)
stage = next
}
return stage
}✅ 使用示例：
func main() {
// 深度为 2：输出 "1,1", "1,2", ..., "59,59"
for s := range IterDepth(2) {
fmt.Println(s)
}
// 深度为 3：输出 "1,1,1", "1,1,2", ..., "59,59,59"
// （注意：59³ ≈ 20.5 万项，建议小范围测试）
// for s := range IterDepth(3) { ... }
}⚠️ 关键注意事项：
- 内存与性能：该方案为惰性求值，不预分配所有结果，但每层 channel 会缓冲未读消息（默认无缓冲，若下游消费慢可能阻塞上游）。必要时可为 chan string 添加合理缓冲（如 make(chan string, 64)）。
- 终止保证：所有 goroutine 均在输入 channel 关闭后自然退出，且最后一层 close(out) 确保下游 range 正常结束。
- 扩展性：可轻松替换 ITER_N 或拼接逻辑（如支持不同范围、自定义分隔符、甚至非数字类型），只需修改 startStage 和 expandStage。
- 错误处理：本例假设输入合法；实际项目中建议对 d
该设计体现了 Go 的并发哲学：用组合代替嵌套，用通信代替共享——将“深度”这一控制逻辑转化为 goroutine 的数量与连接方式，彻底解耦结构与数据，真正实现“一次编写，任意深度运行”。
