认 识 TCL (二 )

■ 李 俊 宏

　

还 记 得 上 期 介 绍 的 一 些 指 令 ？ 忘 了 话 ， 请 翻 翻 上 期 的 文 章 看 看 ， 这 期 继 续 上 期 未 完 的 部 分 。

　

foreach命 令
读 者 可 能 从 来 不 曾 在 C语 言 中 看 到 像 foreach这 样 的 命 令 ， 不 过 ， foreach在 读 者 想 要 对 一 系 列 的 值 进 行 某 些 动 作 的 时 候 十 分 有 用 。 读 者 可 以 将 一 系 列 的 数 字 透 过 foreach命 令 加 起 来 。 如 A所 示 ：

A
set sum 0
foreach i{1 2 3 4 5 6 7 8 9 10}{
set sum [expr $sum ＋ $i]
}
puts “ um=$sum”

如 果 读 者 有 一 系 列 的 值 放 在 一 个 变 数 中 ， 可 以 使 用 该 变 数 来 取 代 在 第 一 个 大 括 号 中 所 放 的 值 。 下 面 的 范 例 会 将 一 系 列 的 字 串 显 示 出 来 。 如 B：

B
set user “ oot ibm”
foreach user$users{
puts “ user”
}

　

　

switch命 令
TCL的 switch命 令 跟 C语 言 的 switch叙 述 不 太 一 样 。 C语 言 的 switch是 计 算 一 个 表 示 式 的 值 ， 并 比 较 该 值 ， 来 决 定 要 如 何 执 行 命 令 。 TCL的 switch命 令 则 是 透 过 一 系 列 的 pattern来 比 较 字 串 後 决 定 如 何 执 行 命 令 。 通 常 的 情 况 下 ， pattern是 由 正 规 表 示 式 （ regular expression） 所 写 成 的 。 下 面 的 命 令 展 示 了 switch命 令 的 语 法 以 及 一 般 的 用 途 。 如 C：

#!/usr/bin/tclsh
#This script reads commands from the user dnd #Processes
#the cnmmands using a switch statement

set prompt ?? enter command (\"quit\"to exit): ? puts nonewline ? prompt? while{[gets stdin cmd]!=-1}{
switch -exact ? cmd{
quit{puts ?? ye? ;exit}
start{puts ?? tarted茜
stop{puts ?? topped茜
draw{puts ?? raw...茜
default{puts ?? o Command:$cmd茜
}
#prompt user again
puts nonewline ? prompt? }
?
下 面 是 由 上 面 这 些 命 令 所 产 生 的 一 个 简 单 的 对 话 。 如 D：

D
Enter command (“ uit” to exit):help
No Command:help
Enter command (“ uit” to exit):start
Started
Enter command (“ uit” to exit):stop
Stopped
Enter command (“ uit” to exit):quit
Bye

就 如 同 这 个 范 例

所 展 示 的 ， switch命 令 让 读 者 可 以 使 用 一 个 字 串 跟 其 他 字 串 做 比 较 ， 然 後 根 据 比 较 的 结 果 来 执 行 对 应 的 命 令 。 在 这 个 范 例 ， 这 个 字 串 就 是 $cmd（ 根 据 使 用 者 所 输 入 的 字 串 来 决 定 其 值 ） 用 来 比 较 的 pattern字 串 有 ： quit、 start、 stop， 及 draw。 下 面 是 一 个 完 全 符 合 （ exact match） 的 范 例 ， 在 switch命 令 後 加 上 -exact的 参 数 ：

switch -exact--$cmd{
.....
}

在 -exact这 个 flag後 面 的 两 个 减 号 （ --） 是 用 来 表 示 flag到 这 边 结 束 。 当 读 者 使 用 switch的 命 令 时 ， 读 者 应 该 要 使 用 两 个 减 号 来 标 明 flag到 什 麽 地 方 结 束 ， 以 避 免 flag跟 要 比 较 的 字 串 混 淆 的 情 况 发 生 。 读 者 可 以 使 用 -regexp的 flag来 使 用 正 规 表 示 式 做 为 比 较 的 方 式 。 请 看 下 面 的 范 例 。 如 E：

E
#Assume that $cmd is the string to be matched
switch -regrep? cmd{
^q.* {puts ?? ye? ;exit}
^x.* {puts ?? omething x...茜
^y.* {puts ?? omething y...茜
^z.* {puts ?? omething z...茜
default {puts Unknown Command:$cmd茜
}

　

以 上 范 例 中 ， 所 有 的 正 规 表 示 式 都 具 有 类 似 的 格 式 。 ^z.*这 个 Pattern所 代 表 的 意 义 是 所 有 以 Z为 开 头 的 字 串 。
TCL的 程 序 （ Procedure）
读 者 可 以 使 用 proc的 命 令 来 加 入 自 己 的 命 令 。 这 种 命 令 称 之 为 程 序 。 TCL直 译 器 会 把 它 们 视 为 一 般 的 TCL内 建 命 令 。 下 面 的 范 例 展 示 了 在 TCL下 面 写 一 个 程 序 是 一 件 非 常 简 单 的 事 情 。 如 F：

F
#!/usr/bin/tclsh
proc total items{
set sum 0
foreach i $items{
set sum [espr $sum+$i]
}
return$sum
}
set counts ? 4 3 5? puts ?? otal=[total$counts]?
Total=17(当 执 行 到 script後 ， 会 印 出 结 果 )

在 这 个 范 例 中 ， 此 程 序 的 名 称 叫 做 total， 它 会 使 用 一 系 列 的 数 字 来 做 为 参 数 。 这 个 程 序 会 使 用 一 个 名 为 items的 变 数 来 接 受 这 些 参 数 。 程 序 本 身 会 解 开 每 个 项 目 ， 然 後 传 回 所 有 项 目 的 总 和 。 因 此 ， 如 果 读 者 要 计 算 1到 10的 总 和 ， 读 者 可 以 使 用 下 面 的 方 式 来 呼 叫 total这 个 程 序 ：
set sum_10[total{1 2 3 4 5 6 7 8 9 10}]

在 一 个 TCL程 序 中 ， 名 为 args的 参 数 具 有 特 别 的 功 用 ； 如 果 读 者 使 用 args作 为 一 个 参 数 的 名 称 ， 读 者 可 以 传 入 参 数 数 目 的 数 字 到 自 己 的 程 序 中 。 如 果 读 者 将 前 面 的 total程 序 的 参 数 名 称 由 itcm改 成 args， 就 可 以 使 用 下 面 的 方 式 来 呼 叫 total程 序 ：
set sum_10[total 1 2 3 4 5 6 7 8 9 10]

如 果 读 者 想 要 存 取 全 域 变 数 （ 一 种 定 义 在 程 序 之 外 的 变 数 ） 读 者 可 以 在 程 序 中 使 用 global命 令 。 global这 个 命 令 会 使 一 个 全 域 变 数 可 以 在 这 个 程 序 中 被 看 见 。 举 例 来 说 ， 有 一 个 TK程 式 中 名 为 theCanvas的 变 数 ， 它 存 放 了 一 个 目 前 绘 图 区 域 ， 如 果 有 一 个 程 序 想 要 使 用 这 个 变 数 ， 它 必 须 在 程 序 中 使 用 下 面 的 命 令 ：

　

glohal theCanvas内 建 的 TCL命 令
在 前 面 的 范 例 中 ， 读 者 已 经 看 到 了 很 多 的 TCL命 令 。 读 者 应 该 知 道 何 种 的 命 令 可 以 在 何 时 使 用 在 TCL中 ， 这 种 认 知 可 以 帮 助 读 者 决 定 何 种 命 令 适 合 读 者 目 前 所 做 的 工 作 。 虽 然 本 文 没 有 足 够 的 空 间 可 以 介 绍 所 有 的 TCL命 令 ， 笔 者 还 是 对 TCL命 令 做 了 一 个 摘 要 。 如 果 读 者 想 要 取 得 这 些 命 令 的 线 上 说 明 ， 可 以 键 入 man 3， 然 後 後 面 接 上 想 要 知 道 的 命 令 名 称 即 可 。 举 例 来 说 ， 如 果 读 者 想 要 知 道 file命 令 的 线 上 说 明 ， 只 需 键 入 man 3 file即 可 。 以 下 是 笔 者 所 列 出 的 TCL内 建 命 令 。 (表 格 一 请 参 考 文 後 )

　

在 TCL中 的 字 串 操 作
如 果 读 者 已 经 浏 览 过 了 上 面 所 列 出 的 TCL命 令 ， 读 者 应 该 学 会 一 些 TCL命 令 ， 像 是 append、 join、 split、 string、 regexp及 regsub等 操 作 字 串 命 令 。 然 而 当 读 者 设 定 一 个 字 串 到 变 数 中 ， TCL直 译 器 会 把 整 个 字 串 当 作 一 个 单 一 的 实 体 。 就 算 读 者 的 字 串 中 有 很 多 的 空 白 字 元 在 里 面 ， 仍 旧 会 被 视 为 单 一 的 实 体 。
有 时 读 者 可 能 会 想 要 把 字 串 当 成 一 个 由 很 多 项 目 组 成 的 list。 split可 以 为 读 者 达 到 这 个 目 的 ， 它 可 以 将 字 串 分 为 很 多 元 素 。 举 例 来 说 ， 下 面 是 在 /etc/passwd中 的 某 行 ：

　

root:OZfp3JpH.JhfY:0:0:root:/root:/bin/tcsh

　

这 行 是 由 冒 号 （ ： ） 所 分 开 的 栏 位 所 组 成 的 。 假 设 读 者 现 在 要 从 每 行 中 取 出 第 一 个 栏 位 （ 因 为 这 个 栏 位 放 的 是 使 用 者 帐 号 ） 读 者 应 该 要 一 次 读 入 一 行 ， 将 每 行 分 成 list， 然 後 取 得 第 一 个 栏 位 的 资 料 （ 此 栏 位 的 索 引 值 为 0） 。 下 面 的 script就 是 要 达 到 此 目 的 。 如 G：

G
#!/usr/bin/tclsh
set fid [open ? etc/passwd? r] ;#Open password file
while{[gets $fid line]!=-1}{
set filed[split $line ? ?? ;#This command split into a list
#Just print out the first field
puts [lindex $fields 0] ;lindex extreacts as a specified index
}

当 读 者 执 行 这 个 命 令 时 ， 它 会 将 系 统 的 /etc/passwd档 案 中 的 login帐 号 列 出 。 join命 令 跟 split命 令 刚 好 相 反 ； 读 者 可 以 将 一 个 list中 的 项 目 组 合 成 为 一 个 字 串 。 假 设 读 者 做 出 下 面 的 这 个 list， 里 面 有 六 个 项 目 ， 定 义 如 下 ：

　

set x {1 2 3 4 5 6}

当 读 者 想 要 组 合 这 些 元 素 的 时 候 ， 可 以 选 择 自 己 要 作 为 间 隔 的 字 元 。 如 果 读 者 想 要 将 所 有 的 元 素 组 合 起 来 ， 且 中 间 不 放 入 任 何 间 隔 字 元 ， 应 该 要 使 用 下 面 的 格 式 ：

　

set y [join $x “ ” ]

现 在 ， y这 个 变 数 的 内 容 就 是 ” l23456” 。
string这 个 命 令 其 实 是 一 群 用 来 处 理 字 串 的 命 令 ， 因 此 string命 令 的 第 一 个 参 数 是 用 来 指 定 要 对 字 串 进 行 何 种 动 作 。 举 例 来 说 ， string compare命 令 是 用 来 比 较 两 个 字 串 。 如 果 两 个 字 串 是 相 同 的 ， string compare这 个 命 令 就 会 传 回 零 。 如 果 在 字 汇 的 比 较 上 ， 第 一 个 字 串 比 第 二 个 字 串 小 的 话 ， 也 就 是 说 ， 第 一 个 字 串 在 字 典 中 会 比 第 二 个 字 串 早 出 现 ， 此 时 这 个 命 令 就 会 传 回 1。 同 样 地 ， 如 果 第 一 个 字 串 在 字 汇 上 的 比 较 是 比 第 二 个 字 串 大 的 话 ， 则 本 命 令 也 会 传 回 1。 因 此 ， 读 者 可 以 将 string compare的 命 令 与 if的 命 令 合 在 一 起 使 用 ， 如 下 所 示 。 如 H：

H
if{[string compare $command ?? uit?? ==0}{
puts ?? xitlng...?
exit 0
}

　

在 string命 令 中 所 使 用 的 字 串 操 作

　

表 格 二 ：

string	命 令 描 述
string compare string1 string2	在 比 较 字 串 後 ， 传 回 -1， 0， 1等 值
string first string1 string2	传 回 在 string2中 的 一 个 出 现 的 string1 index 的 值
string index string charlndex	传 回 在 charlndex所 指 定 索 引 值 的 字 元
string last string1 string2	传 回 在 string2中 最 後 一 个 出 现 的 string1的 index值
string length string	传 回 string的 长 度
string match pattern string	如 果 string能 够 符 合 pattern的 话 ， 就 传 回 1， 否 则 传 回 0
string range string first last	传 回 在 string中 字 元 的 范 围
string tolower string	将 string的 字 元 变 小 後 传 回
string toupper string	将 string的 字 元 变 大 後 传 回
string trim string chars	传 回 经 过 修 整 前 面 或 是 後 面 字 元 的 字 串
string trimleft string chars	传 回 经 过 修 整 左 边 字 元 的 字 串
string trimrigh string chars	传 回 经 过 修 整 右 边 字 元 的 字 串

　

阵 列 （ Arrays）

在 TCL中 ， 阵 列 就 是 一 个 可 以 更 改 的 字 串 索 引 。 一 个 阵 列 包 含 了 许 多 的 元 素 ； 每 个 元 素 的 字 串 索 引 ， 我 们 称 为 元 素 名 称 （ element name） 。 换 句 话 说 ， 读 者 可 以 使 用 这 个 名 称 来 存 取 一 个 阵 列 里 面 的 元 素 。 在 内 部 上 ， TCL是 使 用 一 种 很 有 效 率 的 资 料 结 构 来 完 成 阵 列 。 这 种 资 料 结 构 也 就 是 大 家 都 知 道 的 hash table。 透 过 这 种 方 式 ， TCL可 以 很 迅 速 的 搜 寻 阵 列 中 的 元 素 。 因 此 ， 读 者 可 以 使 用 set命 令 来 宣 告 一 个 阵 列 。 下 面 的 范 例 ， 就 是 展 示 出 如 何 定 义 一 个 名 为 HD_data阵 列 ， 这 个 阵 列 是 用 来 记 录 每 个 使 用 者 的 硬 碟 空 间 使 用 量 ：

　

set HD_data(root) 147778
set HD_data(ibm) 35478
set HD_data(henry) 3394
set HD_data(apin) 44472
set HD_data(skytree) 77884

　

当 读 者 定 义 好 这 个 阵 列 之 後 ， 读 者 可 以 透 过 元 素 名 称 来 存 取 元 素 。 如 下 面 的 范 例 所 示 ：

　

set user “ ibm”
puts HD space used by $user=HD_data($user)K”

　

环 境 变 数 （ environment variables）

境 变 数 阵 列 ， 这 个 阵 列 叫 做 env。 读 者 可 以 将 环 境 变 数 的 名 称 当 成 元 素 名 称 来 使 用 。 换 句 话 说 ， 读 者 可 以 使 用 变 数 名 称 当 做 索 引 存 取 读 者 想 要 存 取 的 变 数 。 下 面 的 命 令 会 印 出 PATH环 境 变 数 的 内 容 ：
读 者 可 以 以 操 作 一 般 的 变 数 的 方 式 来 操 作 环 境 变 数 阵 列 。 举 例 来 说 ， 读 者 可 以 使 用 下 面 的 命 令 加 入 一 个 新 的 目 录 到 PATH中 ：

　

set env(PATH): “ $env(PATH):/usr/sbin”

这 里 需 要 注 意 的 是 ， 环 境 变 数 的 任 何 修 改 都 不 会 影 响 到 原 始 行 程 （ 举 例 来 说 ， 读 者 用 来 启 动 TCL script的 shell就 是 TCL script原 始 行 程 ） 的 环 境 变 数 的 内 容 。 任 何 使 用 exec命 令 所 建 立 出 来 的 script行 程 ， 将 会 继 承 修 改 过 後 的 所 有 环 境 变 数 。

　

TCL的 档 案 处 理
大 部 份 在 本 文 所 用 到 显 示 字 串 的 范 例 都 是 使 用 TCL的 puts命 令 。 在 预 设 的 情 况 之 下 ， puts会 写 入 资 料 到 标 准 输 出 中 ： 当 读 者 使 用 X window的 时 候 ， xterm视 窗 就 是 读 者 的 标 准 输 出 。 读 者 也 可 以 选 择 以 一 个 档 案 识 别 码 作 为 puts命 令 的 第 一 个 参 数 来 将 资 料 ?? 入 到 档 案 中 。 要 取 得 一 个 档 案 识 别 码 ， 读 者 需 要 先 使 用 TCL的 open命 令 开 启 一 个 档 案 。 下 面 的 命 令 告 诉 读 者 怎 样 开 启 一 个 档 案 ， 然 後 写 入 一 行 的 文 字 到 档 案 中 ， 最 後 再 把 它 关 起 来 ：

　

set fid [open “ testfile” w] ;#open file
named testfile
puts $fid “ TEsting 1..2..3” ;#use file ID
close $fid ;#close the file

当 读 者 在 使 用 puts的 命 令 将 字 串 放 到 标 准 输 出 的 时 候 ， 不 需 要 给 它 档 案 识 别 码 。 同 时 ， phts也 会 自 动 换 行 。 如 果 不 希 望 puts命 令 为 读 者 换 行 ， 可 以 使 用 -nonewline的 参 数 。 请 看 下 面 的 范 例 ：

puts． -nonewline “ Command$” ;#nonewline
is good for command

在 puts命 令 後 面 加 上 -nonewline的 参 数 可 以 用 来 在 读 者 的 TCL script中 显 示 命 令 提 示 符 号 。 读 者 可 能 也 看 过 了 使 用 gets的 命 令 来 从 标 准 输 入 中 读 取 一 行 资 料 。 下 面 的 范 例 会 从 标 准 输 入 中 读 取 一 行 的 资 料 （ 当 按 下 Enter的 时 候 ， 命 令 就 会 传 回 ） ：

　

set line [get stdin] ;#read a line of into line
variable

这 个 事 先 经 过 定 义 的 档 案 识 别 码 stdin， 是 代 表 标 准 输 入 ， 也 就 是 指 读 者 的 键 盘 输 入 。 另 外 一 个 事 先 定 义 的 档 案 识 别 码 就 是 stdout， 代 表 标 准 输 出 设 备 。 还 有 一 个 就 是 stderr， 代 表 标 准 错 误 输 出 设 备 。 在 预 设 的 情 况 下 ， stdout及 stderr， 都 是 输 出 到 萤 幕 上 面 。 下 面 有 几 种 方 式 用 以 呼 叫 gets命 令 来 读 取 一 行 资 料 到 一 个 名 为 line的 变 数 中 ：

　

gets stdin line;#read a line of inout into the
line variable

如 果 要 从 另 外 一 个 档 案 来 读 取 资 料 ， 读 者 要 先 开 启 一 个 档 案 并 取 得 档 案 识 别 码 ， 然 後 使 用 gets命 令 现 在 档 案 识 别 码 作 为 参 数 。 举 例 来 说 ， 如 果 要 读 入 所 有 /etc/passwd中 的 内 容 ， 并 将 它 们 显 示 在 标 准 输 出 设 备 上 面 的 话 ， 读 者 应 该 使 用 下 面 的 方 式 。 如 I：

I
set fpass[open ? etc/passwd? r] ;#open /etc/passwd
while{gets $fpass line]!=-1}{ ;#read lines in a while loop
puts $line ;#and print each line
}

gets命 令 很 适 合 用 来 读 取 文 字 档 案 ， 因 为 它 一 次 处 理 一 行 ； 事 实 上 ， 它 是 找 换 行 字 元 来 作 为 一 行 结 束 的 认 定 。 如 果 读 者 想 要 读 取 一 个 binary file， 像 是 图 档 。 应 该 使 用 read命 令 取 代 gets。 例 如 ， 如 果 想 要 读 取 2048-byte的 资 料 ， 可 以 使 用 下 面 的 命 令 。 如 J：

　

J
#Assume fid is the file ID of an open file
while{![eof $fid]}{ ;Until end-of-line is reached
set buffer[read $fid 2048] ;read up to 2048 bytes into buffer
#process the data in buffer ;#process the buffer
}

read这 个 命 令 中 的 第 二 个 参 数 是 用 来 指 定 所 要 读 取 的 最 大 byte数 。 如 果 读 者 不 指 定 这 个 参 数 ， read命 令 会 将 整 个 档 案 读 进 来 。 读 者 可 以 使 用 这 种 特 性 来 处 理 整 个 档 案 。 当 读 者 读 入 档 案 内 容 之 後 ， 其 他 命 令 可 以 帮 助 读 者 将 输 入 的 资 料 分 成 一 行 一 行 的 文 字 。 请 看 下 面 的 范 例 。 如 K：
如 果 读 者 想 要 一 次 处 理 数 个 档 案 （ 像 是 所 有 副 档 名 为 .tcl的 档 案 ） 使 用 glob这 个 命 令 可 以 帮 助 读 者 扩 展 档 名 （ 如 *.tcl） 到 一 个 list中 。 然 後 ， 就 可 以 使 用 open命 令 来 开 启 并 且 处 理 每 个 档 案 了 ， 请 看 下 面 的 方 法 。 如 L：

K
set fid[open ? etc/passwd? r] ;#open file for reading
set buffer [read $fid 100000] ;#read entire file into buffer
split $buffer 涂 n? ;#slipt buffer into lines
foreach line $buffer{
puts $lines ;#do whatever you want with each line
}

L
oreach filename[glob *.tcl]{ ;# create a list of filename
puts -nonewline $filename ;# dlsplay the filename
set file[open $filename r] ;#open the file
gets $file line ;#read the first line
puts $line ;#print it(this is only for testing)
#process rest of the file as nescessary
close $file ;#close the file
}

　

　

执 行 Linux命 令
为 了 避 免 复 制 大 量 Linux命 令 的 情 况 ， TCL提 供 了 让 读 者 可 以 执 行 任 何 Linux命 令 的 机 制 。 如 果 读 者 已 经 学 会 了 使 用 Linux的 命 令 ， 就 可 以 直 接 在 TCL script中 使 用 它 们 。 在 TCL script中 ， 读 者 可 以 使 用 exec命 令 来 执 行 Linux命 令 。 在 最 简 单 的 情 况 下 ， 读 者 使 用 一 个 Linux命 令 来 做 为 exec命 令 的 参 数 。 举 例 来 说 ， 如 果 读 者 要 显 示 目 前 所 在 目 录 的 档 案 列 表 ， 可 以 使 用 下 面 的 方 式 ：
exec ls

结 果 会 显 示 在 标 准 输 出 上 面 ， 跟 在 shell的 提 示 号 下 面 执 行 ls命 令 的 结 果 一 样 。 当 读 者 在 shell下 面 使 用 Linux命 令 ， 可 以 透 过 一 个 特 别 的 字 元 将 输 入 及 输 出 重 新 导 向 ， 像 是 ＜ （ 将 输 入 重 新 导 向 ） ， ＞ （ 将 输 出 重 新 导 向 ） ， 以 及 ｜ （ pipe） 。 这 些 字 元 在 TCL中 也 可 以 正 常 的 工 作 。 因 为 exec命 令 本 身 就 是 一 个 完 整 的 命 令 列 ， 可 以 接 受 任 何 的 输 入 或 是 输 出 的 导 向 。 因 此 ， 读 者 可 以 将 目 录 列 表 的 结 果 送 到 一 个 名 为 dirlist的 档 案 中 。 就 像 下 面 的 范 例 这 样 ：

　

exec ls $ dirlist

TCL的 exec命 令 并 不 会 去 扩 展 万 用 字 元 （ 像 是 星 号 ） 。 如 果 读 者 想 在 档 名 中 使 用 万 用 字 元 ， 需 要 做 下 面 几 个 步 骤 ： 必 须 先 使 用 glob命 令 来 扩 展 万 用 字 元 。 然 後 将 整 个 exec命 令 当 做 eval命 令 的 参 数 。 举 例 来 说 ， 如 果 读 者 想 要 看 到 所 有 副 档 名 为 *.tcl的 档 案 列 表 ， 可 以 使 用 下 面 的 方 式 ：

　

eval exec ls [glob *.tcl] ;#this is equivalent
to Linux
#command “ ls *.tcl”

相 信 介 绍 到 这 里 ， 一 定 有 许 多 人 会 有 信 心 去 撰 写 TCL script了 吧 ！ 相 信 一 定 也 会 有 许 多 人 很 想 知 道 另 一 个 script， 也 就 是 TK script的 写 法 ， 留 到 下 一 期 的 Linux专 栏 再 出 了 ， 这 一 期 就 让 笔 者 先 行 偷 懒 一 下 吧 ！ (作 者 E-Mail： s841084@moon.yzu.edu.tw)

表 格 一 ：

　

命 令	动 作
append	将 参 数 加 入 变 数 中
arrey	对 一 个 阵 列 的 变 数 进 行 不 同 的 运 算
break	离 开 一 个 回 圈
catch	执 行 一 个 script， 然 後 让 TCL直 译 器 进 行 错 误 追 踪
cd	改 变 目 前 所 在 的 目 录
close	关 闭 档 案
concat	将 两 以 上 的 列 表 合 成 一 个 列 表
continue	忽 略 一 个 回 圈 所 剩 下 的 命 令
eof	检 查 档 案 是 否 结 束
error	产 生 一 个 错 误
eval	将 列 表 串 连 在 一 起 ， 然 後 将 结 果 当 成 TCL script 来 计 算
exec	开 始 另 一 个 行 程 来 执 行 参 数 所 指 定 的 命 令
exit	结 束 目 前 这 一 个 TCL script
expr	计 算 一 个 表 示 式
file	检 查 一 个 档 名 及 属 性
flush	清 除 缓 冲 区 内 的 资 料 到 档 案 中
for	回 圈
foreach	对 每 个 指 定 的 项 目 做 特 定 的 动 作
format	将 一 个 输 出 格 式 化 ， 然 後 放 到 一 个 字 串 中
gets	从 一 个 档 案 中 读 取 一 行
glob	传 回 符 合 指 定 的 pattern的 档 案 名 称 。 （ 如 *.tcl）
global	存 取 全 域 变 数 的 内 容
history	提 供 存 取 history list的 功 能
if	测 试 一 个 表 示 式 ， 如 果 这 个 表 示 式 为 真 的 话 ， 就 执 行 指 定 的 命 令
incr	增 加 指 定 的 变 数 的 值
info	传 回 TCL直 译 器 的 内 部 资 讯
join	将 一 个 list中 所 有 的 项 目 合 起 来 成 为 一 个 字 串
lappend	加 入 一 个 项 目 到 Iist中
lindex	透 过 一 个 索 引 值 ， 传 回 指 定 list中 的 某 个 项 目
linsert	插 入 一 个 项 目 到 指 定 的 索 引 值 之 前 的 位 置
list	建 立 一 个 由 指 定 的 参 数 所 组 成 的 list
llength	传 回 一 个 list的 元 素 的 个 数
lrange	传 回 指 定 的 list某 个 范 围 内 的 元 素
lreplce	使 用 新 的 元 素 取 代 一 个 list中 的 元 素
lsearch	在 一 个 list中 寻 找 某 个 元 素
lsort	将 一 个 list以 指 定 的 顺 序 来 进 行 排 序
open	开 启 一 个 档 案 ， 并 且 传 回 识 别 码
pid	取 得 行 程 的 识 别 码
proc	定 义 一 个 TCL程 序
puts	将 字 元 送 到 一 个 档 案 中
pwd	传 回 日 前 的 工 作 目 录
read	从 一 个 档 案 中 读 入 指 定 数 目 的 资 料 （ 也 可 以 读 入 整 个 档 案 ）
regexp	查 看 一 个 正 规 表 示 式 与 字 串 是 否 相 符
regsub	将 一 个 正 规 表 示 式 所 指 定 的 pattern取 代 成 为 其 他 的 字 串
rename	更 改 名 称 或 是 删 除 某 个 命 令
return	从 一 个 TCL程 序 传 回 一 个 值
scan	解 析 一 个 字 串 ， 使 用 与 C语 言 相 同 的 sscanf相 同 的 格 式
seek	变 更 一 个 已 经 开 始 的 档 案 的 存 取 位 置
set	设 定 一 个 变 数 的 值 ， 或 是 传 回 它 的 值
source	读 入 一 个 档 案 并 把 它 当 做 一 个 TCL script来 做 处 理
split	打 断 一 个 字 串 到 一 个 TCL的 list中
string	对 一 个 字 串 进 行 各 种 的 处 理
switch	根 据 指 定 的 字 串 来 决 定 要 处 理 的 区 块 中 的 命 令
tell	传 回 一 个 已 经 开 启 的 档 案 的 存 取 位 置
time	传 回 执 行 一 个 script所 需 的 时 间
trace	当 一 个 变 数 被 存 取 的 时 候 ， 就 执 行 指 定 的 TCL命 令
unknown	处 理 任 何 无 法 辨 识 的 命 令 （ TCL直 译 器 会 在 遇 到 无 法 辨 识 的 命 令 的 时 候 ， 执 行 这 个 命 令 ）
unset	删 除 一 个 或 多 个 变 数 的 定 义
uplevel	在 另 一 个 不 同 的 context执 行 一 个 script
upvar	参 考 一 个 在 程 序 之 外 的 变 数 （ 本 命 令 可 以 用 来 完 成 pass-by-refererce的 程 序 呼 叫 ， 可 以 在 更 改 程 序 内 变 数 的 同 时 ， 一 并 更 改 对 外 部 对 应 的 参 数