{% raw %}

# Tcl 列表

> 原文： [https://zetcode.com/lang/tcl/lists/](https://zetcode.com/lang/tcl/lists/)

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

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

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

## 创建列表

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

```tcl
#!/usr/bin/tclsh

set l1 { 1 2 3 }
set l2 [list one two three]
set l3 [split "1.2.3.4" .]

puts $l1
puts $l2
puts $l3

```

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

```tcl
set l1 { 1 2 3 }

```

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

```tcl
set l2 [list one two three]

```

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

```tcl
set l3 [split "1.2.3.4" .]

```

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

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

```

`createlists.tcl`脚本的输出。

## `llength`命令

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

```tcl
#!/usr/bin/tclsh

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

```

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

```tcl
puts [llength { 1 2 3 4 }]

```

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

```tcl
puts [llength {}]

```

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

```tcl
puts [llength { 1 2 {3 4} }]

```

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

```tcl
puts [llength { 1 2 {} 3 4 }]

```

空列表也计入一个元素。

```tcl
$ ./list_length.tcl 
4
0
3
5

```

`list_length.tcl`示例的输出。

## 检索元素

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

```tcl
#!/usr/bin/tclsh

set vals { 2 4 6 8 10 12 14 }

puts [lindex $vals 0]
puts [lindex $vals 3]
puts [lindex $vals end]
puts [lindex $vals end-2]

```

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

```tcl
puts [lindex $vals 0]
puts [lindex $vals 3]

```

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

```tcl
puts [lindex $vals end]
puts [lindex $vals end-2]

```

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

```tcl
$ ./retrieving.tcl 
2
8
14
10

```

这是`retrieving.tcl`脚本的输出。

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

```tcl
#!/usr/bin/tclsh

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

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

```

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

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

```

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

```tcl
lassign { a b c } x y z
puts "$x $y $z"

```

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

```tcl
$ ./retrieving2.tcl 
c d e
b c d e
a b c

```

这是`retrieving2.tcl`脚本的输出。

## 遍历列表

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

```tcl
#!/usr/bin/tclsh

foreach item {1 2 3 4 5 6 7 8 9} {

    puts $item
}

```

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

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

```

示例的输出。

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

```tcl
#!/usr/bin/tclsh

set days [list Monday Tuesday Wednesday Thursday \
    Friday Saturday Sunday]
set n [llength $days]

set i 0

while {$i < $n} {

    puts [lindex $days $i]
    incr i
}

```

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

```tcl
set days [list Monday Tuesday Wednesday Thursday \
    Friday Saturday Sunday]

```

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

```tcl
set n [llength $days]

```

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

```tcl
set i 0

```

这是一个柜台。

```tcl
while {$i < $n} {

    puts [lindex $days $i]
    incr i
}

```

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

```tcl
puts [lindex $days $i]

```

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

```tcl
incr i

```

计数器增加。

```tcl
$ ./traverse2.tcl
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

```

示例的输出。

## `lmap`命令

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

```tcl
#!/usr/bin/tclsh

set vals { 1 2 3 4 5 6 }

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

```

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

```tcl
puts [lmap a $vals {expr {$a ** 2}}]

```

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

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

```

示例的输出。

## 插入元素

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

```tcl
#!/usr/bin/tclsh

set nums {4 5 6}
puts $nums

lappend nums 7 8 9
puts $nums

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

```

我们列出了三个数字。

```tcl
lappend nums 7 8 9

```

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

```tcl
puts [linsert $nums 0 1 2 3]

```

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

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

```

这是`operations.tcl`脚本的输出。

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

```tcl
#!/usr/bin/tclsh

set animals1 { lion eagle elephant dog cat }
set animals2 { giraffe tiger horse dolphin }

set animals [concat $animals1 $animals2]

puts $animals

puts [lsearch -exact $animals eagle]
puts [lreplace $animals 3 4 buffalo crocodile]

```

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

```tcl
set animals [concat $animals1 $animals2]

```

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

```tcl
puts [lsearch -exact $animals eagle]

```

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

```tcl
puts [lreplace $animals 3 4 buffalo crocodile]

```

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

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

```

这是示例输出。

## 排序项目

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

```tcl
#!/usr/bin/tclsh

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

puts [lsort $names]
puts [lsort -ascii $names]
puts [lsort -ascii -decreasing $names]
puts [lsort -integer -increasing $nums]
puts [lsort -integer -decreasing $nums]
puts [lsort -integer -unique $nums]

```

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

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

```

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

```tcl
puts [lsort $names]
puts [lsort -ascii $names]

```

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

```tcl
puts [lsort -integer -increasing $nums]
puts [lsort -integer -decreasing $nums]

```

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

```tcl
puts [lsort -integer -unique $nums]

```

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

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

```

这是`sorting.tcl`脚本的输出。

## 嵌套列表

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

```tcl
#!/usr/bin/tclsh

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

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

puts [lindex $nums 0]
puts [lindex [lindex $nums 2] 1]
puts [lindex [lindex [lindex $nums 3] 1] 1]

```

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

```tcl
set nums {1 2 {1 2 3 4} {{1 2} {3 4}} 3 4}

```

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

```tcl
puts [llength $nums]

```

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

```tcl
puts [llength [lindex $nums 2]]

```

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

```tcl
puts [lindex $nums 0]

```

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

```tcl
puts [lindex [lindex $nums 2] 1]

```

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

```tcl
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，该命令被打印到终端上。

```tcl
$ ./nestedlists.tcl
6
4
1
2
4

```

示例的输出。

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

```tcl
#!/usr/bin/tclsh

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

puts [lindex $nums 0]
puts [lindex $nums 2 1]
puts [lindex $nums 2 3 1]

```

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

```tcl
$ ./nestedlists2.tcl 
1
2
5

```

示例的输出。

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

{% endraw %}