Tcl脚本语言入门与Tk Toolkit深度解析

需积分: 9 133 浏览量更新于2024-07-22 收藏 316KB PDF 举报

Tcl脚本语言是一本由John K. Ousterhout撰写的专业书籍，它属于计算机科学与电气工程领域的教育资源，特别是对于软件工程和电子工程专业人士来说，具有很高的实用价值。这本书作为1993年Addison-Wesley出版社的作品，版权受到保护，允许个人进行个人使用，但任何形式的大规模复制或商业使用都需要事先获得作者或出版商的书面许可。本书的核心内容涵盖了Tcl（Tool Command Language）和Tk（Tkinter）工具包的深入讲解。Tcl是一种解释型、脚本式编程语言，以其简洁易学、强大灵活的特点而受到欢迎，尤其适用于快速原型开发和自动化任务。Tk则是Tcl的一个图形用户界面（GUI）工具包，提供了丰富的控件和功能，使得Tcl能够创建交互式应用。书中详尽介绍了Tcl的基本语法、数据类型、控制结构、函数定义以及如何利用Tk构建图形界面。读者可以通过学习本书了解到Tcl的命令式编程风格，以及如何有效地处理文本、文件操作、网络通信和错误处理等核心主题。此外，书中还可能涵盖了一些高级主题，如对象-oriented编程在Tcl中的应用，以及如何利用Tcl与其他语言（如C、Python）进行集成。值得注意的是，这本书是作者为准备1994年出版的正式版本所做的草稿，因此它不仅包含了基础知识，还反映了当时Tcl和Tk技术的最新进展。为了鼓励Tcl社区的学习和交流，Addison-Wesley允许在正式出版前分发这些草稿，但再次强调了尊重版权的重要性，确保任何复制或传播都符合规定的条件。阅读《Tcl and the Tk Toolkit》对于希望深入了解Tcl语言和其在软件开发中的应用的专业人士来说，是一份宝贵的资源，它提供了一个系统且全面的学习平台，帮助读者掌握这个强大的脚本语言，并利用Tk工具包创建高效、用户友好的应用程序。

8 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

For the expr command the word structure doesn’t matter much since expr concate-

nates all its arguments together. However for the button and pack commands, and for

most Tcl commands, the word structure is important. The button command expects its

ﬁrst argument to be the name of a window and the following arguments to come in pairs,

where the ﬁrst argument of each pair is the name of a conﬁguration option and the second

argument is a value for that option. Thus if the double-quotes were omitted the value of

the -text option would be “Hello,” and “world!” would be treated as the name of a

separate conﬁguration option. Since there is no option deﬁned with the name “world!”

the command would return an error.

Now let us move on to the behavior of the commands. The basic building block for a

graphical user interface in Tk is a widget. A widget is a window with a particular appear-

ance and behavior (the terms “widget” and “window” are used synonymously in Tk). Wid-

gets are divided into classes such as buttons, menus, and scrollbars. All the widgets in the

same class have the same general appearance and behavior. For example, all button wid-

gets display a text string or bitmap and execute a particular Tcl command when they are

invoked with the mouse.

Widgets are organized hierarchically in Tk, with names that reﬂect their position in

the hierarchy. The main widget, which appeared on the screen when you started wish, has

the name “.”. The name .b refers to a child of the main widget. Widget names in Tk are

like ﬁle names in UNIX except that they use “.” as a separator character instead of “/”.

Thus .a.b.c refers to a widget that is a child of widget .a.b, which in turn is a child of

.a, which is a child of the main widget.

Tk provides one command for each class of widgets, which you invoke to create wid-

gets of that class. For example the button command creates button widgets. All of the

widget creation commands have the same form: the ﬁrst argument is the name of a new

widget to create and additional arguments specify conﬁguration options. Different widget

classes support different sets of options. Widgets typically have many options (there are

about 20 different options deﬁned for buttons, for example), and default values are pro-

vided for the options that you don’t specify. When a widget creation command like but-

ton is invoked it creates a new window by the given name and conﬁgures it as speciﬁed

by the options.

The button command in the example speciﬁes two options: -text, which is a

string to display in the button, and -command, which is a Tcl script to execute when the

user invokes the button. In this example the -command option is exit. Here are a few

other button options that you can experiment with:

-background The background color for the button.

-foreground The color of the text in the button.

-font The name of the font to use for the button, such as

*-times-medium-r-normal--*-120-* for a 12-point

Times Roman font.

2.3 Script ﬁles 9

DRAFT (8/12/93): Distribution Restricted

The pack command makes the button widget appear on the screen. Creating a widget

does not automatically cause it to be displayed. Independent entities called geometry man-

agers are responsible for computing the sizes and locations of widgets and making them

appear on the screen. The pack command in the example asks a geometry manager called

the packer to manage .b. The command asks that .b ﬁll the entire area of its parent win-

dow; furthermore, if the parent has more space than needed by its child, as in the example,

the parent is shrunk so that it is just large enough to hold the child. Thus when you typed

the pack command the main window shrunk from its original size to the size that appears

in Figure 2.1.

2.3 Script ﬁles

In the examples so far you have typed Tcl commands interactively to tclsh or wish.

You can also place commands into script ﬁles and invoke the script ﬁles just like shell

scripts. To do this for the hello world example, place the following text in a ﬁle named

hello:

#!/usr/local/bin/wish -f

button .b -text "Hello, world!" -command exit

pack .b

This script is the same as the one you typed earlier except for the ﬁrst line. As far as wish

is concerned this line is a comment but if you make the ﬁle executable (type

“chmod 775 hello” to your shell, for example) you can then invoke the ﬁle directly

by typing hello to your shell. When you do this the system will invoke wish, passing it

the ﬁle as a script to interpret. Wish will display the same window shown in Figure 2.1

and wait for you to interact with it. In this case you will not be able to type commands

interactively to wish; all you can do is click on the button.

Note: This script will only work if wish is installed in /usr/local/bin. If wish has been

installed somewhere else then you’ll need to change the ﬁrst line to reﬂect its location on

your system.

In practice users of Tk applications rarely type Tcl commands; they interact with the

applications using the mouse and keyboard in the usual ways you would expect for graph-

ical applications. Tcl works behind the scenes where users don’t normally see it. The

hello script behaves just the same as an application that has been coded in C with a tool-

kit such as Motif and compiled into a binary executable ﬁle.

During debugging, though, it is common for application developers to type Tcl com-

mands interactively. For example, you could test out the hello script by starting wish

interactively (type wish to your shell instead of hello). Then type the following Tcl

command:

source hello

10 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

Source is a Tcl command that takes a ﬁle name as argument. It reads the ﬁle and evalu-

ates it as a Tcl script. This will generate the same user interface as if you had invoked

hello directly from your shell, but you can now type Tcl commands interactively too.

For example, you could edit the script ﬁle to change the -command option to

-command "puts Good-bye!; exit"

then type the following commands interactively to wish without restarting the program:

destroy .b

source hello

The ﬁrst command will delete the existing button and the second command will recreate

the button with the new -command option. Now when you click on the button the puts

command will print a message on standard output before wish exits.

2.4 Variables and substitutions

Tcl allows you to store values in variables and use those values in commands. For exam-

ple, consider the following script, which you could type to either tclsh or wish:

set a 44

⇒ 44

expr $a*4

⇒ 176

The ﬁrst command assigns the value “44” to variable a and returns the variable’s value. In

the secon command t he $ causes Tcl to perform variable substitution: the Tcl interpreter

replaces the dollar-sign and the variable name following it with the value of the variable,

so that the actual argument received by expr is “44*4”. Variables need not be declared

in Tcl; they are created automatically when assigned to. Variable values are stored as

strings and arbitrary string values of any length are allowed. Of course, in this example an

error will occur in expr if the value of a doesn’t make sense as an integer or real number

(try other values and see what happens).

Tcl also provides command substitution, which allows you to use the result of one

command in an argument to another command:

set a 44

set b [expr $a*4]

⇒ 176

Square brackets invoke command substitution: everything inside the brackets is evaluated

as a separate Tcl script and the result of that script is substituted into the word in place of

the bracketed command. In this example the second argument of the second command will

be “176”.

2.5 Control structures 11

DRAFT (8/12/93): Distribution Restricted

2.5 Control structures

The next example uses variables and substitutions along with some simple control struc-

tures to create a Tcl procedure power that raises a base to an integer power:

proc power {base p} {

set result 1

while {$p > 0} {

set result [expr $result*$base]

set p [expr $p-1]

}

return $result

}

If you type the above lines to wish or tclsh, or if you enter them into a ﬁle and then

source the ﬁle, a new command power will become available. The command takes two

arguments, a number and an integer power, and its result is the number raised to the

power:

power 2 6

⇒ 64

power 1.15 5

⇒ 2.01136

This example uses one additional piece of Tcl syntax: braces. Braces are like double-

quotes in that they can be placed around a word that contains embedded spaces. However,

braces are different from double-quotes in two respects. First, braces nest. The last word

of the proc command starts after the open brace on the ﬁrst line and contains everything

up to the close brace on the last line. The Tcl interpreter removes the outer braces and

passes everything between them, including several nested pairs of braces, to proc as an

argument. The second difference between braces and double-quotes is that no substitu-

tions occur inside braces, whereas they do inside quotes. All of the characters between the

braces are passed verbatim to proc without any special processing.

The proc command takes three arguments: the name of a procedure, a list of argu-

ment names separated by white space, and the body of the procedure, which is a Tcl script.

Proc enters the procedure name into the Tcl interpreter as a new command. Whenever the

command is invoked, the body of the procedure will be evaluated. While the procedure

body is executing it can access its arguments as variables: base will hold the ﬁrst argu-

ment to power and p will hold the second argument.

The body of the power procedure contains three Tcl commands: set, while, and

return. The while command does most of the work of the procedure. It takes two

arguments, an expression “$p > 0” and a body, which is another multi-line Tcl script.

The while command evaluates its expression argument and if the result is non-zero then

it evaluates the body as a Tcl script. It repeats this process over and over until eventually

the expression evaluates to zero. In the example, the body of the while command multi-

12 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

plies the result value by base and then decrements p. When p reaches zero the result con-

tains the desired power of base.

The return command causes the procedure to exit with the value of variable

result as the procedure’s result. If it is omitted then the return value of the procedure

will be the result of the last command in the procedure’s body. In the case of power this

would be the result of while, which is always an empty string.

The use of braces in this example is crucial. The single most difﬁcult issue in writing

Tcl scripts is managing substitutions: making them happen when you want them and pre-

venting them from happening when you don’t want them. Braces prevent substitutions or

defer them until later. The body of the procedure must be enclosed in braces because we

don’t want variable and command substitutions to occur at the time the body is passed to

proc as an argument; we want the substitutions to occur later, when the body is evaluated

as a Tcl script. The body of the while command is enclosed in braces for the same rea-

son: rather than performing the substitutions once, while parsing the while command,

we want the substitutions to be performed over and over, each time the body is evaluated.

Braces are also needed in the “{$p > 0}” argument to while. Without them the value

of variable p would be substituted when parsing the while command; the expression

would have a constant value and while would loop forever (you can try replacing some

of the braces in the example with double quotes to see what happens).

In the examples in this book I use a stylized syntax where the open brace for an argu-

ment that is a Tcl script appears at the end of one line, the script follows on successive

lines indented, and the close brace is on a line by itself after the script. Although I think

that this makes for readable scripts, Tcl doesn’t require this particular syntax. Script argu-

ments are subject to the same syntax rules as any other arguments; in fact the Tcl inter-

preter doesn’t even know that an argument is a script at the time it parses it. One

consequence of this is that the open parenthesis must be on the same line as the preceding

portion of the command. If the open brace is moved to a line by itself then the newline

before the open brace will terminate the command.

By now you have seen nearly the entire Tcl language syntax. The only remaining syn-

tactic feature is backslash substitution, which allows you to enter special characters such

as dollar-signs into a word without enclosing the entire word in braces. Note that while

and proc are not special syntactic elements in Tcl. They are just commands that take

arguments just like all Tcl commands. The only special thing about while and proc is

that they treat some of their arguments as Tcl scripts and cause the scripts to be evaluated.

Many other commands also do this. The button command was one example (its -com-

mand option is a Tcl script), and you’ll read about several other control structures later on,

such as for, foreach, case, and eval.

One ﬁnal note about procedures. The variables in a procedure are normally local to

that procedure and will not be visible outside the procedure. In the power example the

local variables include the arguments base and p as well as the variable result. A

fresh set of local variables is created for each call to a procedure (arguments are passed by

copying their values), and when a procedure returns its local variables are deleted. Vari-

剩余141页未读，继续阅读

zlfxia621208

粉丝: 3
资源: 15

Tcl脚本语言入门与Tk Toolkit深度解析

Vivado下的TCL命令集合

TCL脚本语言详细教程

TCL语言教程

tcl脚本语言

TCL+TCL脚本语言编程+TCL语言教程

Tcl语言全攻略，TCL脚本语言

TCL脚本语言培训

TCL脚本语言编程

Tcl 脚本语言 语法

tcl脚本语言的教程

最新资源

Tcl 脚本语言语法