{% raw %}

Tcl 列表

原文： https://zetcode.com/lang/tcl/lists/

在 Tcl 教程的这一部分中，我们将讨论列表。

计算机程序可以处理数据。 处理数据组是一项基本的编程操作。 在 Tcl 中，列表是基本数据结构。 它是有价物品的有序集合。 列表中的项目用空格隔开。

列表中的每个项目均由其索引标识。 列表没有固定的长度。 列表元素可以是字符串，数字，变量，文件或其他列表。 我们可以将列表嵌套到其他任何深度的列表中。

创建列表

我们可以通过多种方式在 Tcl 中创建列表。

  1. #!/usr/bin/tclsh
  3. set l1 { 1 2 3 }
  4. set l2 [list one two three]
  5. set l3 [split "1.2.3.4" .]
  7. puts $l1
  8. puts $l2
  9. puts $l3

创建了三个列表，并将它们的元素打印到控制台。

  1. set l1 { 1 2 3 }

创建列表的基本方法是将列表的元素放在大括号内。 列表元素由空格分隔。

  1. set l2 [list one two three]

创建列表的另一种方法是使用list命令。

  1. set l3 [split "1.2.3.4" .]

一些 Tcl 命令作为结果返回一个列表。 在上面的代码行中，split命令返回从字符串生成的数字列表。

  1. $ ./createlists.tcl
  2.  1 2 3 
  3. one two three
  4. 1 2 3 4

createlists.tcl脚本的输出。

llength命令

llength命令计算列表中的元素数。

  1. #!/usr/bin/tclsh
  3. puts [llength { 1 2 3 4 }]
  4. puts [llength {}]
  5. puts [llength { 1 2 {3 4} }]
  6. puts [llength { 1 2 {} 3 4 }]

该脚本计算四个列表的长度。

  1. puts [llength { 1 2 3 4 }]

该列表包含四个元素，因此，有 4 个被打印到控制台。

  1. puts [llength {}]

此列表为空； llength命令返回 0。

  1. puts [llength { 1 2 {3 4} }]

此列表包含一个内部列表– {3 4}。 内部列表占一个元素。

  1. puts [llength { 1 2 {} 3 4 }]

空列表也计入一个元素。

  1. $ ./list_length.tcl 
  2. 4
  3. 0
  4. 3
  5. 5

list_length.tcl示例的输出。

检索元素

列表元素检索有三个基本命令：lindex，lrange和lassign。

  1. #!/usr/bin/tclsh
  3. set vals { 2 4 6 8 10 12 14 }
  5. puts [lindex $vals 0]
  6. puts [lindex $vals 3]
  7. puts [lindex $vals end]
  8. puts [lindex $vals end-2]

该代码示例使用lindex命令从指定索引处的列表中检索元素。

  1. puts [lindex $vals 0]
  2. puts [lindex $vals 3]

Tcl 列表索引从 0 开始。上述命令在位置 1 和 4 处打印列表的元素。

  1. puts [lindex $vals end]
  2. puts [lindex $vals end-2]

end字符串表示最后一个元素的索引。 也可以从中减去一个整数。

  1. $ ./retrieving.tcl 
  2. 2
  3. 8
  4. 14
  5. 10

这是retrieving.tcl脚本的输出。

下一个代码示例说明lrange和lassign命令。

  1. #!/usr/bin/tclsh
  3. puts [lrange { a b c d e } 2 4]
  4. puts [lrange { a b c d e } 1 end]
  6. lassign { a b c } x y z
  7. puts "$x $y $z"

lrange命令返回由两个索引指定的列表的一部分。 lassign命令将列表中的值分配给指定的变量。

  1. puts [lrange { a b c d e } 2 4]
  2. puts [lrange { a b c d e } 1 end]

在这里，我们打印列表的两个子列表。

  1. lassign { a b c } x y z
  2. puts "$x $y $z"

使用lassign命令，我们将列表元素分配给三个变量。

  1. $ ./retrieving2.tcl 
  2. c d e
  3. b c d e
  4. a b c

这是retrieving2.tcl脚本的输出。

遍历列表

现在我们已经定义了列表和基本的列表操作，我们想遍历列表元素。 我们展示了几种浏览列表项的方法。

  1. #!/usr/bin/tclsh
  3. foreach item {1 2 3 4 5 6 7 8 9} {
  5.     puts $item
  6. }

我们使用foreach命令浏览列表元素。 item变量的每个循环周期都有数字列表中的下一个值。

  1. $ ./traverse1.tcl
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. 6
  8. 7
  9. 8
  10. 9

示例的输出。

在第二个示例中，我们将使用while循环查看日期名称。

  1. #!/usr/bin/tclsh
  3. set days [list Monday Tuesday Wednesday Thursday \
  4.     Friday Saturday Sunday]
  5. set n [llength $days]
  7. set i 0
  9. while {$i < $n} {
  11.     puts [lindex $days $i]
  12.     incr i
  13. }

我们使用while循环遍历列表。 在使用while循环时，我们还需要一个计数器和列表中的项目数。

  1. set days [list Monday Tuesday Wednesday Thursday \
  2.     Friday Saturday Sunday]

list命令用于创建日期列表。

  1. set n [llength $days]

列表的长度由llength命令确定。

  1. set i 0

这是一个柜台。

  1. while {$i < $n} {
  3.     puts [lindex $days $i]
  4.     incr i
  5. }

while循环执行主体中的命令，直到计数器等于列表中的元素数为止。

  1. puts [lindex $days $i]

lindex从计数器指向的列表中返回一个值。

  1. incr i

计数器增加。

  1. $ ./traverse2.tcl
  2. Monday
  3. Tuesday
  4. Wednesday
  5. Thursday
  6. Friday
  7. Saturday
  8. Sunday

示例的输出。

lmap命令

可以使用lmap命令浏览列表中的元素。 这是一个函数式命令。 lmap命令遍历一个或多个列表中的所有元素并收集结果。

  1. #!/usr/bin/tclsh
  3. set vals { 1 2 3 4 5 6 }
  5. puts [lmap a $vals {expr {$a ** 2}}]

该示例将lmap应用于整数列表。

  1. puts [lmap a $vals {expr {$a ** 2}}]

函数式的lmap命令将表达式在其主体中应用于vals列表的每个元素。 返回包含新的平方整数列表的结果。

  1. $ ./lmap_cmd.tcl 
  2. 1 4 9 16 25 36

示例的输出。

插入元素

下一个示例将元素插入 Tcl 列表。 lappend命令将元素添加到列表的末尾； 它修改了原始列表。 linsert命令在指定的索引处插入元素； 它不会修改原始列表，但会返回一个新列表。

  1. #!/usr/bin/tclsh
  3. set nums {4 5 6}
  4. puts $nums
  6. lappend nums 7 8 9
  7. puts $nums
  9. puts [linsert $nums 0 1 2 3]
  10. puts $nums

我们列出了三个数字。

  1. lappend nums 7 8 9

lappend将数据附加到列表。 原始列表已更改。

  1. puts [linsert $nums 0 1 2 3]

linsert在给定索引处插入元素。 第一个数字是索引。 其余值是要插入列表中的数字。 该命令创建一个新列表并返回它； 它不会修改原始列表。

  1. $ ./inserting.tcl 
  2. 4 5 6
  3. 4 5 6 7 8 9
  4. 1 2 3 4 5 6 7 8 9
  5. 4 5 6 7 8 9

这是operations.tcl脚本的输出。

在下面的示例中，我们将连接列表，搜索项目并替换列表中的项目。

  1. #!/usr/bin/tclsh
  3. set animals1 { lion eagle elephant dog cat }
  4. set animals2 { giraffe tiger horse dolphin }
  6. set animals [concat $animals1 $animals2]
  8. puts $animals
  10. puts [lsearch -exact $animals eagle]
  11. puts [lreplace $animals 3 4 buffalo crocodile]

我们定义了两个动物列表。 我们介绍了三个新命令。

  1. set animals [concat $animals1 $animals2]

concat命令用于连接（添加）两个列表。 上一行连接了两个列表，新列表设置为animal变量。

  1. puts [lsearch -exact $animals eagle]

使用lsearch命令，我们在列表中寻找鹰。 使用-exact选项，我们可以寻找完全匹配的内容。 该命令返回第一个匹配元素的索引，如果没有匹配，则返回 -1。

  1. puts [lreplace $animals 3 4 buffalo crocodile]

lreplace命令用水牛和鳄鱼代替了狗和猫。

  1. $ ./operations2.tcl
  2. lion eagle elephant dog cat giraffe tiger horse dolphin
  3. 1
  4. lion eagle elephant buffalo crocodile giraffe tiger horse dolphin

这是示例输出。

排序项目

在本节中，我们将展示如何对 Tcl 列表中的项目进行排序。

  1. #!/usr/bin/tclsh
  3. set names { John Mary Lenka Veronika Julia Robert }
  4. set nums { 1 5 4 3 6 7 9 2 11 0 8 2 3 }
  6. puts [lsort $names]
  7. puts [lsort -ascii $names]
  8. puts [lsort -ascii -decreasing $names]
  9. puts [lsort -integer -increasing $nums]
  10. puts [lsort -integer -decreasing $nums]
  11. puts [lsort -integer -unique $nums]

要对列表元素进行排序，我们可以使用sort命令。 该命令不会修改原始列表。 它返回一个新的元素排序列表。

  1. set names { John Mary Lenka Veronika Julia Robert }
  2. set nums { 1 5 4 3 6 7 9 2 11 0 8 2 3 }

我们有两个列表。 在第一个数字中，我们有字符串，在第二个数字中。

  1. puts [lsort $names]
  2. puts [lsort -ascii $names]

默认排序是 ASCII 排序。 元素按其在 ASCII 表中的位置排序。

  1. puts [lsort -integer -increasing $nums]
  2. puts [lsort -integer -decreasing $nums]

我们将值视为整数，然后按升序和降序对其进行排序。

  1. puts [lsort -integer -unique $nums]

我们在数字上下文中以递增顺序对列表中的元素进行排序。 重复项将被删除。

  1. $ ./sorting.tcl
  2. John Julia Lenka Mary Robert Veronika
  3. John Julia Lenka Mary Robert Veronika
  4. Veronika Robert Mary Lenka Julia John
  5. 0 1 2 2 3 3 4 5 6 7 8 9 11
  6. 11 9 8 7 6 5 4 3 3 2 2 1 0
  7. 0 1 2 3 4 5 6 7 8 9 11

这是sorting.tcl脚本的输出。

嵌套列表

在 Tcl 中可以有嵌套列表-其他列表中的列表。

  1. #!/usr/bin/tclsh
  3. set nums {1 2 {1 2 3 4} {{1 2} {3 4}} 3 4}
  5. puts [llength $nums]
  6. puts [llength [lindex $nums 2]]
  8. puts [lindex $nums 0]
  9. puts [lindex [lindex $nums 2] 1]
  10. puts [lindex [lindex [lindex $nums 3] 1] 1]

这是一个在 Tcl 中具有嵌套列表的简单示例。

  1. set nums {1 2 {1 2 3 4} {{1 2} {3 4}} 3 4}

nums是带有两个嵌套列表的列表。 第二个嵌套列表还有两个附加的内部嵌套列表。

  1. puts [llength $nums]

我们确定列表的大小。 嵌套列表被视为一个元素。

  1. puts [llength [lindex $nums 2]]

在此行中，我们确定第一个嵌套列表的大小，这是主列表的第三个元素。

  1. puts [lindex $nums 0]

在这里，我们打印主列表的第一个元素。

  1. puts [lindex [lindex $nums 2] 1]

在上一行中，我们获得了第一个嵌套列表的第二个元素。

  1. puts [lindex [lindex [lindex $nums 3] 1] 1]

在这里，我们获得内部列表的第二个内部列表的第二个元素，它们位于主列表的第 4 个位置。 换句话说：最里面的命令首先执行。 [lindex $nums 3]返回{{1 2} {3 4}}。 现在，第二个命令在此返回列表上运行。 [lindex {{1 2} {3 4}} 1]表达式返回{3 4}。 最后，最后一条命令[lindex {3 4} 1]返回 4，该命令被打印到终端上。

  1. $ ./nestedlists.tcl
  2. 6
  3. 4
  4. 1
  5. 2
  6. 4

示例的输出。

可以使用更简单的语法来检索嵌套列表的元素。

  1. #!/usr/bin/tclsh
  3. set nums { 1 2 {1 2 3 {4 5}} 3 4 }
  5. puts [lindex $nums 0]
  6. puts [lindex $nums 2 1]
  7. puts [lindex $nums 2 3 1]

索引跟随lindex命令的第一个参数，从最外面的列表的索引开始。

  1. $ ./nestedlists2.tcl 
  2. 1
  3. 2
  4. 5

示例的输出。

在 Tcl 教程的这一部分中，我们介绍了 Tcl 列表。

{% endraw %}