如何在tcl中迭代嵌套列表？

tcl中有一个嵌套的列表x

set x {{A 0} {B 1} {C 2} {D 3}}

如何迭代并打印此嵌套列表中的所有元素

set x {{A 0} {B 1} {C 2} {D 3} {6 {F G}}}

set y {{{{1 2 {3 4}}}}}

array set myarr {}
set count 0
proc printListElem {myList} {
    global myarr count
    for {set i 0} {$i <[llength $myList]} {incr i} {
        set currentElem [lindex $myList $i]
        if {![info exists myarr($count,${currentElem})]} {
            incr count
            set myarr($count,${currentElem}) 1
            printListElem $currentElem
        } else {
            incr count -1
            break
        }
    }
}

printListElem $y
foreach idx [lsort [array names myarr]] {
    lassign [split $idx ,] key value
    puts "[string repeat "+" $key]$value"
}

---

此处出现的

+

数量将表示列表元素的嵌套级别。（感谢格伦先生的建议）。这可能不是一个有效的方法，但也可以这样做

如果我们知道列表深度，就可以嵌套一些

foreach

调用：

foreach a $x {
    foreach b $a {
        puts "--> $b"
    }
}

但是Tcl中不存在一般的“迭代所有可能的嵌套列表”，因为该概念与Tcl的类型模型不兼容。从字面上讲，你不应该以一种让这成为一个明智问题的方式来思考价值观。您不需要构建任意的树：您需要构建特定的树，其中的级别对于当前的问题是有意义的

---

（关键问题是，

red hot cat

同时是一个3项列表和一个11个字符的字符串。）

扩展Dinesh的答案很容易，使其真正递归：

set x {{A 0} {B 1} {C 2} {D 3} {4 {F G}}}; # Have added one more element

proc printListElem {myList {level 1}} {
    foreach elem $myList {
        puts "[string repeat "+" $level] $elem"
        if {[llength $elem] > 1} {
            printListElem $elem [expr {$level + 1}]
        }
    }
}

printListElem$x

+ A 0
++ A
++ 0
+ B 1
++ B
++ 1
+ C 2
++ C
++ 2
+ D 3
++ D
++ 3
+ 4 {F G}
++ 4
++ F G
+++ F
+++ G

---

我看到人们试图递归迭代并提出通用解决方案，我很确定有些人可能不同意这一点，但“如何迭代并打印此嵌套列表中的所有元素？”这一问题的答案非常简单

该列表包含4个元素“A1”、“B2”、“C3”、“D4”，因此答案是：

% set x {{A 0} {B 1} {C 2} {D 3}}
{A 0} {B 1} {C 2} {D 3}

% foreach item $x {
    puts $item
}
A 0
B 1
C 2
D 3

假设一个人想要对单个值做一些事情，那么可以使用or（或），例如

也可以采用多个值，因此也可以采用以下方式：

foreach item $x {
    foreach {char num} $item {
        puts "char = $char, num = $num"
    }
}

在实践中，人们不会有随机级别的嵌套列表来存储有用的数据，但如果一个人确实有这样的数据，那么它可能值得研究

例如：

 % set x {A {B 2} C {D {E 5}} F 6}
 A {B 2} C {D {E 5}} F 6
 % dict get $x A
 B 2
 % dict get $x A B
 2
 % dict get $x C D E
 5
 % dict get $x F
 6

---

如果您愿意完全失去嵌套级别的所有跟踪，则可以使用此方法完全折叠所有嵌套列表级别（除非在列表中的字符串值内使用{}，这些级别也将被删除）

set x {{A 0} {B 1} {C 2} {D 3} {6 {F G}}} 
set xn [string map {"{" "" "}" ""} $x] 


puts [join $xn "\n"]

---

你尝试了什么？预期的结果是什么？@Dinesh，你想在你的答案中加入这个吗？哇！！！看起来很棒。最好是一个独立的wiki答案。：）。实际上，我正在考虑通过在列表中支持更多的嵌套级别，使其更加健壮。让我在回答中更新一下。希望它应该是有效的。

 % set x {A {B 2} C {D {E 5}} F 6}
 A {B 2} C {D {E 5}} F 6
 % dict get $x A
 B 2
 % dict get $x A B
 2
 % dict get $x C D E
 5
 % dict get $x F
 6

set x {{A 0} {B 1} {C 2} {D 3} {6 {F G}}} 
set xn [string map {"{" "" "}" ""} $x] 


puts [join $xn "\n"]