Tcl教程

TCL缩短工具命令语言的形式。由加州大学伯克利分校的约翰Ousterhout设计它。它是一种脚本语言，由其自身的解释器，它被嵌入到开发应用程序的组合。

TCL最初在Unix平台中。后来移植到Windows，DOS，OS/2和Mac OSX。 TCL非常类似于其他UNIX的shell语言，类似Bourne Shell (Sh), the C Shell (csh), the Korn Shell (sh), 和 Perl。

它的目的是提供程序与其他程序，也是作为一个可嵌入的翻译相互作用的能力。虽然原来的目的是为了使程序能够进行交互，可以找到由Tcl/Tk 编写的完全成熟的应用。

Tcl 特性

TCL的特点如下：

• 减少开发时间。
• 功能强大和简单的用户界面工具包整合传统知识。
• 一次编写，随处运行。它可以运行在Windows，Mac OS X和几乎所有的Unix平台。
• 有经验的程序员很容易上手，因为语言就是这么简单，可以在几个小时或几天学习Tcl就可以搞定。
• 可以轻松地用Tcl扩展现有的应用程序。另外，也可以包括Tcl的用C，C++或Java来扩展Tcl，或反之亦然。
• 有一组功能强大的网络功能。
• 最后，它的开源，免费的，可以用于其他无任何限制商业应用。

应用程序

Tcl是一种通用的语言，可以随便就能找到Tcl应用的例子。它包括

• 这通常是由数据库支持的可扩展的网站。
• 高性能的网络服务器建立的TclHttpd。
• TCL基于CGI的网站。
• 桌面GUI应用程序。
• 嵌入式应用。

TCL环境设置 - Tcl教程

如果愿意设置TCL环境，需要在计算机上提供以下两个软件的应用(一)文本编辑器，(二)Tcl解释器。

文本编辑器

这将被用来写入程序。一些编辑器的例子包括Windows记事本，操作系统编辑命令，Brief, Epsilon, EMACS和VIM或vi。

编辑器名称和版本的文本变化在不同的操作系统可能也会不太一样。例如，记事本将用于Windows，VIM或vi可以在Windows上使用，以及Linux或UNIX。

编辑器来创建的文件称为源文件，并包含程序的源代码。对Tcl程序的源文件被命名为扩展名为“.tcl”。

在开始编程之前，请确保已建立了一个文本编辑器，并有足够的经验来写计算机程序，将其保存在一个文件中，编译并最终执行。

Tcl解释器

这仅仅是一个小的程序，写入Tcl命令，并让它们逐行执行。在遇到错误它停止执行而不会完全编译TCL文件。

让我们来看看 helloWorld.tcl 文件，如下所示。我们将利用这一个程序作为第一个运行程序。

#!/usr/bin/tclsh

puts "Hello World!"

在Windows上安装

从可用有效的Tcl二进制文件列表下载最新版本的Windows安装程序。Tcl社区版免费供个人使用。

运行下载的可执行文件安装Tcl，可以按照屏幕上的说明进行。

现在，我们可以建立并切换到文件夹中使用cd命令包含该文件，然后按照以下步骤执行该程序运行Tcl的 helloWorld.tcl 文件

C:\Tcl> tclsh helloWorld.tcl

我们可以看到下面的输出

C:\Tcl> helloWorld

C:\Tcl是文件夹，使用以保存我们的示例文件。可以将其更改保存到您的Tcl程序的文件夹。

在Linux上安装

大多数Linux操作系统自带内置Tcl，可以马上开始在这些系统使用。万一它不可用，那么使用下面的命令来下载和安装Tcl-TK。

$ yum install tcl tk

现在，我们可以建立并切换到文件夹中使用cd命令包含该文件，然后按照以下步骤执行该程序运行Tcl的 helloWorld.tcl 文件

$ tclsh helloWorld.tcl

我们可以看到下面的输出。

$ hello world

安装在基于Debian的系统

当tcl-tk在操作系统中不可用，可以使用下面的命令来下载和安装Tcl-Tk。

$ sudo apt-get install tcl tk

现在，我们可以建立并切换到文件夹中使用cd命令包含该文件，然后按照以下步骤执行该程序运行Tcl的 helloWorld.tcl 文件

$ tclsh helloWorld.tcl

我们可以看到下面的输出。

$ hello world

安装Mac OS X系统

从可用有效的Tcl二进制文件列表下载最新版本的Mac OS X包。Tcl社区版是免费供个人使用。

运行下载的可执行文件安装Active Tcl，可以按照屏幕上的说明进行操作。

现在，可以建立并切换到文件夹中使用cd进入包含该文件，然后按照以下步骤执行该程序运行Tcl的 helloWorld.tcl 文件

$ tclsh helloWorld.tcl

我们可以看到下面的输出。

$ hello world

从安装源文件

可以使用从源文件安装二进制包。一般最好使用Tcl的二进制文件适用于Windows和Mac OS X，在基于UNIX的系统资源所以只编译如下所示。

• 下载 源文件.
• 现在，使用以下命令解压，编译和构建切换到下载的文件夹后。

$ tar zxf tcl8.6.1-src.tar.gz
$ cd tcl8.6.1
$ cd unix
$ ./configure —prefix=/opt —enable-gcc
$ make
$ sudo make install

注意：请确保更改文件名，在上面的命令1和2 写上对应的下载版本。

TCL特殊变量 - Tcl教程

在TCL，我们划分一些变量作为特殊变量，他们有一个预定义的用法/功能。特殊变量列表如下。

上述特殊变量都有各自的 Tcl 解释特殊的含义。

使用Tcl的特殊变量的例子

让我们来看看一些例子特殊变量。

Tcl 版本

#!/usr/bin/tclsh

puts $tcl_version

当运行程序，会得到一个类似的输出，如下图所示。

8.5

TCL环境路径

#!/usr/bin/tclsh

puts $env(PATH)

当运行程序，会得到一个类似的输出，如下图所示。

/web/com/GNUstep/Tools:/usr/GNUstep/Local/Tools:/usr/GNUstep/System/Tools:/usr/local/sml/bin:/usr/local/flex/bin:/usr/local/gcc-4.8.1/bin:/usr/share/java:.:/usr/share/java:/usr/lib/jvm/java/lib:/usr/lib/jvm/java/jre/lib:/usr/local/bin:/usr/local/mozart/bin:/usr/local/go/bin:/usr/local/factor/:/usr/local/groovy-2.1.7/bin:/opt/Pawn/bin/:/usr/local/icon-v950/bin:/usr/local/lib/mono/4.0:/usr/lib64/qtC.3/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/Pawn/bin:/usr/local/dart/bin:/usr/local/julia/usr/bin:/usr/local/julia:/usr/local/scriptbasic/bin

TCL程序包路径

#!/usr/bin/tclsh

puts $tcl_pkgPath

当运行程序，会得到一个类似的输出，如下图所示。

/usr/lib64/tcl8.5 /usr/share/tcl8.5 /usr/lib64/tk8.5 /usr/share/tk8.5

TCL库

#!/usr/bin/tclsh

puts $tcl_library

当运行程序，会得到一个类似的输出，如下图所示。

/usr/share/tcl8.5

TCL补丁级别

#!/usr/bin/tclsh

puts $tcl_patchLevel

当运行程序，会得到一个类似的输出，如下图所示。

8.5.7

TCL精度

#!/usr/bin/tclsh

puts $tcl_precision

当运行程序，会得到一个类似的输出，如下图所示。

0

TCL启动文件

#!/usr/bin/tclsh

puts $tcl_rcFileName

当运行程序，会得到一个相似的输出，如下图所示。

~/.tclshrc

TCL基本语法 - Tcl教程

TCL 是相当简单易学，让我们开始创建第一个Tcl程序！

第一个TCL程序

让我们写一个简单的Tcl程序。所有的Tcl文件都以.tcl为扩展名。所以，把下面的源代码在 test.tcl 文件中。

#!/usr/bin/tclsh

puts "Hello, World!"

假设，TCL环境设置正确;让我们切换到文件所在的目录，然后运行该程序：

$ tclsh test.tcl

我们会得到下面的输出。

Hello, World!

现在，让我们来看看Tcl程序的基本结构，因此，这可以了解Tcl语言的基本构建块。在TCL，我们使用新的行或分号终止代码前行。但分号不是必要的，如果使用的是每一个命令(即一个换行)。

注释

注释就像帮助文本在Tcl程序，解释器忽略它们。注释可以使用hash_(#)在开始写入。

#!/usr/bin/tclsh

# my first program in Tcl
puts "Hello World!"

多行或者块注释使用，如果条件为0。一个例子如下所示。

#!/usr/bin/tclsh

if 0 {
my first program in Tcl program
Its very simple
}
puts "Hello World! welcome to yiibai.com"

行内注释使用;＃。下面给出一个例子。

#!/usr/bin/tclsh

puts "Hello World!" ;# my first print in Tcl program

标识符

一个Tcl标识符是用来标识变量，函数，或任何其它用户定义的项目的名称。一个标识符开始以字母A到Z或a〜z或后跟零个或多个字母下划线（_），下划线，美元（$）和数字（0〜9）。

TCL不允许标点字符，如@和％标识符。TCL是大小写敏感的语言。因此Manpower 和manpower 在Tcl是两个不同的标识符。这里是可接受的标识符的一些例子：

mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal

保留字

下面列出了一些在Tcl中的保留字。这些保留的字可以不被用作常量或变量，或任何其他的标识符名称。

Tcl空格

仅包含空格，可能与注释行，被称为一个空行和Tcl解释完全忽略它。

空白格是Tcl中用来描述空格，制表符，换行符和注释的术语。空格分开一声明中的一个组成部分，使解释器来识别，其中在声明一个元件，如puts, ends和下一个元素开始。因此，在下面的语句：

#!/usr/bin/tclsh

puts "Hello World!"

必须有puts和之间“Hello World！”至少一个空白字符（通常是一个空格），以便解释器能够区分它们。另一方面，在下面的语句

#!/usr/bin/tclsh

puts [expr 3 + 2] ;# print sum of the 3 and 2

有时不需要空格在字符之间，如3和+之间，或+和2也没有必要（可以不用），虽然是自由的，如果想为便于阅读，包括一些空白格。

TCL命令 - Tcl教程

大家都知道，TCL是工具命令语言，命令语言中最重要的组成部分。 TCL命令是建立在对与每一个具有其自身的预定义的功能的语言。这些命令构成该语言的保留字，不能用于其它变量命名。这些Tcl命令的好处是，可以用来定义自己实现这些命令代替原来的内置功能。

每个 Tcl 命令的验证输入并降低了解释程序的工作。

Tcl命令实际上是词语的列表，使用要执行表示该命令的第一个字。接下来的单词代表参数。为了组单词组成单一的参数，随函多个单词可使用“”或{}。

Tcl命令的语法如下。

commandName argument1 argument2 ... argumentN

让我们来看看Tcl命令的一个简单的例子。

#!/usr/bin/tclsh

puts "Hello, world!"

当上述代码被执行时，它会产生以下结果。

Hello, world!

在上面的代码中，提出的是Tcl命令和“Hello World”的是参数1。正如前面所说，我们用“”组成两个词。

让我们来看看Tcl命令的另一个例子使用两个参数。

#!/usr/bin/tclsh

puts stdout "Hello, world!"

当上述代码被执行时，它会产生以下结果。

Hello, world!

在上面的代码中，puts 是Tcl命令，stdout是参数1 以及“Hello World”参数2。在这里，标准输出使得在标准输出设备打印的程序。

命令替换

在命令替换，方括号是用来计算在方括号中的脚本。一个简单的例子，两个数字相加如下所示。

#!/usr/bin/tclsh

puts [expr 1 + 6 + 9]

当上述代码被执行时，它会产生以下结果。

16

变量替换

在变量替换，$使用在变量名之前，这将返回该变量的内容。一个简单的例子为一个值设置为变量并打印如下所示。

#!/usr/bin/tclsh

set a 3
puts $a

当上述代码被执行时，它会产生以下结果。

3

反斜杠替换

这些通常被称为转义序列，每个反斜线后跟有自己的含义字母。一个简单的例子换行符替换如下所示。

#!/usr/bin/tclsh

puts "Hello\nWorld"

当上述代码被执行时，它会产生以下结果。

Hello
World

TCL数据类型 - Tcl教程

原始数据类型在Tcl中是字符串，我们常常可以找到字符串和引用在Tcl语言中。这些原始数据类型依次创建复合数据类型列表和关联数组。在Tcl中，数据类型可以表示不仅是简单Tcl的对象，但也可以代表相同的句柄，图形对象(主要是小部件)复杂的对象，和I/O通道。让我们来看看详细介绍每一个上面。

简单的Tcl对象

在Tcl中，无论它是一个整数，布尔，浮点数，或一个字符串。当使用一个变量，可以直接赋值给它，Tcl没有声明一步。可以有内部表示为这些不同类型的对象。它可以将一个数据类型到其它需要时。分配值给变量的语法如下。

#!/usr/bin/tclsh

set myVariable 18
puts $myVariable

当上述代码被执行时，它会产生以下结果。

18

上述声明将创建一个变量名myVariable，并将其存储为一个字符串，即使我们没有使用双引号。现在，如果试图让该变量的运算，它会自动变成一个整数。一个简单的例子如下所示。

#!/usr/bin/tclsh

set myVariable 18
puts [expr $myVariable + 6 + 9]

当上述代码被执行时，它会产生以下结果。

33

需要注意的一个重要的事情是，这些变量并没有任何默认值，必须指定的值在使用之前。

如果我们尝试使用puts来打印，这个数字被转化为正确的字符串。有两种表示方法，内部和外部，帮助 Tcl 创建复杂的数据结构很容易相对于其他语言。另外，Tcl 更有效，因为它是动态对象的性质。

字符串表示

不同于其他语言，在TCL，不需要包含双引号，它只有一个字。一个例子如下，

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

当上述代码被执行时，它会产生以下结果。

hello

当我们想表示多个字符串，可以使用双引号或大括号。它如下所示。

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable
set myVariable {hello world}
puts $myVariable

当上述代码被执行时，它会产生以下结果。

hello world
hello world

列表 - List

列表不过是一组元素。一组单词或者使用双引号或大括号可以用来表示一个简单的列表。一个简单的列表如下所示。

#!/usr/bin/tclsh

set myVariable {red green blue}
puts [lindex $myVariable 2]
set myVariable "red green blue"
puts [lindex $myVariable 1]

当上述代码被执行时，它会产生以下结果。

blue
green

关联数组

关联数组有一个索引（key）但不一定是整数。人们普遍认为就像键值对是字符串。一个简单的例子如下所示。

#!/usr/bin/tclsh

set marks(english) 80
puts $marks(english)
set marks(mathematics) 90
puts $marks(mathematics)

当上述代码被执行时，它会产生以下结果。

80
90

句柄

TCL句柄通常用于表示文件和图形对象。这些可以包括句柄网络请求以及其它渠道，如串口通讯，套接字或I/O设备。下面是创建一个文件句柄的例子。

set myfile [open "filename" r]

您会在Tcl文件I/O一章看到更多内容细节。

TCL变量 - Tcl教程

在TCL，变量声明没有概念。当遇到一个新的变量名，TCL将定义一个新的变量。

变量命名

变量的名称可以包含任何字符和长度。甚至可以存在空格被封闭在大括号中的变量，但不建议这样做。

set命令用于指定值的变量。set 命令的语法是：

set variableName value

变量的几个例子如下所示。

#!/usr/bin/tclsh

set variableA 10
set {variable B} test
puts $variableA
puts ${variable B}

当上述代码被执行时，它会产生以下结果。

10
test

正如可以在上面的方案看到，$variableName 用于获取变量的值。

动态类型

TCL是一种动态类型语言。变量的值可以在需要时被动态地转换为所需的类型。例如，一个数字5，其被存储为字符串将做的算术运算时被转换为数字。它如下所示。

#!/usr/bin/tclsh

set variableA "10"
puts $variableA
set sum [expr $variableA +20];
puts $sum

当上述代码被执行时，它会产生以下结果。

10
30

数学表达式

正如在上面的例子中看到，expr是用于表示数学表达式。 Tcl默认精度为12位。为了得到浮点运算的结果，我们应该增加至少一个十进制数字。一个简单的例子说明了上述情况。

#!/usr/bin/tclsh

set variableA "10"
set result [expr $variableA / 9];
puts $result
set result [expr $variableA / 9.0];
puts $result
set variableA "10.0"
set result [expr $variableA / 9];
puts $result

当上述代码被执行时，它会产生以下结果。

1
1.1111111111111112
1.1111111111111112

在上面的例子中，可以看到三种情况。第一种情况，被除数和除数是整数，得到一个整数作为结果。第二种情况，除数是小数以及第三种情况，分数是一个十进制数。在第二和第三情况下，得到的是十进制数作的结果。

在上面的代码，可以使用tcl_precision特殊变量改变精度。它如下所示。

#!/usr/bin/tclsh

set variableA "10"
set tcl_precision 5
set result [expr $variableA / 9.0];
puts $result

当上述代码被执行时，它会产生以下结果。

1.1111

TCL运算符 - Tcl教程

运算符是一个符号，告诉编译器执行特定的数学或逻辑操作。 Tcl语言有丰富的内置运算符，运算符提供的以下几种类型：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 三元运算符

本教程将一个一个地来解释算术，关系，逻辑，位及其他运算符。

算术运算符

下表列出了所有Tcl语言支持的算术运算符。假设变量A=10，变量B=20，则：

算术运算实例

关系运算符

下表列出了所有Tcl语言支持的关系运算符。假设变量A=10，以及变量B=20，则：

关系运算符例子

逻辑运算符

下表列出了所有Tcl语言支持的逻辑运算符。假设变量A=1和变量B=0，则：

逻辑运算符例子

位运算符

位运算符适用于位并进行逐位操作。&, |, 和 ^ 的真值表如下：

假设，如果A =60;且B =13;现在以二进制格式它们将如下：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

通过Tcl语言支持位运算符列在下表中。假设变量A=60和变量B=13，则：

位运算符例子

三元运算符

三元运算符例子

Tcl运算符优先级

运算符优先级决定术语的表达分组。这会影响一个表达式是如何进行计算。某些运算符的优先级高于其他运算符;例如，乘法运算符的优先级比所述加法运算高。

例如：x =7 + 3 2;这里，x被赋值13，而不是20，因为运算符 优先级高于+，所以它首先被乘以3 * 2，然后加上 7。

这里，具有最高优先级的操作出现在表格上方，那些具有最低出现在底部。在一个表达式中，更高的优先级运算符将首先计算。

运算符优先级示例

TCL决策 - Tcl教程

决策结构需要程序员指定的一个或多个条件进行评估，或由程序进行测试，如果条件被确定为真以及一条或多条语句，任选的其它语句，如果条件被确定为假则被执行。

以下是在大多数编程语言中找到的典型决策结构的一般形式：

TCL语言使用expr内部命令，因此它为我们声明使用expr的声明不是必需的。

TCL语言提供了以下几种类型的决策语句。

? : 操作符

我们已经覆盖条件操作符 ？ ：在前面的章节中可以用它来代替 if ... else语句。以下是它的一般形式：

Exp1 ? Exp2 : Exp3;

计算Exp1，Exp2和Exp3表达式。注意使用和放置。

a的值？表达是确定这样：Exp1计算评估。如果是真的，那么Exp2后进行评估计算，并成为整个的值？表达式。如果计算Exp1是假的，那么Exp3计算它的值变为表达式的值。一个例子如下所示。

#!/usr/bin/tclsh

set a 10;
set b [expr $a == 1 ? 20: 30]
puts "Value of b is $b\n"
set b [expr $a == 10 ? 20: 30]
puts "Value of b is $b\n"

当编译和执行上面的程序，将会产生以下结果：

Value of b is 30
Value of b is 20

TCL循环 - Tcl教程

可能有一种情况，当需要执行一个代码块多次。在一般情况下，语句是顺序执行的：如在函数内的第一条语句，首先执行，然后是第二个 ... 等等。

编程语言提供了各种控制结构，允许更多复杂的执行路径。

循环语句可以让我们执行语句多次或代码组，下面是在大多数编程语言循环语句的一般形式：

TCL语言提供循环以下类型来处理循环。

循环控制语句

循环控制语句改变其正常的顺序执行。当执行离开范围，在该范围内创建的所有自动对象被销毁。

TCL支持下面的控制语句。

无限循环

如果条件永远不会为假那么一个循环就是无限循环。 while循环是传统上用于此目的。可以通过条件表达式为1，来执行一个死循环。

while {1} {
puts "This loop will run forever."
}

当条件表达式为不存在，它被假定为真。 TCL程序员更普遍使用while {1} 构造以表示无限循环。

注意：可以通过按 Ctrl+ C键 终止无限循环。

TCL数组 - Tcl教程

数组是一组使用索引对应元素的排列方式。常规数组的语法如下所示。

set ArrayName(Index) value

用于创建简单数组的例子，如下所示。

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts $languages(0)
puts $languages(1)

当上述代码被执行时，它会产生以下结果。

Tcl
C Language

数组大小

用于计算数组大小的语法，如下所示。

[array size variablename]

用于打印数组的大小的示例如下所示。

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts [array size languages]

当上述代码被执行时，它会产生以下结果。

2

数组迭代

虽然数组索引可以是非连续的，像索引1，然后索引10等指定的值。但是如果它们是连续的，我们可以用数组迭代访问数组的元素。一个简单的数组迭代的打印元素，如下所示。

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
for { set index 0 } { $index < [array size languages] } { incr index } {
puts "languages($index) : $languages($index)"
}

当上述代码被执行时，它会产生以下结果。

languages(0) : Tcl
languages(1) : C Language

关联数组

在TCL，所有数组本质是相关联的。数组存储并没有任何具体的顺序进行检索。关联数组使用索引但不一定都是数字。一个简单的例子，关联数组与非数字索引如下所示。

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts $personA(Name)
puts $personA(Age)

当上述代码被执行时，它会产生以下结果。

Dave
14

数组的索引

用于检索数组索引的语法如下所示。

[array names variablename]

用于打印数组的大小的示例如下所示。

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts [array names personA]

当上述代码被执行时，它会产生以下结果。

Age Name

关联数组迭代

可以使用数组的索引来遍历数组。如下例子所示。

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
foreach index [array names personA] {
puts "personA($index): $personA($index)"
}

当上述代码被执行时，它会产生以下结果。

personA(Age): 14
personA(Name): Dave

TCL字符串 - Tcl教程

Tcl 的原始数据类型是字符串，我们常常可以在Tcl找到引用字符串的唯一语言。这些字符串可以包含字母数字字符，数字，布尔值，甚至是二进制数据。 TCL采用16位Unicode字符和字母数字字符，可以包含字母包括非拉丁字符，数字或标点符号。

布尔值，可以表示为1，yes 或 true 为真值和0，no 或 false 为假值。

字符串表示

不同于其他语言，在TCL，只有一个字时，不需要包含双引号。示例如下，

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

当上述代码被执行时，它会产生以下结果。

hello

当要表示多个字符串，我们可以使用双引号或大括号。它如下所示。

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable
set myVariable {hello world}
puts $myVariable

当上述代码被执行时，它会产生以下结果。

hello world
hello world

字符串转义序列

字符文字可以是一个普通的字符（例如，'x'），转义序列（如“\t'），或通用字符（例如，'\u02C0'）。

Tcl有一些字符，当他们前面加一个反斜杠他们将有特殊的含义，它们被用来表示类似的换行符（\n）或制表符（\t）。在这里，有一些转义序列代码的列表：

以下为例子来说明一些转义字符序列：

#!/usr/bin/tclsh

puts("Hello\tWorld\n\n");

让我们编译和运行上面的程序，这将产生以下结果：

Hello World

字符串命令

子命令字符串命令列表列如下表。

一些常用的Tcl字符串子命令的例子在下面给出。

字符串比较

#!/usr/bin/tclsh

set s1 "Hello"
set s2 "World"
set s3 "World"
puts [string compare s1 s2]
if {[string compare s2 s3] == 0} {
puts "String \'s1\' and \'s2\' are same.";
}

if {[string compare s1 s2] == -1} {
puts "String \'s1\' comes before \'s2\'.";
}

if {[string compare s2 s1] == 1} {
puts "String \'s2\' comes before \'s1\'.";
}

让我们编译和运行上面的程序，这将产生以下结果：

-1
String 's1' comes before 's2'.
String 's2' comes before 's1'.

字符串索引

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "o"
puts "First occurrence of $s2 in s1"
puts [string first $s2 $s1]
puts "Character at index 0 in s1"
puts [string index $s1 0]
puts "Last occurrence of $s2 in s1"
puts [string last $s2 $s1]
puts "Word end index in s1"
puts [string wordend $s1 20]
puts "Word start index in s1"
puts [string wordstart $s1 20]

让我们编译和运行上面的程序，这将产生以下结果：

First occurrence of o in s1
4
Character at index 0 in s1
H
Last occurrence of o in s1
7
Word end index in s1
11
Word start index in s1
6

字符串长度

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Length of string s1"
puts [string length $s1]

让我们编译和运行上面的程序，这将产生以下结果：

Length of string s1
11

处理大小写

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Uppercase string of s1"
puts [string toupper $s1]
puts "Lowercase string of s1"
puts [string tolower $s1]

让我们编译和运行上面的程序，这将产生以下结果：

Uppercase string of s1
HELLO WORLD
Lowercase string of s1
hello world

修整字符

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "World"
puts "Trim right $s2 in $s1"
puts [string trimright $s1 $s2]

set s2 "Hello"
puts "Trim left $s2 in $s1"
puts [string trimleft $s1 $s2]

set s1 " Hello World "
set s2 " "
puts "Trim characters s1 on both sides of s2"
puts [string trim $s1 $s2]

让我们编译和运行上面的程序，这将产生以下结果：

Trim right World in Hello World
Hello
Trim left Hello in Hello World
World
Trim characters s1 on both sides of s2
Hello World

匹配字符串

#!/usr/bin/tclsh

set s1 "test@test.com"
set s2 "*@*.com"
puts "Matching pattern s2 in s1"
puts [string match "*@*.com" $s1 ]
puts "Matching pattern tcl in s1"
puts [string match {tcl} $s1]

让我们编译和运行上面的程序，这将产生以下结果：

Matching pattern s2 in s1
1
Matching pattern tcl in s1
0

Append 命令

#!/usr/bin/tclsh

set s1 "Hello"
append s1 " World"
puts $s1

让我们编译和运行上面的程序，这将产生以下结果：

Hello World

Format 命令

Tcl显示格式format说明如下列表。

一些简单下面的例子给出。

#!/usr/bin/tclsh

puts [format "%f" 43.5]
puts [format "%e" 43.5]
puts [format "%d %s" 4 tuts]
puts [format "%s" "Tcl Language"]
puts [format "%x" 40]

让我们编译和运行上面的程序，这将产生以下结果：

43.500000
4.350000e+01
4 tuts
Tcl Language
28

Scan命令

scan命令用于分析基于对格式说明的字符串。一些例子如下所示。

#!/usr/bin/tclsh

puts [scan "90" {%[0-9]} m]
puts [scan "abc" {%[a-z]} m]
puts [scan "abc" {%[A-Z]} m]
puts [scan "ABC" {%[A-Z]} m]

当上述代码被编译和执行时，它产生了以下结果：

1
1
0
1

TCL列表 - Tcl教程

列表是Tcl的基本可用数据类型之一。它是用于表示项目的有序集合。它可以包括不同类型的在同一列表的项目。此外，一个列表可以包含另一个列表。

需要注意的一个重要的事情是，列表表示为完全串并处理在需要时，形成的各个项目。所以要避免大的列表，在这种情况下，可使用数组代替。

创建一个列表

列表的一般语法如下。

set listName { item1 item2 item3 .. itemn }
# or
set listName [list item1 item2 item3]
# or
set listName [split "items separated by a character" split_character]

一些例子如下面给出。

#!/usr/bin/tclsh

set colorList1 {red green blue}
set colorList2 [list red green blue]
set colorList3 [split "red_green_blue" _]
puts $colorList1
puts $colorList2
puts $colorList3

当上述代码被执行时，它会产生以下结果。

red green blue
red green blue
red green blue

追加项目到列表

追加项目到列表的语法如下。

append listName split_character value
# or
lappend listName value

一些例子如下面给出。

#!/usr/bin/tclsh

set var orange
append var " " "blue"
lappend var "red"
lappend var "green"
puts $var

当上述代码被执行时，它会产生以下结果。

orange blue red green

列表长度

列表长度的语法如下。

llength listName

例如，列表长度如下例所示。

#!/usr/bin/tclsh

set var {orange blue red green}
puts [llength $var]

当执行上面的代码，产生以下结果：

4

列表索引项

用于选择在指定索引的列表项如下。

lindex listname index

例如，列表索引项目如下所示。

#!/usr/bin/tclsh

set var {orange blue red green}
puts [lindex $var 1]

当执行上面的代码，产生以下结果：

blue

插入索引项目

在列表特定索引插入项目的语法如下。

linsert listname index value1 value2..valuen

例如，在列表特定的索引插入项目如下。

#!/usr/bin/tclsh

set var {orange blue red green}
set var [linsert $var 3 black white]
puts $var

当执行上面的代码，产生以下结果：

orange blue red black white green

更换项目索引

用于替换列表项以特定索引的语法如下。

lreplace listname firstindex lastindex value1 value2..valuen

例如用于替换列表项以特定的索引如下。

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lreplace $var 2 3 black white]
puts $var

当执行上面的代码，产生以下结果：

orange blue black white

设置指数项目

用于设置列表项在特定索引下面的语法给出。

lset listname index value

例如设置列表项的索引具体如下。

#!/usr/bin/tclsh

set var {orange blue red green}
lset var 0 black
puts $var

当执行上面的代码，产生以下结果：

black blue red green

转换列表变量

复制值到变量的语法如下。

lassign listname variable1 variable2.. variablen

例如，用于将列表到变量如下。

#!/usr/bin/tclsh

set var {orange blue red green}
lassign $var colour1 colour2
puts $colour1
puts $colour2

当执行上面的代码，产生以下结果：

orange
blue

排序列表

排序列表的语法如下。

lsort listname

进行列表的排序如下例子。

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lsort $var]
puts $var

当执行上面的代码，产生以下结果：

blue green orange red

TCL字典 - Tcl教程

词典是用于值映射到键的布置。常规字典的语法如下所示。

dict set dictname key value
# or
dict create dictname key1 value1 key2 value2 .. keyn valuen

用于创建字典的一些例子如下所示。

#!/usr/bin/tclsh

dict set colours colour1 red
puts $colours
dict set colours colour2 green
puts $colours

set colours [dict create colour1 "black" colour2 "white"]
puts $colours

当执行上面的代码，产生以下结果：

colour1 red
colour1 red colour2 green
colour1 black colour2 white

字典的大小

用于获取字典的大小语法如下所示。

[dict size dictname]

用于打印的尺寸一个例子如下所示。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
puts [dict size $colours]

当执行上面的代码，产生以下结果：

2

字典迭代

打印键和字典的值一个简单的字典迭代如下图所示。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
foreach item [dict keys $colours] {
set value [dict get $colours $item]
puts $value
}

当执行上面的代码，产生以下结果：

black
white

字典的键值

字典键检索值的语法如下所示。

[dict get $dictname $keyname]

用于键检索值的示例如下面给出。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set value [dict get $colours colour1]
puts $value

当执行上面的代码，产生以下结果：

black

字典中的所有键

用于检索在字典的所有键的语法如下所示。

[dict keys $dictname]

用于打印所有的键一个例子如下所示。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set keys [dict keys $colours]
puts $keys

当执行上面的代码，产生以下结果：

colour1 colour2

字典中的所有值

用于检索在字典中的所有值的语法如下所示。

[dict values $dictname]

用于打印的所有值一个例子如下所示。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set values [dict values $colours]
puts $values

当执行上面的代码，产生以下结果：

black white

关键存在于字典

检查一个键是否存在于字典的语法如下所示。

[dict values $dictname]

用于检查一个键是否存在于字典的一个例子如下所示。

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set result [dict exists $colours colour1]
puts $result

当执行上面的代码，产生以下结果：

1

TCL过程 - Tcl教程

程序是什么，只不过代码块的一系列命令，提供了一个可重复使用的特定功能。它被用于避免相同的代码被重复在多个位置。程序相当于许多编程语言中使用的功能，并提供Tcl proc命令的帮助。

创建一个简单程序的语法如下所示。

proc procedureName {arguments} {
body
}

一个简单程序的例子如下。

#!/usr/bin/tclsh

proc helloWorld {} {
puts "Hello, World!"
}
helloWorld

当执行上面的代码，产生以下结果：

Hello, World!

过程的多个参数

对于程序带参数如下图的例子所示。

#!/usr/bin/tclsh

proc add {a b} {
return [expr $a+$b]
}
puts [add 10 30]

当执行上面的代码，产生以下结果：

40

过程的可变参数

对于程序带参数如下图的例子所示。

#!/usr/bin/tclsh

proc avg {numbers} {
set sum 0
foreach number $numbers {
set sum [expr $sum + $number]
}
set average [expr $sum/[llength $numbers]]
return $average
}
puts [avg {70 80 50 60}]
puts [avg {70 80 50 }]

当执行上面的代码，产生以下结果：

65
66

过程使用默认参数

默认参数是用来提供一种可如果未提供任何参数值时，可以使用默认值。对于程序用其有时称为隐式参数默认参数，一个例子如下所示。

#!/usr/bin/tclsh

proc add {a {b 100} } {
return [expr $a+$b]
}
puts [add 10 30]
puts [add 10]

当执行上面的代码，产生以下结果：

40
110

递归过程

递归过程的示例如下所示。

#!/usr/bin/tclsh

proc factorial {number} {
if {$number <= 1} {
return 1
}
return [expr $number * [factorial [expr $number - 1]]]

}
puts [factorial 3]
puts [factorial 5]

当执行上面的代码，产生以下结果：

6
120

TCL包 - Tcl教程

包用于创建代码的可重用单位。程序包由提供特定功能的文件的集合。文件的这个集合是由包名称标识，可以有多个版本的相同的文件。所述包可以在Tcl脚本，二进制库的集合或两者的组合。

包使用的命名空间的概念来避免变量名和过程名发生冲突。查看更多在我们的下一个命名空间教程。

创建包

包可以以最小的两个文件的帮助下被创建。一个文件包含包代码。另一个文件包含声明包索引文件包。

创建和使用程序包步骤列表如下。

步骤1：创建代码

对于包文件夹内创建代码表示 HelloWorld。该文件可以使用代码命名HelloWorld.tcl，如下所示。

# /Users/rajkumar/Desktop/helloworld/HelloWorld.tcl
# Create the namespace
namespace eval ::HelloWorld {

# Export MyProcedure
namespace export MyProcedure

# My Variables
set version 1.0
set MyDescription "HelloWorld"

# Variable for the path of the script
variable home [file join [pwd] [file dirname [info script]]]

}

# Definition of the procedure MyProcedure
proc ::HelloWorld::MyProcedure {} {
puts $HelloWorld::MyDescription
}

package provide HelloWorld $HelloWorld::version
package require Tcl 8.0

第2步：创建包INDEX

打开tclsh。切换到HelloWorld目录，并使用pkg_mkIndex命令创建索引文件，如下图所示。

% cd /Users/rajkumar/Desktop/helloworld
% pkg_mkIndex . *.tcl

第三步：添加目录到AUTOPATH

使用lappend命令来添加程序包到全局列表如下所示。

% lappend auto_path "/Users/rajkumar/Desktop/helloworld"

步骤4：添加软件包

接下来添加程序包使用程序包编程要求声明如下所示。

% package require HelloWorld 1.0

第5步：调用过程

现在，一切都被设置，可以调用我们的程序如下图所示。

% puts [HelloWorld::MyProcedure]

会得到下面的结果。

HelloWorld

前两个步骤创建软件包。当程序包被创建，可以通过添加最后三个报表如下图所示，使用它在任何Tcl文件。

lappend auto_path "/Users/rajkumar/Desktop/helloworld"
package require HelloWorld 1.0
puts [HelloWorld::MyProcedure]

会得到下面的结果。

HelloWorld

TCL命名空间 - Tcl教程

名称空间是一个容器组标识符，用于组变量和程序。命名空间可从Tcl 8.0版开始使用。引入命名空间之前，有一个全局范围。现在有了命名空间，我们可以分区全局范围。

创建命名空间

使用命名空间命令创建命名空间。一个简单的例子，创建命名空间如下图所示

#!/usr/bin/tclsh

namespace eval MyMath {
# Create a variable inside the namespace
variable myResult
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {
set ::MyMath::myResult [expr $a + $b]
}
MyMath::Add 10 23

puts $::MyMath::myResult

当执行上面的代码，产生以下结果：

33

在上面的程序，可以看到有一个变量myResult和程序Add的一个命名空间。这使得创建变量和程序可根据相同的名称在不同的命名空间。

嵌套的命名空间

TCL允许命名空间的嵌套。一个简单的例子，嵌套的命名空间如下。

#!/usr/bin/tclsh

namespace eval MyMath {
# Create a variable inside the namespace
variable myResult
}

namespace eval extendedMath {
# Create a variable inside the namespace
namespace eval MyMath {
# Create a variable inside the namespace
variable myResult
}
}
set ::MyMath::myResult "test1"
puts $::MyMath::myResult
set ::extendedMath::MyMath::myResult "test2"
puts $::extendedMath::MyMath::myResult

当执行上面的代码，产生以下结果：

test1
test2

导入和导出空间

可以在前面的例子命名空间看到，我们使用了大量的作用范围解决运算符，它们的使用变得更复杂。我们可以通过导入和导出命名空间避免这种情况。下面给出一个例子。

#!/usr/bin/tclsh

namespace eval MyMath {
# Create a variable inside the namespace
variable myResult
namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {
return [expr $a + $b]
}

namespace import MyMath::*
puts [Add 10 30]

当执行上面的代码，产生以下结果：

40

忘记命名空间

可以通过使用forget子删除导入的命名空间。一个简单的例子如下所示。

#!/usr/bin/tclsh

namespace eval MyMath {
# Create a variable inside the namespace
variable myResult
namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {
return [expr $a + $b]
}
namespace import MyMath::*
puts [Add 10 30]
namespace forget MyMath::*

当执行上面的代码，产生以下结果：

40

TCL文件I/O - Tcl教程

TCL支持文件处理使用内置命令，如：open, read, puts, gets 和 close.

一个文件代表了一个字节序列，不要紧，如果它是一个文本文件或二进制文件。

打开文件

TCL使用open命令在Tcl中打开文件。打开文件的语法如下。

open fileName accessMode

在这里，文件名是字符串文字，用它来命名文件名，accessMode可以是以下值之一：

关闭文件

要关闭一个文件，请使用close命令。close 的语法如下。

close fileName

当程序完成使用该文件已被打开的一个程序中的任何文件都必须关闭。在大多数情况下，文件不需要被明确地关闭;它们会自动关闭，当文件对象会自动终止。

写入文件

puts命令用于写入一个打开的文件。

puts $filename "text to write"

一个简单写入文件的例子如下所示。

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test"
close $fp

当上述代码被编译和执行时，它创建根据目录的新文件input.txt（在该程序的工作目录）。

读取文件

以下是简单从文件中读取的命令：

set file_data [read $fp]

读与写一个完整的例子如下所示。

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test"
close $fp
set fp [open "input.txt" r]
set file_data [read $fp]
puts $file_data
close $fp

当上述代码被编译和执行时，它读取在前面的部分创建的文件，并且产生以下结果：

test

下面是另一个例子读取文件，文件一行一行直到结束。

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test\ntest"
close $fp
set fp [open "input.txt" r]

while { [gets $fp data] >= 0 } {
puts $data
}
close $fp

当上述代码被编译和执行时，它读取在前面的部分来创建的文件，并且产生以下结果：

test
test

TCL错误处理 - Tcl教程

Tcl的错误处理设置有error 和 catch命令。对每个这些命令语法如下所示。

Error 语法

error message info code

在上面的 error命令语法，message是错误信息，info是在全局变量errorInfo中设置，code是在errorCode设置的全局变量。

Catch 语法

catch script resultVarName

另外，在上述catch 命令语法，脚本是要执行的代码，resultVarName是可变保存错误或结果。 catch命令返回0，如果没有错误，如果有一个错误，返回1。

对于简单的错误处理一个例子如下所示。

#!/usr/bin/tclsh

proc Div {a b} {
if {$b == 0} {
error "Error generated by error" "Info String for error" 401
} else {
return [expr $a/$b]
}
}
if {[catch {puts "Result = [Div 10 0]"} errmsg]} {
puts "ErrorMsg: $errmsg"
puts "ErrorCode: $errorCode"
puts "ErrorInfo:\n$errorInfo\n"
}

if {[catch {puts "Result = [Div 10 2]"} errmsg]} {
puts "ErrorMsg: $errmsg"
puts "ErrorCode: $errorCode"
puts "ErrorInfo:\n$errorInfo\n"
}

当执行上面的代码，产生以下结果：

ErrorMsg: Error generated by error
ErrorCode: 401
ErrorInfo:
Info String for error
(procedure "Div" line 1)
invoked from within
"Div 10 0"

Result = 5

正如在上面的例子中看到，我们可以创建自己的自定义错误消息。同样地，也能够捕捉由Tcl所产生的错误。一个例子如下所示。

#!/usr/bin/tclsh

catch {set file [open myNonexistingfile.txt]} result
puts "ErrorMsg: $result"
puts "ErrorCode: $errorCode"
puts "ErrorInfo:\n$errorInfo\n"

当执行上面的代码，产生以下结果：

ErrorMsg: couldn't open "myNonexistingfile.txt": no such file or directory
ErrorCode: POSIX ENOENT {no such file or directory}
ErrorInfo:
couldn't open "myNonexistingfile.txt": no such file or directory
while executing
"open myNonexistingfile.txt"

TCL内置函数 - Tcl教程

Tcl提供了一些内置的功能(程序)，用于各种操作。这包括，

• 列表处理函数。
• 字符串处理函数。
• 数组处理函数。
• 字典处理函数。
• 文件I/O处理函数。
• 命名空间和包处理函数。
• 数学处理函数。
• 操作系统处理函数。

数学和系统函数以外的都包含在前面的章节。数学与系统内置函数说明如下。

数学函数

Tcl的数学函数可列于下表中。

使用数学函数的一些例子如下。

#!/usr/bin/tclsh

namespace import ::tcl::mathfunc::*
puts [tan 10]
puts [pow 10 2]
puts [ceil 10.34]
puts [hypot 10 20]
puts [srand 45]
puts [log 10]
puts [srand 45]

当执行上面的代码，它产生了以下结果。

0.6483608274590866
100.0
11.0
22.360679774997898
0.0003521866166741525
2.302585092994046
0.0003521866166741525

系统函数

在Tcl中包含重要的系统函数如下，

• clock - 秒函数返回当前时间以秒为单位。
• clock - 格式化函数格式化秒到的日期和时间。
• clock - 扫描函数扫描输入字符串，并将其转换为秒。
• open - 函数用于打开一个文件。
• exec - 函数用于执行一个系统命令。
• close - 函数用于关闭一个文件。

对于上述函数的一些实例在下面列出。

#!/usr/bin/tclsh

#get seconds
set currentTime [clock seconds]
puts $currentTime
#get format
puts "The time is: [clock format $currentTime -format %H:%M:%S]"
puts "The date is: [clock format $currentTime -format %D]"

set date "Jun 15, 2014"
puts [clock scan $date -format {%b %d, %Y}]

puts [exec ls]
puts [exec dir]

set a [open input.txt]
puts [read $a];
puts $a
close $a

当执行上面的代码，产生以下结果：

1402819756
The time is: 03:09:16
The date is: 06/15/2014
1402808400
input.txt
main.tcl
input.txt main.tcl
This is the file you can use to provide input to your program and later on open it inside your program to process the input.

file3

下表提供了可用于格式化的日期和时间的列表字符串。

TCL正则表达式 - Tcl教程

Tcl所述“正则表达式”命令用于匹配正则表达式中使用。正则表达式是一个字符序列，它包含一个搜索模式。它由多个规则如下面的表格解释了这些规则和相应的使用。

语法

正则表达式的语法如下。

regexp optionalSwitches patterns searchString fullMatch subMatch1 ... subMatchn

这里，正则表达式是命令。我们将看到有关可选开关后。模式是如前面提到的规则。搜索字符串是其进行的正则表达式的实际字符串。精确匹配任何可变持有的正则表达式匹配结果的结果。 Submatch1到SubMatchn是持有次级匹配模式的结果可选的子变量。

在深入复杂的之前，让我们来看看一些简单的例子。一个字符串中的任何字母。当任何字符遇到正则表达式的搜索时将被停止，并返回。

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*)} "Tcl Tutorial" a b
puts "Full Match: $a"
puts "Sub Match1: $b"

当执行上面的代码，产生以下结果：

Full Match: Tcl
Sub Match1: Tcl

多种模式

下面的例子演示了如何搜索多个模式。这是任意字符后跟任何字母的任何字的母模式例子。

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*).([A-Z,a-z]*)} "Tcl Tutorial" a b c
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

当执行上面的代码，产生以下结果：

Full Match: Tcl Tutorial
Sub Match1: Tcl
Sub Match2: Tutorial

上面的代码修改版本，以表明一个子模式可以包含多个模式如下所示。

#!/usr/bin/tclsh

regexp {([A-Z,a-z]*.([A-Z,a-z]*))} "Tcl Tutorial" a b c
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

当执行上面的代码，产生以下结果：

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

选择正则表达式的命令

选择在Tcl中提供的列表是，

• -nocase : 用于忽略大小写。
• -indices : 匹配的子模式，而不是匹配的字符存储的位置。
• -line : 新行敏感匹配。换行后忽略字符。
• -start index : 搜索模式开始设置偏移
• -- : 标志着开关的结束

在上面的例子中，特意用[AZ,az]所有字母，可以使用-nocase代替，如下图所示。

#!/usr/bin/tclsh

regexp -nocase {([A-Z]*.([A-Z]*))} "Tcl Tutorial" a b c
puts "Full Match: $a"
puts "Sub Match1: $b"
puts "Sub Match2: $c"

当执行上面的代码，产生以下结果：

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

使用选择的另一个例子如下所示。

#!/usr/bin/tclsh

regexp -nocase -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b
puts "Full Match: $a"
puts "Sub Match1: $b"
regexp -nocase -start 4 -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b
puts "Full Match: $a"
puts "Sub Match1: $b"

当执行上面的代码，产生以下结果：

Full Match: Tcl
Sub Match1: Tcl
Full Match: Tutorial
Sub Match1: Tutorial