第 15 章 BASH Shell

Linux 下主要有三种不同的 Shell ：Bourne Again She l（l BASH ），Public Korn

Shel l（ PDKSH ）及 TCSH Shell 。这些 Shell 都是相应 UNIX 下 Shell 的增强版。BASH Shell 是 UNIX 下的 Borune Shell 的增强版，它包括了 Korn Shell 和 C Shell 的大多数高级特性。 TCSH Shell 是 C Shell 的增强版，而 C Shell 最初是BSD 版 UNIX 系统下开发的一种 Shell。 PDKSH 是 UNIX 系统下 Korn Shell 的子集。尽管这些 UNIX 系统下的 Shell 有较大的区别，但它们仍然有许多共同的特性。虽然 UNIX 系统中 Bourne Shell 缺乏其它 UNIX 版本下 Shell 的许多功能，但在 Linux 中， BASH Shell 同时具有 Korn Shell 、 C Shell 及 TCSH Shell 的大多数高级特性。

在 Lunix 系统中，所有以上三种 Shell 你都可以使用，但其缺省 Shell 是 BASH Shell 。本章中所有的例子都是使用的 BASH Shell 。当你登陆进入 Lunix 系统后，系统将采用缺省 Shell ，但你可以转换到另一种 Shell 下：键入 tcsh ，系统将使用 TCSH Shell ；键入 bash ，系统将使用 BASH Shell 。你可以用 CTR L ＋ d 或者用 exit 命令退出一种 Shell。

在使用 Lunix 系统的过程中，你可以只使用一种 Shell 完成你所要做的工作。本书第 5 章讨论了所有 Shell 的一般特性，而本章及下一章将讨论 BASH Shell 及 TCSH Shell 。本书不讨论 PDKSH Shell ，因为 PDKSH Shell 是 Korn Shell

的一个子集，且 Korn Shell 的大多数高级特性都可以在 BASH Shell 中找到。

命令和文件名扩展特性

BASH Shell 命令行有一个与 TCSH Shell 非常相似的内在特性：命令与文件名扩展特性。当你输入一个还没完成的命令或文件名时，你只需键入 TAB 键就能激活命令与文件名扩展特性，帮你完成该命令剩余的输入。如果有多个命令或文件的前缀相同， BASH Shell 将响

铃并等待你输入足够的字符，以便选择唯一的命令或文件名。在下面的例子中，用户键入 cat 命令和一个还没有输全的文件名，通过键入 TAB 键，系统开始搜索与之匹配的命令或文件名，如果找到，系统将自动输入搜索到的命令或文件名。用户敲 ENTER 键后，系统将执行这条命令。

$ cat pre TAB

$ cat preface

BASH Shell 也能列出你当前目录下的部分匹配的文件名来完成文件名扩展。如果你键入 “ ESC ” 键，然后键入 “ ? ” ， Shell 将列出所有与你输入的字符串相匹配的文件名。我们看下面的例子：在没有完成的输入后键入“ ESC ? ”， Shell 将列出所有与输入的字符串相匹配的文件名，然后 Shell 回显命令行，根据列出的文件名，你可以键入你要输入的文件名或按 “ TAB ” 键来完成文件名的字符扩展。

$ ls

document docudrama

$cat doc ESC ? document docudrama

$ cat docudrama

命令行编辑

BASH Shell 本身具有命令行编辑功能，能使你在执行所键入的命令之前方便地修改你所键入的命令。如果你在键入命令时犯了一个拼写错误，你只需在运行你所键入的命令之前，使用编辑命令来纠正你的拼写错误，然后执行它，而不用再重新输入整行命令。这对那些要键入长路径文件名作参数的命令特别有用。

命令行编辑的操作是 Emacs 编辑命令的子集。你可用 CTRL-f 或者右方向键向前移向一字符， CTRL-b 或者左方向键向后移向一字符。 CTRL-d 或 DEL 键将删除光标所在位置的字符。要增加字符，只需把光标移到你所希望插入字符的地方，插入新的字符。在任何时候你可以键入 “ ENTER ” 键去执行一个命令。在下一节，你将用命令行编辑操作去修改你先前所键入的命令。

实用命令

在 BASH Shell 中， history 实用命令能够保存你最近所执行的一些命令。这些最近你所执行的命令在被 history 实用命令保存时，其历史记录号从 1 开始，但只有有限个命令可以被保存下来，其缺省值是 500 。 history 实用命令用一小段内存来记录有限个最近你所执行的命令。要查看最近你所执行的一组命令，只用键入 history 命令，然后键入 ENTER （回车键），你最近所执行的一组命令即按执行的先后顺序被显示出来（命令前的数字为历史记录号）。

$ history

1 cp mydata today 2 vi m ydata

mv mydata reports
cd reports 5 ls

...

所有这些命令都被称之为事件（ even t）。一个事件表示一个操作已经发生，也即一个命令被执行。这些事件根据它们被执行的先后顺序用数字给以标识，这一标识称为历史事件号。最后执行的历史事件的事件号最大。每个事件都可被它的历史事件号或命令的初始字符或字符串等确定。

histroy 实用命令能够使你查询以前的事件，并可把它们显示到命令行上或执行它。最简便的办法是通过上下光标键，把先前的一个个事件逐次显示到命令行。你不必要先运行 history 命令，就可执行上述操作。按一下上光标键，你

上一次执行的一个事件将出现在命令行上，再按一下，上一次的前一事件又会出现在命令行上；按一下下光标键，将会使当前事件的下一事件出现在光标行上。 BASH Shell 也可以通过键入 “ ESC ” 、 “ TAB ” 键来完成对历史事件的字符扩展。正如标准的命令行扩展特性，你键入历史事件的部分字符串，然后键入 “ ESC ” ，再键入 “ TAB ” 键，与你刚才键入的字符串相匹配的历史事件将自动扩展并回显到命令行处。如果不止一个事件与你输入的字符串相匹配，你将会听到一声响铃，继续键入字符或字符串， Shell 将会唯一确定你所要键入的历史事件。然后，你可以用命令行编辑操作来编辑显示在命令行上的事件。通过左右键在命令行上移动，你可以把光标停留在任何地方，插入你所需要的字符或字符串，如用 BACKSPACE 键和 DEL 键，你可以删除字符或字符串。按回键后，这一事件将被执行。你也可以通过！命令来查询和执行历史事件。在！命令最后键入能够确定历史事件的关联字符，这关联字符可以是历史事件的历史事件号，或者该事件的前几个字符串。在下面的例子中，历史事件号为 3 的事件被查询到。同时，又用其开头几个字符串去匹配，也被查询到。

$ !3

mv mydata reports

$ !mv

mv mydata reports

你也可以用一个偏移量（相对于历史事件列表中最后一个事件）来查询历史事件。负的偏移量将通从历史事件列表表尾向前偏移，从而查询到所要的事件。在下面的例子中，历史事件号为 2 的事件 “ vi mydata ” 就是用一个负的偏移量查询到，并执行的。必须注意的是，这个偏移量是相对于相对于历史事件列表中的最后一个事件的。在本例中，历史事件列表中最后一个事件是事件 5 ，

历史事件列表中第一个事件为 1 。从历史事件号为 5 的事件，往前偏移 4 ，即是历史事件号为 2 的事件。

＄！ -4

vi m ydata

如果 “ !” 命令后没有任何参数，则系统将默认为上一事件。在下面的例子中，用户在命令行上键入无参数的 “ !” 命令，系统将执行上一事件。本例中，上一事件为 “ ls ” 命令。

$ !ls

mydata today reports

你也可以用模式去搜索一个历史事件。该搜索的模式必须用符号 “ ? ” 括起来。在下面的例子中，模式 “ ?myd? ” 用来搜索历史事件号为 3 的历史事件 vi mydata 。

$ !? m yd? vi m ydata

历史事件编辑

你也可以编辑历史事件列表中你先前执行的任何事件。在 BASH Shell 中，有两种方法来实现。你可以用命令行编辑功能去查询和编辑历史事件列表中的任何事件。同时，你也可以用 history fc 命令选项来查询一个事件并用全屏幕编辑器 vi 来编辑它。两种方法涉及到两种不同的编辑器。前一种命令的局限性在于它只能用命令行行编辑器进行单行编辑（其编辑命令是 Emacs 编辑器命令的子集）。但是，它能使你非常方便地查询历史事件列表中的事件。第二种方法

用功能强大的标准全屏幕编辑器 vi 来完成编辑，但它仅针对某些特定的历史事件。

用命令行编辑器，你不仅可以编辑当前的命令，而且可以编辑历史事件列表中的事件并执行之。你可以用 CTRL-P 命令转移到历史事件列表中当前的事件的前一事件，用 CTRL-n 命令转移到历史事件列表中当前的事件的下一事件，用 E S C <命令转移到历史事件列表中最初的一事件，用 ESC > 命令转移到历史事件列表中的最后一事件。你甚至可以用一种方式去搜索指定的事件，例如，在反斜 “ ＼ ” 后键入搜索模式将在历史文件列表中向后 (backward) 搜索历史文件，而在问号 “ ? ” 后键入搜索模式将向前 (forward) 搜索历史文件。键入 “ n ” 命令重复进行上次搜索。

一旦你找到编辑的事件，你可以使用 Emacs 命令行编辑命令对该文件进行行编辑。按 CTRL-d 进行字符删除，CTRL-f 或光标右键前移一个字符串，CRTL-b 或光标左键后移一个字符。如果要增加一个字符，把光标移到你需要输入字符的地方键入字符即可。表 15-1 列出了查询历史事件列表的各种命令。

如果想用标准的编辑器对一事件进行编辑，你可以用 fc 命令及一个指定的事件关联（如历史事件号）来查询该事件，此时，系统所使用的编辑器是 Shell 为 fc 命令指定的缺省编辑器。下面的例子将用标准编辑器编辑历史事件号为 4 的事件 cd reports ，然后执行之。

$ fc 4

你可以也可以一次选择多个命令进行编辑并执行。通过先输入第一个命令的标识符，然后输入最后一个命令的标符来选择多个命令。这一标识符可以是命令的历史事件号，也可以是命令的初始字符或字符串。在下面的例子中，用

历史事件号来选择在事件号在 2 与 4 之间的一系列命令，然后编辑并运行它们。另一例子采用历史事件列表中初始字符或字符串来作标识符。

$ fc 2 4

$ fc vi c

fc 使用缺省的编辑器，这一缺省编辑器被 FCEDIT 某些特殊变量所指定。通常这一编辑器为 vi 编辑器。但是，如果你想使用 Emacs 编辑器，在你使用fc 命令时，你可以用 -e 选项和 emacs 选项。下面的例子将用 Emacs 编辑器对事件号为 4 的事件 cd reports 进行编辑，然后运行。

$ fc -e emacs 4

配置 H istory: HISTFILE 及 HISTSIZE

你系统所保存的事件数被保存在一个特定的系统变量中，这个变量就是H ISTSIZE 。这个变量的缺省值通常被设置为 500 。你可以非常简单方便地改变它的值，并赋之以新的值。在下面的例子中，用户重新设置变量 HISTSIZE 的值为 10 。

$ HISTSIZE=10

实际上，历史事件被保存在一个文件中，而这个文件名由变量 H ISTFILE 指定。通常这个文件的缺省名是 .bash_history 。但是，你可以通过给变量H ISTFILE 赋值，来指定新的文件名。在下面的例子中，显示出了变量 HISTFILE 的值，然后，新的文件名 newhist 被赋值给它，所有历史事件将被保存在 newhist 文件中。

$ echo $HISTFILE

.bash_history

$ HISTFILE= “ newhis t”

$ echo $HISTFILE newhist

别名

通过 alias 命令，你可以给一个命令创建一个新的名字。 alias 命令象一个宏，对其代表的命令进行替换。它不是逐字对命令名进行替换，而是仅仅对命令取另外一个名字。

alias 命令由关键词 alias 开头，然后是要替换命令的新的名字，其后是等号（ = ）及将要替换的命令，在等号之间不能有空格。下面的例子中， list 就是 ls 命令的一个别名。

$ alias list=ls

$ ls

mydata today

$ list

mydata today

你也可以用一个别名对一个命令或其选项进行替换。但是，你必须用一对单引号把它们括起来。所有包括空格的别名必须用单引号把它们括起来。在下面的例子中， lss 是带 -s 选项 ls 命令的别名， lsa 是带 -F 选项的 ls 命令的别名。带 -s 选项的 ls 命令将列出文件及它们的文件占的块大小；带 -F 选项的 ls 命令

将在目录名前加一 “ /” 。需要主要的是，对命令和其选项要单引号把它们括起来。

$ alias lss='ls -l'

$ lss

mydata 14 today 6 reports 1

$ alias lsa='ls -F'

$ lsa

mydata today /reports

你也许经常对一个带参数选项的命令取别名。如果你经常执行带有复杂参数组合的命令，你可能想用简单的别名来代替。例如：假如你常常想列出所有你的源程序和目标代码文件，假设这些文件分别以 .c 和 .o 为扩展名，那么你需要用带参数的 ls 命令（此时这个参数是特定的字符串 *.［ co ］），于是，你可以用别名给这个命令取别名。下面给出的例子中，用 ls

c 给带参数 * .［ co ］的 ls 命令取别名。

$ alias lsc='ls * .［ co ］ '

$ lsc

main.c main.o lib.c lib.o

你也可以用一个 Shell 命令名给一个命令行取别名。这在你要执行带特定选项的 Shell 命令时非常有用。例如带 -i 选项的 rm 、 cp 及 m v 命令通常用来保证不覆盖已存在的同名的文件。如果你在使用上述命令的过程中，希望系统给予相应的提示来确认你是否想覆盖已有的文件，你可以给它们取别名去包含这一选项。例如：下面的命令就是用带 -i 选项的 rm 、 cp 及 m v 命令取别名为 rm 、 cp

及 m v 的。

$ alias rm=' rm -i'

$ alias mv=' mv -i'

$ alias cp=' cp -i'

不带任何参数的 alias 命令将列出所有当前已经起作用的别名及它们所代表的命令。你可以用 unalias 命令去删除一个别名。在下面的例子中，用户列出了当前所有的别名，然后用 unalias 命令删除别名 lsa 。

$ alias lsa=ls -F list=ls rm=rm -i

$ unalias lsa

控制 Shell 的运行方式

BASH Shell 有一些特殊变量，能让你控制 Shell 以不同的方式工作。例如：变量 noclobber 能防止在重定向输出时意外地覆盖一个文件。你可以通过 set 命令来使 noclobber 特殊变量有效或无效。 set 命令有两个参数：一个选项来指定变量开（ on ）或关（ off），另一变量是特殊变量的变量名。要使一特殊变量开（有效），用 -o 选项，要使其关（无效），用 +o 选项。

例如：

$ set -o feature// 使 feature 变量开

$ set +o feature // 使 feature 变量关

三个最常用的 Shell 特殊变量变量有： ignoreeo f、 noclobber 及 noglob。表

列出了 set 命令的用法及几个 Shell 特殊变量的作用。

15.5.1ignoreeof

设置了 ignoreeof 变量后，你将不能使用 CTRL-d 来退出 Shell 。 CTRL-d 不仅被用来退出 Shell，而且可以用来终止用户直接输往标准输出上的输入。该操作经常在 MailX 程序和一些 Shell 实用命令中使用，例如 cat 实用命令。你可能在上述实用程序操作中，非常容易误操作而意外地退出 Shell 。 ignoreeof 特殊变量正是用来防止这些意外的退出。在下面的例子中，用带 -o 选项的 set 命令来使 ignoreeof 特殊变量有效 (on)，这时，用户只能用 logout 或 exit 命令退出 Shell 。

$ set -o ignoreeof

$ ctrl-d

Use exit to logout

15.5.2noclobber

设置了 noclobber 变量后，可以使在重定向输出时保护已存在的文件。如果你用重定向把输出保存到一个已经存在的文件中时， noclobber 这一特殊变量可以防止文件在进行标准输出时被意外覆盖，原文件将被受到保护。这种情况有可能发生在把重定向输出的内容保存到你输入的文件名中，而你给出的这

个文件名可能已经存在了。因此， noclobber 特殊变量可以防止你意外地覆盖一个你已经存在的原文件。下面的例子中，用户设置 noclobber 特殊变量为有效（ on ），在重定向时，用户试图去覆盖系统已经存在的文件 myfile ，此时，系统将返回一错误信息。

$ set -o noclobber

$ cat preface>myfile myfile: file exists

你可能觉得你的确是想在重定向输出时覆盖这个文件，系统的这一提示将浪费你的时间，这时，你可以在重定向操作算子后面加一惊叹号（ !）。于是，系统将不考虑 noclobber 变量的有效性而直接把重定向输出的内容输出至指定的文件。

$ cat preface >! myfile

15.5.3noglob

设置了 noglob 变量后， Shell 将不扩展文件名中一些特殊的字符或字符串。例如：字符 “ * ” 、 “ ? ” 、 “ ［ ” 、 “ ］ ” 及 “ ~ ” 等字符将不再展开多义性文件名与一文件名相匹配。如果你在文件名中使用了这些特殊字符，这个特殊变量或许就对你有用。下面的例子中，如果用户希望列出结尾为 “ ? ” 的文件名answer? ，可通过如下步骤：首先，用户使 noglob 变量为无效（关），然后再列出文件名。可以看到，目前命令行上的问号（ “ ? ” ）被认为是文件名中的一个字符，而不是被看作一个特殊的字符（代表任意一字符）。

$ set -o noglob

$ ls answer? answer?

环境变量与子 Shell ： export 命令

当你登陆到你的帐号后， Linux 系统将创建你的用户 Shell 。在此 shell 中，你可以使用 Shell 命令或申明变量。你也可以创建并运行 Shell 脚本程序。然而，当你运行一个 Shell 脚本程序时，系统将创建一个子 Shell 。此时，系统中将有两个 Shell ，一个是你登陆时系统的缺省 Shell ，另一个是系统为运行脚本程序创建的 Shell。在脚本程序 Shell 中，你可以执行有自己 Shell 的另一脚本 Shell 。当一个脚本程序运行完毕，它的脚本 Shell 将终止，你可以返回到你执行该脚本之前的 Shell 。从这种意义上来说，你可以有许多 Shell ，每个 Shell 都 “ 寄生 ” 在某 Shell 之上（称之为父 Shell ）。

在一个子 Shell 内定义的变量只在该子 Shell 内有效。如果你在一 Shell 脚本程序中定义了一变量，当该脚本程序运行时，你定义的变量只是该脚本 Shell 内的一局部变量。其它的 Shell 不能引用它。从这种意义上来说，变量是隐藏在它的 Shell 之内的。

你可以在如下三种主要的 Shell 中定义环境变量，即 BASH Shell 、 PDKSH Shell 及 TCSH Shell 。但是， BASH Shell 中实现环境变量的机制与 TCSH Shel 有很大的不同。在 BASH Shell 中，环境变量被输出的。也就是说。环境变量在每个子 Shell 中都有一个拷贝。例如，如果 myfile 这个变量被输出，那么这个变量在每个子 Shell 中都会为你自动定义。而在 TCSH Shell 中，环境变量只

被定义一次，一旦被定义，在任何子 Shell 中都可以直接引用。

在 BASH Shell 中，一个环境变量可以被认为是一个 Added capabilities 的常规变量。要使其变量值可以改变，你可以使用 export 命令对已定义的变量进行变量输出。 export 命令将使系统在创建每一个新的 Shell 时定义那个变量的一个拷贝。每个新的 Shell 将有其自己的环境变量的拷贝。这个过程常称之为变量输出。

在下面的例子中，变量 myfile 是在 dispfile 脚本程序中定义的。然后用 export 命令使其成为一环境变量。变量 myfile 将可以输出至任何子 Shell ，例如当执行printfile 脚本程序时产生的子 Shell 。

dispfile 脚本程序清单：

/************** begin dispfile ***********/ myfile="List"

export myfile

echo "Displaying $myfile" pr -t -n $myfile

printfile

/************** end dispfile ***********/ printfile 脚本程序清单：

/************** begin printfile ***********/

echo "Printing $myfile" lpr $myfile&

/************** end printfile ***********/

$ dispfile

D isplaying List

screen
modem
paper Printing List

把环境变量的输出理解为全局变量是一种误解。一个新的 Shell 绝不会改变其 Shell 以外的变量的值。但是，这个变量的值将被传递给这个新创建的 Shell 。你可以将输出变量理解为将变量的值输出到一个 Shell，而不是将它们本身。对那些比较熟悉结构化编程的读者来说，可以把输出变量理解为 “ 值引用 ” 。

用特殊 Shell 变量设置登陆 Shell

前面已经指出，在你登陆进入你的帐号， Linux 系统将为你创建 Shell 。这个 Shell 被称为你的登陆 Shell 或用户 Shell 。当你执行 Shell 程序脚本时，系统将创建用户 Shell 的子 Shell 。你可以在你的用户 Shell 下定义变量，你也可以定义环境变量，而这些环境变量可以被在运行 Shell 程序脚本时创建的任何子 Shell 所引用。

Linux 有一些特殊 Shell 变量，这些变量允许你配置你的用户 Shell 。很多这

些特殊 Shell 变量在你登陆时系统已经为你定义好，但是，有些变量你可以自己再定义。

这些特殊变量名是系统的一些保留关键字。你不能用这些关键字作为你自己的变量名。为使这些特殊变量容易识别，这些特殊 Shell 变量都是由一些大写字母组成的字符串。例如：关键字 HOME 是系统用来定义名为 HOME 的特殊变量的，它是一个特殊环境变量，用来保存用户的主目录路径名。另一方面，前面的章节中介绍的关键字 noclobber 用来定义 noclobber 环境变量，这个特殊变量可以防止在重定向输出覆盖已有的文件。

许多特殊变量在你登陆你的用户时被系统自动赋了初始值，但是，如果需

要，用户可以改变这些特殊变量的值。但是，有些特殊变量的值是不能被重新赋值的。例如，保存用户主目录路径名的特殊环境变量 HOME 是用户不能给重新赋值的。一些命令，例如 cd 命令就是通过保存用户主目录的特殊变量 HOME 来进行目录定位的。一些常用的特殊环境变量将在本节中详细介绍。

另外一些系统定义并赋以一定的初始值的特殊变量是用户可以任意改变的。你可以重新给它们定义一个新的值。例如，变量 PATH 是系统定义的，在登陆时被赋以一初始值，这一初始值包括了一些命令所在的目录路径。当你执行某个命令时， Shell 将自动搜索这些路径。你可以在 PATH 变量中增加新的路径，在执行命令时将对这些新的路径进行搜索

还有一些特殊变量，用户登陆系统后并不给它们赋值。这些变量通常是一些可选择项。例如，变量 EXINIT 允许你为 vi 编辑器进行设置选项。在每次登陆系统后，你必须重新为这些变量定义值。从这种意义上说，这些变量可称之为 “ 用户级定义 ” （ user-defined ）特殊变量。

这三类特殊变量没有严格、权威的分类与定义。本书根据它们特点，分别称这类特殊变量为：用户不能改变其值的“ 系统自赋值 ” （ system-determined ）特殊变量、用户可以重新定义一新值的 “ 可重定义 ” （ redefinable ）变量及用户必须自己赋值的 “ 用户级定义 ” （ user-defined）特殊变量。

你可以用 env 命令列出当前定义的特殊变量及其值。 env 命令与 set 命令很相似，但 env 命令仅列出系统特殊变量。

$ env USERNAME=chris

ENV=/home/chris/.bashrc H ISTSIZE=1000

H ISTFILE=/home/chris/.bash_history H ISTFILESIZE=1000

HOSTNAME=garnet LOGNAME=chris

H ISTFILESIZE=1000

CDPATH=:$HOME/letters:$HOME/oldletters MAIL=/var/spool/mail/chris

WWW_HOME=fi le:/usr/doc/calderadoc-0.80-1/Caldera_Info TERM= linux

HOSTTYPE=i386

PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/home/chris/bin: HOME=/home/chris

SHELL=/bin/bash

PS1= ［＼ u@ ＼ h ＼ w ］＼ $

PS2=> MAILCHECK=10000

MAILPATH=/home/mail/chris:/home/chris/projmsgs CRPATH=/usr/lib/CRISPlite/macros OSTYPE=Linux NNTPSERVER=nntp.ix.netcom.com

EXINIT='set nu ai' TZ=PST5PDT SHLVL=1

_=/usr/bin/env

你可以用称为初始化文件的特殊脚本语言去对 “ 可重定义 ” （ redefinable ）变量及 “ 用户级定义 ” （ user-defined）变量进行自动定义。初始化文件是一个特殊的 Shell 脚本程序，只要用户进入这个特定的 Shell ，它将自动运行。你可以对这个初始化文件进行编辑，给一些特殊变量进行定义与赋值。当你进入Shell ，初始化文件将被执行，并对一些特殊变量进行定义与赋值，从而有效地给这些特殊变量赋予你所定义的值。例如，在 BASH Shell 中，其初始化文件是 .profile ，当你每次登陆进入 Linux 时，该文件都被自动运行。该文件包含了一些特殊变量的定义与赋值。因为 .profile 文件仅仅是一种 Shell 脚本程序，因此，你可以用任何一种编辑器对其进行编辑，例如 vi 编辑器。如果需要，你可以改变那些特殊变量的值。

在 BASH Shell 中，所有 “ 可重定义变量 ” （ redefinable ）及 “ 用户级定义

变量 ” （ user-defined）是为环境变量而设置的。当你定义或重定义一特殊变量时，你必须对其进行输出（ export ），以使其成为环境变量。这意味着你对任

何特殊变量的改变都必须用 export 变量进行输出。在登陆初始化文件 .profile 文件的结尾，你会看到通常有一 export 命令来对该文件中定义的所有特殊变量进行输出。

“ 系统自赋值 ” （ system-determined ）特殊变量

在这里，将介绍三个常见的系统 “ 系统自赋值 ” （ system-determined ）特殊变量，它们是： HOME 、 LOGNAME 及 TZ 。当你一登陆，系统就自动定义它们，你可以访问它们的值，但不能改变它们。它们都是环境变量，任何的子Shell 都可以访问它们的值。

HOME

HOME 变量保存你主目录的路径名。这个主路径是系统管理员在创建你的用户时由系统管理员指定的。当你登陆进入你的帐号时，系统将自动把主目录路径名保存到 HOME 变量中。下面的例子中，用 echo 命令列出变量 HOME 的值。

$echo $HOME

/home/chris

当你需要指定绝对路径时，我们经常用到 HOME 变量。在下面的例子中，用保存了主目录名的 HOME 变量来指定 reports 的绝对路径名。

$ ls $HOME/reports LOGNAME

LOGNAME 变量保存你的登陆名，而不是路径名。如果用户以用户名 chris

登陆，系统将以字符串 “ chris ” 作为变量 LOGNAME 的值。在某些情况下，你

需要使用你的登陆名，这时，你可以使用 LOGNAME 变量。下面的例子将介绍LOGNAME 变量的使用。我们知道，用户的 mail 信箱的目录名与其登陆用户名相同，用户可以直接使用他的登陆名或简单方便地引用 LOGNAME 变量的值定位 mail 目录。如果有时用户决定要改变其登陆名，那么，他们更愿意使用LOGNAME 变量。

$ ls /usr/mail/$LOGNAME TZ

TZ 变量用来指定系统所使用的时区。它是在你登陆进入系统时由系统设置的。在 TZ 变量中，用三个字段来显示其值。前三个字母显示当地时区，下一个字母是当地时区与格尼威制标准时间（ Greenwich mean tim e）的时差数，最后的三个字母是当地的夏令时（ Daylight Saving ）时区。下面的例子中， TZ 变量保存的是太平洋标准时间（ Pacific standard tim e），它和格尼威制标准时间的时差是八个小时，使用的是太平洋夏令时。

$ echo $TZ PST8PDT

BASH Shell 可重定义特殊变量

可重定义变量保存如下一些信息： Linux 命令所在的路径名、 ma il 信箱中文件的路径名以及你的命令提示符等。你可以通过简单的赋值操作来修改上述任何变量的值。另外一些常用的可重定义的特殊变量有： SHELL 、 PATH 、 PS1 、PS 2 、及 MAIL 等。 SHELL 变量保存你所登陆后使用的 Shell 类别（包括路径的程序名）。 PATH 变量保存执行 Linux 命令时要搜索的目录表。 PS1 和 PS2

变量保存命令提示符的值。 MAIL 变量用来保存你的邮件信箱中文件的路径名。

SHELL

在 Linux 系统中，当你登陆时，系统将启动 BASH Shell 、 PDKSH Shell 及TCSH Shell 这三种 Shell 中的任何一种。而 SHELL 变量将保存系统启动的 Shell 名（包括目录路径名），也就是你的缺省 Shell。 Shell 程序放置在 /bin 目录下。下面是不同 Shell 程序所在的目录路径列表：

BASH Shell ： /bin/bash PDKSH Shell ： /bin/pdksh TCSH Shell ： /bin/tcsh

在下面的例子显示出 SHELL 变量的值。

$ echo $SHELL

/bin/bash

PATH

PATH 变量保存一系列由 “ ： ” 号分开的目录路径。每次要执行一个命令时，系统将对在 PATH 变量中列出的路径名逐一进行搜索，以找到要执行的命令。例如， cp 命令放置在 linux 系统中的 /usr/bin 路径下，这个目录路径是 PATH 变量中列出的目录路径之一。在每次执行 cp 命令之前，系统将搜索这一路径，从而找到 cp 应用程序。系统会给 PATH 变量定义一初始值。在 Linux 系统中， PATH 变量的初始路径名为 usr/bin 和 /usr/sbin 。

Shell 可执行任何可执行文件，包括你开发或创建的应用程序或脚本程序。

因此， PATH 变量也可以搜索你的工作目录。如果你想在你的工作目录下运行你自己的脚本程序或应用程序， Shell 也可以搜索到它们。

在 PATH 变量保存的字符串中，路径和路径之间不能有空格。如果该字符串中仅仅只有一个 “ ： ” 号而没有指定特定的路径，那么，系统将仅搜索你的工作目录。在整个字符串的结尾加一个 “ ： ” 号表示包括你的工作目录。例如：字符串 /usr/bin:/usr/sbin :表示将要搜索三个目录，即目录 /usr/bin 、 /usr/sbin 及你当前的工作目录。

$ echo $PATH

/usr/bin:usr/sbin:

如果需要，你可以任意加入新的路径至 PATH 变量中。如果你用 Shell 脚本程序创建了几个你自己的 Linux 命令，那么，上述特性就非常实用。你可以创建一个目录，并把上述新的 Shell 脚本命令放到这个目录，然后把该目录加到 PATH 变量中，于是，无论你在何目录下，你都可以执行上述 Shell 脚本命令。因为在 PATH 变量中已包含了脚本命令所在目录字符串，当你发出执行一个脚本命令的时候，系统每次都对该目录进行搜索。

你可以用变量赋值的方式往 PATH 变量的路径列表中增加一个新的路径，

并且可以在你的 Shell 下直接执行这一赋值过程。看下面的例子：用户 chris 向PATH 变量中增加了一新的名为 m ybin 的路径。尽管你可以仔细地往 PATH 变量中键入所有路径名列表及新的路径名来完成这一赋值过程，但你可以用

$PATH 给 PATH 变量赋值，然后加入新的路径名。下面的例子中，增加的新的路径名中的 HOME 的值用来代表用户的主目录。必须注意的是在两个 “ ： ” 号之间没有任何字符串，表示要搜索工作目录。

$PATH=$PATH:$HOME/mybin

$export PATH

$echo $PATH

/usr/bin:/usr/sbin::/home/chris/mybin

如果你仅在登陆后才往 PATH 变量中增加一个目录，那么，这个目录仅仅是在你的登陆期间被增加。当你退出用户，然后重新登陆，登陆初始化文件 .bash_profile 将重新用该文件原来设置的 PATH 变量的值来初始化 PATH 变量（稍后，我们在本章将详细介绍 .bash_profile 文件）。如果你想保存你新增加的路径，你必须编辑你的 .bash_profile 文件，找到给 PATH 变量赋值的地方，然后只需往 PATH 变量中插入 “ ： ” 号及新的路径至路径列表中即可。

PS1 和 PS2

PS1 和 PS2 变量分别用来设置系统首选和辅助命令提示符。 BASH Shell 的首选命令提示符是符号 “ $ ” ，你可以用新的字符（窜）给 PS1 变量赋新的值来改变命令提示符。下面的例子中， Shell 命令提示符由符号 “ $ ” 变成了符号 “ -> ” 。

$ PS1="->"

->export PS1

你可以把命令提示符设置成任何你想设置的符号，包括字符串。如下例：

$ PS1="Please enter a command: " P lease enter a command: export PS1 P lease enter a command: ls

mydata /reports

P lease enter a command:

PS2 变量用来设置辅助命令提示符，用来当一个命令较长，一行无法完成或没有完成时，系统在下一行给用户的命令提示符。缺省的辅助命令提示符是

“ > ” 。当一行无法完成或没有完成时，后续增加的命令行将用辅助命令提示符而不是首选命令提示符。你可以通过上述改变首选命令提示符的方法来改变辅助命令提示符的值。例如：

$ PS2="@"

与 TCSH Shell 一样， BASH Shell 提供一组预定义符，以便配置你的命令提示符。你可以用时间、你的用户名或者你的当前目录路径名，甚至可以用你当前将要输入命令的历史事件号作为你的命令提示符或提示符的一部分。每个预定义符以 “ ＼ ” 符号开头。 “ ＼ w ” 代表当前的工作目录， “ ＼ t” 代表当前的时间， “ ＼ u ” 代表你的用户名。 “ ＼ !” 将显示下一命令的历史事件号。下面的例子中，用户在命令提示符中增加了当前工作目录。

$ PS1=" ＼ w $"

/home/dylan $

这些预定义符必须是有双引号括起来的一字符串。如果没有双引号，那么这些预定义符将不会被赋值给 PS1 和 PS2 变量，而是把字符串本身的值作为命令提示符。例如命令行 PS1= ＼ w 将把字符串 “ ＼ w ” 设置为命令提示符，而不是把当前工作目录设置为命令提示符。下面的例子将时间和历史命令号一起作为新的命令提示符。

$ PS1=" ＼ t ＼ ! ->"

下面是一些用来配置系统命令提示符的一组预定义符列表：

＼ !当前历史事件号

＼ $ 除超级用户外，所有的其它用户都用 “ $ ” 作命令提示符，而超级用户用 “ # ” 作命令提示符

＼ d 当前日期

＼ s 当前 Shell 类别

＼ t 当前时间

＼ u 当前用户名

＼ w 当前工作目录

MAIL 、 MAILCHECK 及 MAILPATH

Linux 系统把发送给你的邮件保存在用户邮件信箱文件里， MAIL 变量就是用来保存用户邮件信箱文件名的。当你执行 Mailx 实用程序时，等待你阅读的邮件就从这个文件中取出。邮件信箱文件及邮件实用程序在本书第 8 章有详细介绍。尽管你可以改变 MAIL 变量的值，但一般很少或没有必要改变它。 Linux 系统需要这个目录路径名去寻找用户邮件信箱文件。

$ echo $MAIL

/var/mail/chris

MATLCHECK 变量用来设置时间间隔。每隔这个设定的时间间隔，如果你有新邮件，系统将会通知你已经有新邮件。如果你希望系统一收新邮件就通知你，你可以减少这一时间间隔。如果你不想被它干扰，你可以延长这一时间间隔。缺省的时间间隔是 10 分钟（ 600s ）。下面的例子中，时间间隔被设置成 20 分钟（ 1200s ）。

$ MAILCHECK=1200

$ export MAILCHECK

如果你想在检查另外一些邮件信箱文件的来件情况，你可以设置 MAILPATH 变量，用来保存另外一些邮件信箱文件的目录路径表。与 MAIL 和 MAILCHECK 变量不同， MAILPATH 是 “ 用户级定义 ” （ user-defined ）特殊变量。要使用

该变量，你必须给它赋一值。你可以给它赋值任何你想核查的邮件信箱文件的目录路径名。在下面的例子中，除在 MAIL 变量中指定的邮件目录路径外，用户还指定了另外一需要检查来件情况的邮件文件目录路径名。

$ MAILPATH=/home/mail/$LOGNAME

$ export MAILPATH

BASH Shell “ 用户级定义 ” （ user-defined ）特殊变量

BASH Shell 中用户级特殊变量保存当前终端类型、缺省的 vi 编辑器配置等信息。很多变量如 TERM 和 CDPATH 等增强了 Shell 的可操作性。另外一些是为某些特定的实用程序设定的。例如 EXINIT 变量就是用来配置 vi 和 Ex 编辑器的。 BASH Shell 环境下的一些可重定义变量和用户级定义变量在表 15-2 中列出。

用户级定义特殊变量不是系统定义的。如果你要使用它们，你自己必须定义并赋值给它们。三个常见的用户级定义特殊变量有： CDPATH 、 TERM 和EXINIT 。 CDPATH 变量保存目录路径名，以便 cd 命令方便地寻找、改变目录。TERM 变量保存当前使用的终端类型。 EXINIT 变量用来配置 vi 和 Ex 编辑器命令。

CDPATH

如果 CDPATH 变量没有定义，当我们在 cd 命令后给出目录名作参数时，它仅在当前工作的目录下搜索所给出的目录名。但是，如果定义了 CDPATH 变量，执行上述命令时，将在 CDPATH 变量中所有列出的目录中去搜索。如果该目录被搜索到，运行 cd 命令后将转至该目录下。如果你正在进行一项工作，而

该工作必须不断地在不同的目录下转来转去，设置 CDPATH 变量后就会对上述工作非常有用。要转至和你现在目录差别很大的目录路径下，你必须知道该目录的绝对路径。但是，你只需简单地将要转向的目录路径的父路径增加到CDPATH 变量中， cd 命令将在其父路径下自动搜索，为你找到你所要转向的目录，并转至该目录下。需要指出的是，你应该把你要转向的目录的父路径赋值给 CDPATH 变量，并不是该目录本身。

在下面的例子中， CDPATH 被增加了搜索路径 /home/chris/letters 。

/home/chris/letters 是 thankyou 的父目录。当执行带参数 thankyou 的 cd 命令时， CDPATH 中的目录将自动搜索，包括 letters 目录，于是， thankyou 目录将被搜索到。

$ CDPATH=$CDPATH:/home/chris/letters

$ export CDPATH

$ echo $CDPATH

:/home/chris/letters

$ cd thankyou

$ pwd

/home/chris/letters/thankyou

当然，你可以编辑 .bash_profile 文件，以便永久地往 CDPATH 变量中增加一些目录路径名。本书建议在向 CDPATH 变量中增加新的目录路径名的过程中，用 HOME 变量去指定各目录路径的主目录路径部分。这是因为系统管理员在对文件系统进行重新组织的过程中，你的主目录路径有可能改变。 HOME 变量始终保存你目前的主目录路径名。在下面的例子中，目录路径名

/home/chris/letters 是用 $HOME/letters 指定的。

$ CDPATH=$CDPATH:$HOME/letters

$ export CDPATH

$ echo $CDPATH

:/home/chris/letters TERM

TERM 变量保存目前你使用的终端的终端名。如果你是从一个终端登陆的，

系统将询问你的终端名，你所输入的终端名将被保存在变量 TERM 中。一些应用程序如标准编辑器，将通过 TERM 变量来查明你所使用的终端类别，这样，系统才正确映射键盘输入的命令与屏幕显示。下面的命令将显示你的终端类别：

$ echo $TERM tvi925

如果你想改变你的终端类别，你可以给 TERM 变量赋值另一终端名来改变它。在下面的例子中， TERM 变量被赋值以 vt100 终端类型，然后，用输出变量 TERM ，以使在使用 Shell 的过程中都能访问它。

$ TERM=vt100

$ export TERM

$ EXINIT

EXINIT 变量可用来保存一些编辑器的命令选项，这些命令选项可以用来配

置 vi 和 Ex 编辑器的编辑环境与编辑命令。当你启动这些编辑器时， EXINIT 变量中保存、设置的命令将被执行。 EXINIT 变量中保存的命令通常用来指定编辑器的一些编辑特性，如是否显示行号、是否进行行缩进等。这些都会在第 17 章

中详细讨论。

在下面的例子中， EXINIT 变量被赋值给一个 set 命令，该 set 命令用来设置编辑器显示行号及自动缩进特性。请注意，两个命令可以缩写并合并为一个字符串。

$ EXINIT='set nu ai'

$ export EXINIT

BASH Shell 登陆初始化文件： .profile

.profile 文件是 BASH Shell 的登陆初始化文件，该文件名也可以是 .bash_profile 。它是一个脚本程序，任何一个用户登陆进入 BASH Shell 后，它都将被自动执行。该程序用一些常用 Shell 命令去定义一些用来管理 BASH Shell 的特殊环境变量。它们可能是一些系统定义类特殊环境变量的重定义或一些用户级定义类特殊变量。例如，当你登陆进入系统，用户 Shell 必须知道 Linux 系统的一些系统命令所在的目录。 Linux 系统将根据 PATH 变量所指定的目录路径来进行搜索。但是， PATH 变量必须首先被赋与指定的目录路径名。在 .bash_profile 中，有一个赋值过程，它正是用来完成上述赋值操作的。由于它是在 .bash_profile 中，这一赋值过程在每次用户登陆时都被自动执行。

也有一些特殊变量需要用 export 命令进行输出。以使它们在你创建的任何

子 Shell 中都能访问其值。你可以用一个 export 命令以要输出的变量列表作为参数同时输出几个变量。通常在 .bash_profile 文件的结尾用一个 export 命令输出文件中定义的所有变量。如果在这个列表中有一个变量遗漏，那么你将无法访问该变量。请大家注意下面 .profile 文件结尾处的 export 命令。

下面列出的是一个标准的 .bash_profile 文件的拷贝，这个文件会在你的用户创建时自动生成。请注意 PATH 变量的赋值情况（通过 HOME 变量给其赋值）。 PATH 变量和 HOME 变量都是系统定义的特殊变量，它们已被系统所定义。 PATH 变量中保存目录的路径名，在执行任何输入的命令时都要对这些目录进行搜索，而 HOME 变量保存你的主目录路径名。赋值语句PATH=$PATH:$HOME/bin 起到了在重定义的过程中包含主目录中 bin 的目录的作用。因此，在执行任何命令的过程中，也将搜索你的 bin 目录，包括你自己定义的脚本程序或应用程序等。必须注意的是， PATH 必须用 export 命令进行输出，以便你创建的任何子 Shell 都能访问。如果你想对你的主目录也进行搜索，你可以在用 vi 或 Emacs 编辑器修改 .bash_profile 文件中的如下行： PATH=$PATH:$HOME ＼ bin:$HOME ，在上述行的末尾增加 :$HOME 。事实上，你可以在该行中增加任何你需要搜索的目录名。

.profile 文件清单

#.bash_profile

#Get the aliases and functions if ［ -f~/.bashrc ］ ; then

.~/.bashrc

#User-specific environment and startup programs

PATH=$PATH:$HOME/bin ENV=$HOME/.bashrc USERNAME=""

export USERNAME ENV PATH

Linux 系也有其自己的 profile 文件，任何用户登陆进入用户时，它都会执行。这个系统初始化文件就是 profile ，在 /etc 目录下可以找到该文件

（ /etc/profile ），里面包含了系统提供给每个用户的一些特殊变量的定义，该文件的清单在下面列出。请注意， PATH 变量重定义时包含了 /usr/X11R6/bin 目录。该目录路径包含了 X- W inodw 中用户在使用 Ca ldera Desktop 时要执行的的一些命令。 HISTFILE 也被重定义，它被赋值给一个较大的历史事件数。

/etc/profile 文件清单

# /etc/profile

# Systemwide environment and startup programs # Functions and aliases go in /etc/bashrc

PATH="$PATH:/usr/X11R6/bin" PS1= "［＼ u@ ＼ h ＼ W ］＼＼ $"

ulimit -c 1000000

umask 002

HOSTNAME='/bin/hostname' H ISTSIZE=1000

H ISTFILESIZE=1000

#Default page for the arena browser

WWW_HOME=fi le:/usr/doc/Calderadoc-0.80-1/Caldera_Info #Default path for CRiSplite

CRPATH=/usr/lib/ CRiSplite/Macros

export PATH PS1 HOSTNMAE HISTSIZE HISTFILESIZE WWW_HOME CRPATH

if ［ "$TERM"=conso l］ then

M IM ICOM="-l -m -con -tmc"; export MINICOM

初始化文件， profile 是一个文本文件，你可以用任何一个文本编辑器编辑该文件。通过编辑 .bash_profile 文件，你可以用编辑命令把一个新的目录路径名插入到目录路径名列表中去，从而非常方便地给 PATH 变量增加新的搜索路径。你也可以增加新的变量定义。但是，如果你定义了变量，必须记住：要在export 命令的参数列表中增加你所定义的变量名。例如，如果你的 .bash_profile 文件中没有变量 EXINIT 的任何定义，那么，你可以编辑该文件，并增加新的赋值语句给 EXINIT 变量赋值。赋值语句 EXINIT='set nu ai' 将设置 vi 编辑器带行号及自动缩进 (indentation)。然后，你需将 EXINIT 变量增加到 export 命令的变量参数列表中。当 .bash_profile 再一次被运行时，变量 EXINIT 将被赋值于命令行 set nu a i。当 vi 编辑器被执行时，变量 EXINIT 被赋值的命令行将被执

行，从而将编辑器 vi 自动设置成带行号，并进行自动缩进。

在下面的例子中，用户的 .bash_ profile 文件已经被修改，包含了变量 EXINIT 的定义，并重新定义了变量 CDPATH 、 PS1 及 H ISTSIZE 。变量 H ISTSIZE 在重定义时，其保存的历史事件号减少了，由系统 .profile 文件中定义的 1000 减少到 30 ；对特殊变量 PS1 的重定义，使系统提示符包括了当前的工作目录。你对文件 .bash_profile 中特殊变量的任何改变都将覆盖先前已在 .profile 系统文件中定义的特殊变量的值。然后，这些特殊变量需用 export 命令进行变量输出。

.profile 文件清单

# .bash_profile

# Get the aliases and functions if ［ -f ~/.bashrc ］ ; then

.~ /.bashrc

#User-specific environment and startup programs PATH=$PATH:$HOME/bin:$HOME

ENV=$HOME/.bashrc USERNAME=""

CDPATH=$CDPATH:$HOME/bin:$HOME H ISTSIZE=30

EXINIT='set nu ai'

PS1= "＼ w ＼ $"

export USERNAME ENV PATH CDPATH HISTSIZE EXINIT PS1

尽管 .profile 文件在你每次登陆进入系统时都会自动执行，但它不会在你每次修改就自动运行。因此，登陆初始化文件 .profile 仅仅在你每次登陆时才会自动运行。如果你想使你的修改起作用而又不想在每次修改后退出系统进行再登陆，那么，你可以用 “ .” 命令运行 .profile 文件。 .profile 文件是一个 Shell 脚本程序，和其它 Shell 脚本程序一样，在 “ .” 命令后键入 .profile 就可以运行该文件。

$ .profile

BASH Shell 初始化文件： .bashrc

.bashrc 文件是一个初始化文件，它在你每次进入 BASH Shell 或创建一新的子 Shell 时都会被执行。如果 BASH Shell 是你的登陆 Shell，那么，在你登陆时， .bashrc 文件会就会与文件 .bash_login 文件同时运行。如果你在另一种Shell 下进入 BASH Shell ，则 .bashrc 文件会自动运行，文件中的一些变量与别名就会被定义。

实际上，.bashrc Shell 初始化文件在你每次创建一个 Shell 时，都会被执行。例如，当你运行一个脚本 Shell 程序时。换句话说，每次创建一个子 Shell ，.bashrc 文件就会被执行。这时，在 .bashrc Shell 初始化文件中任何定义的局部变量或别名，在用 export 命令进行变量输出后，都会起作用。 .bashrc 文件中通常是一些别名与特征变量的定义，而这些特征变量是用来开启某些 Shell 特性的。

别名与特征变量是在 Shell 内局部定义的，但 .bashrc 文件将在创建一新的子Shell 中定义它们。因此， .bashrc 文件中通常是给 rm 、 cp 及 mv 等命令定义的别名。在下面的例子是一个具有许多标准定义的 .bashrc 例子文件。

.bashrc 文件清单

# Source global definitions if ［ -f /etc/bashrc ］ ; then

./etc/bashrc fi

set -o ignoreeof set -o noclobber

alias rm 'rm -i' alias mv 'mv -i' alias cp 'cp -i'

Linux 系统通常有一个名为 .bashrc 的系统文件，所有的用户在进入 Shell 时都要运行该文件。文件中有一些特定的全局别名与特征变量，这些别名与变量对任何进入 BASH Shell 的用户都是必不可少的。该文件位于 /etc 目录下

（ /etc/.bashrc ）。用户自己的 .bashrc 文件位于用户主目录下，该文件中包含很多必要的初始化命令。上面例子中的 ./etc/bashrc 文件正是用来做该项工作的。你可以在你自己的 .bashrc 文件中定义你自己的命令或定义。如果你修改

了 .bashrc 文件，且希望它们能在当前的登陆环境下起作用，你可以用 “ .” 命令或 source 命令重新执行该文件。

$ source .bashrc

BASH Shell 退出初始化文件： .bash_logout

.bash_logout 也是一个初始化文件，当用户退出系统时，将执行该文件。当你退出时，你可以指定系统执行你想做的操作。 .bash_logout 文件不是用来定义变量或别名的，而是通常由一些 Shell 命令组成的关机程序，也就是关机时你想要系统做的一些操作。通常希望系统退出时的操作是清屏，然后向用户发出祝福或结束信息。

和 .bash_profile 文件一样，你可以在 .bash_logout 文件中增加你自己的命令。实际上，在你的用户被创建时， .bash_logout 并不能自动建立。你需用 vi 或 Emacs 编辑器自己去创建该文件。你可以在该文件中加入退出祝福语或其它操作。在下面的例子中，用户在 .bash_logout 文件中加入 clear 命令和 echo 命令。当用户退出系统时， clear 命令将清屏，然后显示 “ Good-bye for now ” 信息。

.bash_logout 文件清单

clear

echo "Good-bye for now"

BASH Shell 程序设计

BASH Shell 具有和其它程序设计语言一样的编程能力，你可以用它设计出复杂的 Shell 程序。 Shell 程序由一些 Linux 命令组成，用来完成一些特定的任务。Linux Shell 能提供许多编程工具给用户，用户可以利用这些工具来创建 Shell 脚本程序。在 Shell 程序脚本中，你可以定义变量并赋值给它们，你也可以在脚本程序中定义变量。在执行该脚本程序时，用户还可以通过交互式方式给这些变量赋值； Linux Shell 还提供了循环、条件等控制结构。其中，循环结构用来多次执行某些 Linux 命令；条件结构用来控制、选择你要执行的命令；

你还可以建立算术或比较操作表达式。所有这些程序设计语句及控制结构与其它程序设计语言中相应的语句及控制结构类似。你可以用 Shell 变量、控制结构、表达式及 Linux 命令来进行 Shell 程序设计。通常由这些组成 shell 程序的指令编写成可以单独运行的脚本程序。你可以用任何标准编辑器来创建这些脚本文件。要运行该 Shell 程序，你只需执行该脚本文件即可。你甚至可以拆分到几个脚本文件中，每个文件都可以调用其它 Shell 脚本程序。可以把变量、表达式及控制结构看作是工具，通过这些工具把多个 Linux 命令组合成一个命令。从这种意义上说，一个 Shell 程序是用户创建的新的、复杂的 Linux 命令。

15.8.1 Shell 脚本程序：命令行及注释行

一个 Shell 脚本程序是一个由 Linux 命令组成的文本文件，你可以用任何文本编辑器来编辑它。你可以以 Shell 脚本程序的文件名作参数，用 sh 命令或“ .”

命令来执行脚本程序中的命令。你也可以设置文件的属性为 “ 可执行性 ”

（ executable ），然后在命令提示符后直接键入任何要运行的文件名去运行该脚本程序。用 chmod 命令来设置脚本程序的可执行性属性，可以把脚本程序设置成可执行文件。在用 chmod 命令修改文件的可执行性属性时，可以用绝对方式或符号方式。用符号方式 “ u+x ” 可修改文件的可执行性属性，例如命令行“ chmod u+x hello ” 将把脚本程序 hello 设置成可执行性。

然后，你可以直接运行脚本程序 hello ，如同使用一个 Linux 命令一样。你只需设置文件的可执行性属性一次。一旦你设置了它，该属性将保持，直至你改变其这一属性为止。

hello 脚本程序清单

echo "Hello, How are you"

$ chmod u+x hello

$ hello

Hello, how are you

在用绝对方式设置文件的可读、可写权限时将同时设置文件的可执行性属性。请参考本书第 7 章关于绝对方式与符号方式的详细解释与说明。简要地说， 700 将把文件设置成可写、可读及可执行权限， 500 将仅设置成可执行和可读权限， 300 设置成可执行和可写权限， 400 将只具有可执行权限。通常用户将权限设置成 700 或 500 。在下面的例子中，用户用绝对方式将文件 hello 设置成可执行权限。

$ chmod 750 hello

$ hello

hello, how are you

通常，在脚本文件中用简短的解释来说明文件的功能、特定命令与变量的作用和目的是非常有用的。你可以用注释行来进行简短的说明。注释行可以自成一行或是文本行的一部分，注释内容前必须用符号“ # ” 注明，但第一行除外。注释行以换行符为结束， Shell 将忽略任意行上符号 “ # ” 后的字符。 Shell 脚本程序的第一行是保留行，用来识别创建的 Shell 类型 ( 下面将会讨论到 )。在下面的例子中，描述脚本程序的文件名及其功能的注释行放置在该文件的文件头。

hello 脚本程序清单

# The hello script says hello echo "Hello, how are you"

有时希望在一种 Linux Shell 下运行为另一种 Shell 编写设计的脚本程序。假设你目前在 TCSH Shell 下，而想运行一个为 BASH Shell 编写设计的脚本程序（该脚本程序包含了一些 BASH Shell 命令），首先，你必须用 sh 命令把该Shell 脚本程序转换成 BASH Shell 脚本程序，然后运行该脚本程序，最后在转换成 TCSH Shell 。然而，你可以自动进行这一过程：在你的脚本程序的首行键入字符串 “ # !” ，然后键入你系统的 Shell 程序的路径名。 Shell 始终首先检查脚本程序的最初一个字符，以辨认该脚本程序是 BASH Shell 脚本程序还是PDKSH Shell 脚本程序亦或 TCSH Shell 脚本程序。如果最初字符是空格，那么，该脚本程序便被假定为 BASH Shell 脚本程序或 PDKSH Shell 脚本程序；如果只是单独的 “ # ” 号（无 “ !” 号），该脚本将被假定为 TCSH Shell 脚本程序。但是，如果 “ # ” 号后面跟着字符 “ !” ，那么， Shell 将读取其后的 Shell 类型路径名。字符串 “ # !” 后面始终是 Shell 类型的路径名，用来确定该 Shell 脚本程序运行的 Shell 类型。如果你目前在与某脚本程序运行环境不同的 Shell

下，当前 Shell 将读取 Shell 脚本程序中 Shell 的路径名，并转换至该 Shell 下执行此脚本程序。但此时如果其初始字符是空格或 “ ＃ ” 号，当前 Shell 将无法确定该脚本程序是 BASH Shell 脚本程序还是 TCSH Shell 脚本程序。这时，该 Shell 脚本程序将仅能在它的所在的 Shell 环境下才能运行。如果你想让 Shell 辨认你的脚本程序的 Shell 类别，你必须在字符串“ # !”后面键入你所运行的 Shell 类型。

例如，如果你在脚本程序 hello 的首行键入字符串 “ #!/bin/sh ” ，你就可以

在 TCSH Shell 中直接运行该脚本程序。运行时，系统首先将改变到 BASH Shell 下，然后执行该脚本程序的命令，然后返回 TCSH Shell 或任意执行该脚本时的 Shell 。在下面的例子中， hello 脚本程序输入了 “ #!/bin/sh ” 命令，然后用户可以在 TCSH Shell 中执行该脚本程序。

hello 脚本程序清单

#!/bin/sh

# The hello script says hello echo "Hello, how are you"

hello

Hello, how are you

变量与脚本程序

在 Shell 中，你可以用变量及脚本语句来创建 Shell 程序。在 Shell 脚本程序中，你可以定义变量并给它们赋值。变量定义在本书第 5 章已详细讨论过。由于变量定义在 Shell 程序设计过程中非常有用，作者在这将会简要介绍。

在 Shell 脚本程序的输入、输出操作中，变量使用的非常多。 read 命令允许用户交互式地给一个变量赋值。当需要用户进行数据输入时，程序设计者通常会给用户一个提示去通知用户。另一种脚本程序数据输入方式称之为 Here 文件方式，它允许你为程序中的命令提供多行输入。该数据输入方式克服了总需要通过读取外部文件等方式来进行多行数据输入。

变量的定义与赋值： = 、 $ 、 set 及 unset

在 Shell 中，当你首次使用变量的名字的时候，需要对一变量进行声明。变量的名字可以是任何一组字母组成的字符或字符串，包括下划线。变量名也可以包含数字，但数字不能作为变量的第一个字母。变量名中不能有如下字符，如 “ !” 号、 “ & ” 字符及空格等。有些变量是 Shell 保留的，只能被 Shell 自己使用。变量名也不能包含几个英文单词，因为系统要使用空格去对命令进行句法分析，并用它分隔命令名及其参数。

你可以用赋值操作给一个变量赋值：键入变量的名，然后键入赋值操作“ = ”，再键入相关数据，变量将被赋值。需指出的是，赋值操作语句中不能有任何空格。任何一组字符串都可以赋值给一个变量。在下面的例子中，变量 greeting 被赋以字符串 “ Hello ”。

$ greeting="Hello"

一旦你给一个变量赋值，你就可以使用该变量，并引用它的值。通常我们引用变量的值作为一个命令的参数。你可以在变量前面加美元字符 “ $ ” 来引用变量的值。 “ $ ” 字符是一个特殊操作符，它用变量的名来引用变量的值。该引用将导致命令行上的变量名被一组字符窜所代替。这样，任何在变量名前有“ $ ” 字符的地方，变量名将由变量的值所代替。

$ echo $greeting Hello

你可以用 set 命令来列出所有已定义的变量的列表。如果你认为不再需要某变量，可用 unset 命令来删除该变量。

说明：表 15-3 列出了一些常用的 BASH Shell 命令及其命令参数与功能，如 echo 、 read 及 break 等。

变量值：字符串

你赋值给变量的值可能是由一组字符组成的字符串。这些字符可能是你直接输入的，也有可能是你执行一个 Linux 命令后的得到的结果。大多数情况下，你需要用单引号、双引号、反斜扛号及回引号等去引用这些变量的值。单引号、双引号、反斜扛及回引号能让用户以不同的方式引用字符串的值。回引号 “ '” 的特殊功能在于：当执行一个 Linux 命令时，它同时把执行的结果作为命令行上的一个命令行参数。

字符串引用：双引号、单引号和反斜扛

尽管字符变量的值可以由任何字符串组成，但当你在字符串中包含了一些特殊字符，而这些特殊字符又是被 Shell 作为操作算子的，这时脚本程序就可能会出现问题。 Shell 有一类特殊的字符，它们可以被用在命令行赋值中。星号 “ * ” 、问号 “ ? ” 、括号 “ （ ” 及 “ ） ” 等都是一组特殊字符，这些特殊字符可以实现文件名扩展。此外，特殊字符 “ .” 代表当前的目录， “ $ ” 代表变量的值，大于符 “ > ” 及小于符 “ < ” 是重定向操作算子，符号 “ & ” 用来执行后台命令，而符号 “ |” 表示通过管道输出执行的结果。如果你想使用上述特殊字符作为你变量值的一部分，你必须首先引用它们。在命令行上引用一个特殊变量字符时，它不会被 Shell 解释为一个特殊字符。

单引号及双引号允许你同时引用几个特殊变量，任何在单引号及双引号内的特殊字符都会被引用。一个反斜扛只引用单个字符（其前面的字符）。如果你想把多个单词赋值给一个变量，你需用单引号去把那些用空格定界的单词括起来（你也可以用双引号），认为是把一个字符串赋值给了一个变量。当然，任何在双引号内的特殊字符也会被引用。

下面的例子用三种方法去给字符类型变量赋值。在第一个例子中，用把双引号内用空格定界的单词赋值给变量 notice 。由于空格是在双引号内的，因此，它们被认为是普通的字符，而不是 Shell 用来分割命令行参数的定界符。在第二个例子中，单引号内的字符串也被赋值给变量 message ，特殊字符 “ .” 被认为是一个普通的字符。在第三个例子中，星号 “ * ” 特殊字符被括在双引号内，该字符也被认为是字符串内的一个普通字符，而 Shell 不会认为它是一个通配符。

$ notice="The meeting will be tomorrow"

$ echo $notice

The meeting will be tomorrow

$ message='The project is on time.'

$ echo $ message The project is on time.

$ notice="You can get a list of files with ls *.c"

$ echo $notice

You can get a list of files with ls *.c

但是，双引号中的特殊字符 “ $ ” 不会被赋值给变量，该特殊字符用来引用变量的值。在双引号内的 “ $ ” 字符后的变量仍然将代表该变量的值，而该变量的值将成为字符串的一部分，而不是变量名成为字符串的一部分。在双引号内你可以使用该方法来引用多个变量的值。在下面的例子中，变量 winner 的值将被 notice 变量引用。

$ winner=dylan

$ notice="The person who won is $ winner"

$ echo $notice

The person who won is dylan

另一方面，如果你也不想在双引号内引用一个变量的值，你可以用单引号来把赋值的字符窜括起来。此时，单引号将忽略字符串内的任何引用，而把特

殊字符 “ $ ” 仅看作为一个普通的字符。在下面的例子中，单引号忽略了其内的变量 winner 的引用。

$ winner=dylan

$ result='The name is the $winner variable'

$ echo $result

The name is the $winner variable

此时，如果用的是双引号，那么，变量 winner 的值将会被变量 result 引用。看下面的例子：字符串 “ $winne r” 被变量 winner 的值替换。

$ winner=dylan

$ result="The name is the $winner variable"

$ echo $result

The name is the dylan variable

你可以用反斜扛特殊字符 “ ＼ ” 来在字符串中使用任何特殊字符，包括特殊字符 “ $ ” 。当你在赋值的字符串中同时包括变量值引用及普通字符 “ $ ” 时，你必须用到反斜扛字符 “ ＼ ” 。在下面的例子中，为了把特殊字符 “ $ ” 看作一个普通的美元字符，你可以在其前面输入一反斜扛字符，及用字符串 “ ＼ $ ” 表示。同时，由于字符串是用双引号括起来的，因此， $winner 将引用变量 winner 的值。

$ winner=dylan

$ result="$winner won ＼ $100.00"

$ echo $reuslt dylan won $100.00

Linux 命令的值：回引号 “ '” （ back qutoes ）

尽管你可以通过定义字符或字符串变量来引用变量的值，你还可以直接把Linux 命令的运行结果赋值给变量。但是，如果你要把 Linux 命令的运行结果赋值给变量，你必须首先运行该命令。如果你在命令行上输入 Linux 命令，该命令首先将会被执行，它的执行结果将成为命令行的一个参数。如果把将要首先运行的 Linux 命令放置在回引号内，命令的运行结果将被赋值给变量。我们也可以把回引号看作是一个表达式，而该表达式是包含了一个将要运行的 Linux 命令及其运行的结果。

在下面的例子中，命令 ls *.c 首先将被执行，而其运行结果将被赋值给变量listc。命令 ls *.c 用来列出所有扩展名为 .c 的文件，然后，这个文件名列表将被赋值给变量 listc 。

$ listc='ls *.c'

$ echo $listc main.c prog.c lib.c

必须注意回引号与单引号之间的区别：单引号把一个 Linux 命令看作是一组字符串，而回引号将表示它是一个 Linux 命令，并会执行这个 Linux 命令。有时，你可能在想要使用回引号时无意间输入了单引号。下面的两个例子说明了两者之间的区别。对于第一个例子，赋值给变量 lscc 的值是用单引号而不是回引号，此时， “ ls *.c ” 仅被看作是一个字符串赋值给变量 lscc 。对于第二个例子，字符串 “ ls *.c ” 是用回引号括起来的，因此，该命令将会被执行。于是，所有那些以 .c 为扩展名的文件名生成一个文件名列表，然后该文件名列表被赋

值给变量 lscc 。

$ lscc='ls *.c'

$ echo $lscc ls *.c

$ lscc='ls *.c'

$ echo $lscc main.c prog.c

引用命令：单引号

有时，你可能会在一个 Linux 命令上使用单引号。在 Linux 命令上使用单引号可以使你把一个 Linux 命令赋值给一个变量，此时，你可以把该变量作为该Linux 命令的另外一个名字。如果在命令行上输入该变量的名之前键入操作算子 “ $ ” ，该变量所代表的 Linux 命令将被执行。在下面的例子中， Shell 变量被赋值以 Linux 命令 ls -F ，必须注意命令上的单引号。当 Shell 变量在命令行上被赋值的时候，包含该命令的变量将成为一个命令行参数，且其包含的命令将会被执行。

$ lsf='ls -F'

$ $lsf

mydata /report/letters

实际上，与别名命令类似，该变量是你为 Linux 命令创建的另外一个名字。在余下的章节中可以看到，在特定的 Shell 环境下，你可以用一个特别的别名

命令来完成上述操作。

脚本输入与输出命令： echo 、 read 及 <<

在一个脚本程序中，你可以使用 echo 命令来输出数据，而用 read 命令来读取输入数据给变量。此外，你还可以使用 Here 文件来在脚本中指定数据，并把它们重定向给一个命令。

在脚本程序中， echo 命令可以把数据送到标准输出，这些数据可能是以字符串形式输出的字符。你将会发现， echo 命令可以输出变量的值，也可以输出常量字符串。

read 命令可以从终端上读取一行输入数据，并赋值给一个或多个变量。该命令可以使用户交互式地给变量赋值。的直至换行符的任何字符都将被读入，并把这些读入的字符赋值给变量。在 Shell 程序中，你可以一起使用 echo 命令与 read 命令，以便提示用户输入数据，输入数据后， read 命令将把读入的数据赋值给变量。在下面的 greetvar 脚本程序中，用户被提示输入数据给变量greeting ，然后， read 命令读取用户键入的数据，并赋值给变量 greeting。

greetvar 脚本程序清单：

echo Pease enter a greeting:

read greeting

echo "The greeting you enter was $greeting"

$ greetvar

P lease enter a greeting:

The greeting you enter was Hi

当处理用户的输入时，你必须考虑到用户有可能输入 Shell 特殊字符。Linux 命令中的任何特殊字符，无论它是在脚本程序还是在其它地方，该特殊字符都将被引用，除非它们被引号括起来。如果一个变量的值是一个特殊字符，且变量的值是用 $ 来引用的，那么， Shell 将认为是一个特殊字符，并把它用变量的值代替。在脚本程序 greetvar 程序中， $greeting 被放置在一个被引号括起来的字符串中，从而可以使用特殊字符 “ $ ” 来求变量 greeting 的值。否则，如果

$greeting 所在的字符串没有被用括号括起来，那么，特殊字符的意义将被扩展。有时，你也希望那些特殊字符被扩展，例如，你想列出所有以用户输入的字符为前缀的文件时，此时，用户输入的任何特殊字符的意义都需被扩展。在下面的例子中，脚本程序中的特殊字符 “ *” 被扩展，以显示以扩展名为 .c 的所有文件。请注意 $fref 没有被双引号括起来。

listfile 脚本程序清单：

echo Please enter a file reference: read fref

echo The files you request are: $fref

$listfiles

P lease enter a file reference:

*.c

The files you request are: calc.c lib.c main.c

通常情况下， Shell 脚本程序包含一系列的 Linux Shell 命令，但有时，你可能需要把输入的数据作为一个命令的参数，例如，如果你想把多行数据输入给 Shell 脚本程序中的某个命令。 Here 操作可以达到上述目的。 Here 操作是一个重定向操作，用来把 Shell 脚本中读入的数据重定向给一个命令。它之所以称为 Here 操作是因为重定向数据是来自脚本程序，而不是来自其它的文件。Here 操作用两个小于号 “ << ” 来表示。 “ << ” 操作可以认为是一个重定向操作，它用来把脚本程序中的数据输入给一个命令。 “ << ” 操作算子放置在它要被重定向的命令之后， “ << ” 后的输入数据将被认为是输入给命令的数据。你可以用CTRL-d 操作来结束数据输入。你也可以不使用 CTRL-d 而用自己指定的一个结束符来结束本次数据输入，这时，在同一行上、 “ << ” 操作算子之后的单词将被认为是本次数据输入的结束符。该结束符可以是任何符号。所有至结束符之前的数据行都将被作为其重定向命令的输入。

在下面的例子中，一些信息被发送给用户 mark ，其中，发送的信息来自于

Here 操作。本次 Here 操作使用的结束符是单词 “ myend ” 。

mailmark 脚本程序清单：

mail mark << myend

D id you remember the meeting Robert

myend

脚本程序命令行参数

与 Linux 命令一样，一个 Shell 脚本程序也可以有其运行参数。当你启动一个脚本程序时，你可以在命令行上键入脚本程序名，然后输入运行该脚本程序的一些运行参数。你可以在脚本程序中用 “ $ ” 操作算子及其在命令行上的参数序号来引用这些参数。命令行上的参数按顺序从 1 开始编号，第一个参数可以用 “ $1 ” 来引用，而其第二个参数可以用 “ $2 ” 来引用，依此类推。 “ $0 ” 将引用该命令行上的第一个字符，即 Shell 脚本程序名本身。

所有对这些参数的引用都可以被认为是对只读变量的值的引用。如果你比

较熟悉程序设计语言中的术语，那么，你可以把命令行上的参数认为是系统赋值给参数变量 $1 及 $9 等的值，而参数变量在脚本程序运行的过程中是只读的，你不能再给它们赋值。一旦系统给它们赋初值后，你不能再改变这些参数变量的值。从这种意义上说，参数变量更像常数，这些常数是由命令行参数确定的。除非被引号括起来，命令行上的每一个单词将会被认为是命令行上一个独立的参数。如果你在命令行上输入了多个参数，那么，可以用相应的参数号来引用它们。在下面的例子中，命令行上输入了四个参数。

greetargs 脚本程序清单：

echo "The first argument is: $1" echo "The second argument is: $2" echo "The third argument is: $3" echo "The fourth argument is: $4"

$ greetargs Hello Hi Salutation "How are you" The first argument is:Hello

The second argument is: Hi

The third argument is:Salutation The fourth argument is:How are you

你可以用一组特殊字符以各种方式去引用命令行上的命令参数，例如“ $ *”、“ $@ ” 及 “ $# ” 等。其中， “ $# ” 代表命令行上的参数个数，这在为一个脚本程序指定固定的参数数目时很有用。“ $* ” 用来代表命令行上的所有参数（在一个命令行上可以有多达 9 个输入参数）。“ $@ ” 也代表命令行上的所有参数，但它可以使你单独引用所有命令行参数中的每个参数。 “ $ *” 与 “ $@ ” 命令之间的区别不是很明显，但当你使用 for-in 控制结构引用命令行参数时，你就可以很好地理解它们之间的差别。因此，本节将对这些特殊参数只作简要介绍，在本章后面的控制结构中将有更详细的介绍。

在下面的例子中，命令行参数先后被用特殊变量 “ $* ” 及 “ $@ ” 显示在屏幕上。命令行上的参数数量被特殊变量 “ $# ” 显示在屏幕上。

sargs 脚本程序清单：

echo $* echo $@

echo "There are $# arguments"

$ sargs Hello Hi W elcome Hello Hi W elcome

Hello Hi W elcome There are 3 arguments

输出变量与脚本 Shell

当你执行一个脚本程序的时候，你将初始化一个新的进程，而该进程有其自己的 Shell 。在该进程的 Shell 中，你可以自己定义变量、执行 Linux 命令，甚至执行其它的脚本程序。如果你在当前正在运行的脚本程序中执行另一个脚本程序，那么，当前正在被执行的脚本程序将被挂起，系统控制被转换到执行的另一个脚本程序上，在返回到被挂起的脚本程序之前，此脚本程序中的所有的命令都将首先被执行，然后再返回至被挂起的脚本程序中继续执行。

从一个脚本程序中执行另一个脚本程序的过程与程序设计语言中的函数或

过程调用很相似。你可以认为是一个脚本程序在调用另一个脚本程序，直到被调用的脚本程序执行结束后，调用该程序的脚本程序才开始继续执行其余下的命令。

任何在你脚本程序中定义的变量都会在它对应的脚本 Shell 中定义，这些定义的变量只是局部变量，它只在它自己的 Shell 中起作用。从这种意义上说，有些变量是被隐藏在它们自己的 Shell 之中。但是，有时你希望在脚本程序中定义的变量可以在其调用的任何脚本程序中起作用。虽然你不能直接定义这样的变量，但你可以用 exort 命令把你定义的变量输出到另外一个脚本程序中。当你用 export 命令输出一个变量时，该命令将告诉系统在每个新创建的子 Shell 中都定义一个该变量的拷贝。于是每个新创建的子 Shell 都可以有该输出变量的拷贝。在下面的例子中，变量 myname 被定义，特殊也被用 export 命令输出。

$ myname="Charles"

$ export myname

通常有的读者把输出变量理解为全局变量，这种理解实际上是错误的。一

个 Shell 决不会引用一个在其外部定义的变量。如果在一个 Shell 内输出了一个变量，在创建新 Shell 时，系统只是在其子 Shell 中生成了该输出变量的值的一个拷贝，即输出变量只输出它们的值，而不是该变量本身。从某种程度上说，一个输出变量是一个限定范围内的全局参数（ a scoped global paramete r），系统会把该变量的值拷贝至在该 Shell 上创建的任何子 Shell 中。任何在输出变量后的 Shell 下直接或间接调用的 Shell 脚本程序都会得到输出变量初始值的一个拷贝。

Shell 算术赋值操作： let 命令

let 命令是 BASH Shell 下对数字型变量进行操作的操作算子。通过该命令，你可以比较两个值或者执行算术操作如加法、乘法等。这些操作算子通常被用在 Shell 程序中，以管理控制结构或执行必要的计算。 let 命令用关键词 let 来标识。该命令的句法如下：关键词 let 后跟着两个数字，而数字之间由一个算术或关系操作算子把它们分隔开。

$ let value1 operator value2

你可以使用表 15-4 列出的任何操作算子。 let 自动假定操作算子是算术算子或关系算子。你不必象在 Shell 用变量求值符 “ $ ” 去求变量的值，因为 let 命令会自动求出变量的值，并把它们的值转换成数字。这也意味着你可以在你的数字算子中使用简单的数字表达式。在下面的例子中， let 命令把 2 和 7 相乘，相乘后的结果输出到标准输出。

$ let 2*7

如果你想在算术表达式的操作数之间输入空格，你必须用双引号把整个算术表达式括起来。此时， let 表达式如下：

$ let "2 * 7 "

你也可以在 let 表达式中包含赋值操作算子。在下面的例子中，乘法的计算结果被赋值给变量 res 。

$ let "res = 2 * 7 "

$ echo $res 14

你也可以在数字之间使用任何关系操作算子来进行比较操作，例如，可以用关系算子来检查一个数字是否大于另一个数字。关系操作算子通常用来管理控制结构，例如循环控制结构或条件控制结构。在下面的例子中，脚本程序helloprg 显示字符串 “ Hello ” 三次。该程序用 let 命令小于或等于操作算子来管理控制循环（ let "again <= 3" ），并用 let 命令使变量 again 逐次加 1（ let "again

= again +1" ）。必须注意，当变量 again 被加 1 时，变量前不必加入求值符号“ $ ” ， let 命令将在表达式中自动求出变量 again 的值。

helloprg 脚本程序清单：

again=1

while let "again <= 3" do

echo $again Hello let "again = again +1 "

done

$ Helloprg 1 Hello

Hello
Hello
1. 控制结构

你可以在 Shell 程序脚本中使用 Shell 控制结构来控制 Linux 命令的执行。控制结构可以使你重复执行某个命令或者在选择执行一些命令中特定的一个或几个命令。控制结构主要由两部分组成：测试条件命令与要执行的命令。如果测试条件返回条件为真，则其后的命令将被执行。因此通过使用控制结构这种方式，你可以在可能将要执行的命令之间作出选择。

主要有两类不同的控制结构：循环控制结构及条件控制结构。循环控制结构用来重复执行一些命令，而条件控制结构只有在满足某种条件时才执行相应的命令。BASH Shell 有三种主要的循环控制结构： W hile 循环、for 循环及 for-in 循环；有两种条件控制结构： if 条件控制结构及 case 条件控制结构。

while 及 if 控制结构是更常见的控制结构，用它们可以实现多种功能，如执行重复操作及在各种不同的测试条件下作出选择等。 case 及 for 控制结构是更专门化的控制结构。 case 控制结构是 if 条件控制结构的一种受限形式，它常用

来实现菜单； for 控制结构是一种有限次循环结构，它在执行每个循环的过程中会把列表中一系列的赋值给变量，直至这些列表中的值被赋值完毕。

if 及 while 控制结构以运行 Linux 命令作为它们的测试条件。所有的 Linux 命令在它们这些完毕后都会返回一个退出状态（ exit status ），如果该命令被成功执行，那么，该命令返回的退出状态为 0 ，如果该命令由于某种原因运行失败，那么，该命令返回的退出状态将会是一个正整数，这个数具体与它们的失败原因有关。 if 及 while 控制结构将检查执行的 Linux 命令的返回值，看这一返回值是 0 还是其它的数字。对于 if 及 while 控制结构，如果测试命令的退出状态是 0 ，这测试条件命令被成功执行，然后开始执行控制结构中的命令。

测试命令

通常，你可能需执行一个比较测试操作，通过该操作来比较两个值的大小，而在控制结构中使用的测试操作是一个 Linux 命令，不是一个关系表达式。但如果要在控制结构中比较两个值，你可以用 Linux 系统中的 test 命令来执行这一比较操作。 test 命令将比较两个值，并返回该命令的退出状态，如果该命令被成功执行，其返回状态将为 0 。

通过 test 命令，你可以比较整数、字符串，甚至执行一个逻辑操作。该命令由关键词 test 开头，其后是要比较的值，这两个比较的值之间被一个选项分隔开（该选项用来指定要进行比较的类别）。这个选项可以认为是一个操作算子，只是在输入该选项的时候用一个负号 “ -” 及一个字母表示，例如， -eq 选项表示比较两个值之间是否相等。但是，对于两个字符窜比较操作实际上是一个操作算子，而不是一个选项。当你比较两个字符串是否相等的时候，你要使

用等号 “ = ” ，对于不等号，用 “ != ” 表示。表 15-5 中列出了 test 命令中使用的所有选项与操作算子。 test 命令的句法如下：

test value -option value test string = string

在下面的一个例子中，用户比较两个整数是否相等。此时，你需使用相等选项 -eq ，该命令通过 test 命令的退出状态来检查测试操作的测试结果。 Shell 特殊变量 “ $? ” 用来保存最近一个 Linux 命令的退出状态（返回值）。

$ num=5

$ test $num -eq 10

$ echo $?

你也可以使用方括号而不用 test 命令中的 test 关键词。例如，对于 test 命令 test $greeting="hi" ，你可以些写成：

$ ［ $greeting = "hi" ］

同样， test 命令 test $num -eq 10 也可以写成：

$ ［ $num -eq 10 ］

方括号本身与其它字符之间必须用空白字符隔开，这些空白字符可以是空格、 TAB 键或回车符等，如果没有空白字符，那么，该命令是无效的。

test 命令是一个 Linux 系统命令，该命令在测试控制结构中被大量使用。必须注意，该命令对字符串及整数等类型有不同的选项。同时，不要混淆字符串比较与整数比较选项之间的区别，对于比较两个字符串是否相等，用选项“ = ” ，

而对两个整数的比较，需用选项 “ -eq ” 。

条件控制结构： if、 if-else 、 elif 及 case

BASH Shell 中有一组条件控制结构，这组控制结构允许你选择要执行的命令。这些控制结构基本上与其它程序设计语言中的条件控制结构基本相同，但仍然有一些差别。 if 条件控制结构用来测试一个 Linux 命令的执行后的退出状态（返回值），而不是一个表达式。此外， if-then 条件控制结构必须以关键词 fi 结尾，而 case 命令必须用关键词 esac 结尾。条件控制结构的详细句法见表15-6 。

if-then 条件控制结构

if 条件控制结构用来在命令执行之前设置一个条件选项，该条件选项是一个指定的 Linux 命令的退出状态（返回值）。如果该命令被成功运行，其返回值将为 0 ，然后， if 控制结构中的命令将被执行；如果该命令的返回值为一个任何非 0 值，这表明该命令运行失败，则 if 控制结构内的命令将不会被执行。

if 控制结构以关键词 if 开头，其后跟一个 Linux 命令，该命令的退出状态（返回值）将被引用，且该命令始终将会被执行；该命令之后是另起一行的关键词then ，再其后可以是任何一组 Linux 命令。最后，由关键词 fi 来结束该条件控制结构。通常你需根据一个 Linux 命令是否成功执行来在两组可能的命令之间作出选择，其中， else 关键词正是用来使 if 控制结构在这两个可能的选项之间作出选择。如果 Linux 命令成功运行，那么，关键词 then 后的命令将被执行；反之，如果该命令运行失败，那么，关键词 else 命令之后的命令将被执行。 if-

then-else 控制结构的句法如下：

if Linux Command then

commands else commands fi

下面的脚本例子程序 elsels 用来执行带不同选项的列文件命令 -ls 命令，这两个可能的选项是或者列出文件的大小，或者列出文件的所有信息。

elsels 脚本程序清单

echo Enter s to list file sizes,

echo otherwise all file information is listed. echo -n "Please enter option:"

read choice

if ［ "$choice" = s ］

then ls -s

else ls -l fi

echo Good-bye

$ elsels

Enter s to list file sizes,

otherwise all file informaton is listed.

P lease enter option: s total 2

1 monday 2 today Good-bye

在 Shell 脚本程序中， if 控制结构也通常被用来检查用户是否输入了合适的参数数。特殊 Shell 变量 “ # ” 将保存用户输入的参数数量。在测试命令中使用“ $# ” ，可以检查用户是否输入了正确的参数数。

如果用户在命令行上输入了不正确的参数个数，你可以结束该 Shell 脚本程序的执行。你可以用 exit 命令来结束 Shell 脚本程序，并返回退出状态。 exit 命令可以返回一个参数值，

例如，返回值为 0 表明该脚本程序成功运行后结束，而其它返回值，如 1 ，表明脚本程序运行时发生了错误。在下面的例子中， ifarg 脚本程序只需输入一个参数。如果用户在输入参数的过程中少输入了一个命令行参数，或者用户多输入了一个命令行参数， if 条件控制结构将为真，错误的消息将被打印出，脚本程序也将退出，并返回一个表示程序运行出错的一个返回值。

ifarg 脚本程序清单：

if ［ $# -ne 1 ］

then

echo Invalid number of arguments exit 1

exho $1

$ ifarg

Invalid number of argumnets

elif 控制结构允许你在该控制结构中嵌入 if-then-else 控制结构。 elif 结构表示 “ else if” ，该控制结构可以使你在几个可能的选项之间作出选择。第一个选项用 if 结构指定，其后跟另一个可能选项，每个可能选项都由其自己的 elif 控制结构指定。最后一个 elif 控制结构的可能选项用 else 来指定。如果第一个 if 控制结构的条件测试失败，那么，控制结构将把程序控制流程传递给其后的 elif 控制结构，如果又失败，那么，程序控制流程将传递给下一个 elif 控制结构。该过程直至到满足条件的测试命令，然后，该 elif 控制结构中的命令将被执行。最后，程序的控制流程传递给以 fi 关键词结尾的 if 控制结构之外。

逻辑命令： && 及 ||

逻辑命令用来对两个 Linux 命令执行逻辑操作。该命令的句法如下：

command && command

command || command

对于逻辑与 “ && ” ，如果两个命令都成功运行，那么，该逻辑命令的退出状态（返回值）为 0 。对于逻辑或 “ ||” ，如果任何一个命令成功运行，那么，逻辑或命令成功运行，并该返回该命令的退出状态为 0 。逻辑命令可以使你在控制结构的测试命令中使用逻辑操作。

case

case 控制结构可以使你在几个可能的选项之间作出选择。它通过一个字符串与其它几个可能的模式之间的比较结果来作出相应选择。每个可能的模式都与一组操作相关联。如果找到与字符串匹配的模式，那么，与该模式相关的一组操作将被执行。 case 控制结构以关键词 case 开始，其后跟一个字符串变量，然后是关键词 in ，再其后是一组可能的模式 ,每个模式可以是一个正则表达式，并以回括符结束。在回括符之后是列出的与该模式想关联的一组命令，再在一个独立的行上输入两个分号 “ ;” ，表明与该模式关联的一组命令已经结束。最后是以关键词 esac 结尾的 case 命令。该控制结构的句法如下：

case string in pattern) commands

;;

pattern) commands

;;

default commands

;;

esac

在上面的模式中可以包含任何 Shell 特殊字符。这些 Shell 特殊可以是“ * ”、“ ［］ ” 、 “ ? ” 及 “ |” 等。你可以用单个特殊字符 “ * ” 来指定一个缺省的模式。该特殊字符 “ * ” 可以与任何模式匹配，因此，它可以作为一个非常有用的缺省项。如果字符串与所有的模式都不匹配，则它必与特殊字符 “ * ” 匹配。这样，如果没有与指定的字符串匹配的模式，缺省项将被执行。缺省项是可选的，你可以不输入该项。

一个 case 结构通常用来实现菜单。在下面的脚本程序 ischoice 中，程序问用户以何种形式列出当前目录下的所有文件。注意，本程序中的缺省项用来警告用户输入无效。

lschoice 脚本程序清单：

#Program to allow the user to select different ways of # listing files

echo s. List Sizes

echo l. List all File Information echo c. List C Files

echo -n "Please enter choice: " read choice

case $choice in

s) ls -s

;;

s) ls -l

;;

c) ls *.c

;;

echo Invalid Option esac

$ lschoice

s. List Sizes

l. List all File Information

c. List C Files

P lease enter choice: c main.c lib.c file.c

循环控制结构： wh ile ， for-in 及 for

BASH Shell 有一组循环控制结构，这组循环控制结构允许你重复执行一个

Linux 命令。这些循环控制命令是：while 、for-in 及 for 控制结构。与 BASH Shell 中的 if 控制结构一样， while 及 until 控制结构也需测试一个 Linux 命令的执行结果。但是， for 及 for-in 控制结构不用执行条件测试命令。它们只是简单地把列表中的一系列值依次赋值给指定的变量来重复执行循环命令。此外， while 及until 控制结构与在其它程序设计语言中的相应结构类似，但 for 及 for-in 控制结构却有很大的不同。循环控制结构的用法见表 15-6 。

Wh ile 循环控制结构

while 循环控制结构用来重复执行命令。 while 循环控制结构以关键词 while 开头，其后是一个 Linux 命令，然后下一行是 do 关键词。该结构用关键词 done 表示循环控制的结束。

下面是 whle 循环控制结构的句法：

while Linux command do

commands done

while 控制结构中的 Linux 命令通常是一个用方括号括起来的测试命令。在下面的脚本程序 myname 中，程序要求用户输入用户名，然后，该程序打印出用户的名字。该循环控制结构通过用 test 命令（以用方括号括起来的方式）来测试变量的值。

myname 脚本程序清单：

again=yes

while ［ "$again" = yes ］

echo -n "Please enter a name:" read name

echo "The name you entered is $name"

echo -n "Do you wish to continute ?" read again

done

echo Good-bye

$ myname

P lease enter a name: George The name you entered is George Do you wish to continute? yes

P lease enter a name: Robert The name you entered is Robert Do you wish to continute? no Good-bye

for-in 循环控制结构

for-in 循环控制结构可以用来依次引用一列表中的值。该控制结构有两个操

作数：一个变量及一个值列表。在 for-in 循环控制结构中，列表中的每一个值被依次赋值给变量。与 W hile 循环控制结构一样， for-in 控制结构也是一种循环控制结构，每执行一次该循环后，列表中的下一个值将被赋值给变量。当到达值列表的表尾后， for-in 循环控制结构将会停止。与 while 循环一样， for-in 控制结构的循环体以关键词 do 开头，以关键词 done 为结束。

for-in 控制结构的句法如下：

for variable in list-of-values do

commands done

在下面的脚本程序 mylistfor 中，用户简单地输出列表中的每个项，并在列表项后加上当天的日期。该列表中的每个项被依次赋值给变量 grocery。

mylistfor 脚本程序清单：

tdate='date+D'

for grocery in milk cookies apples cheese do

echo "$grocery $tdate" done

$ mylistfor

m ilk12/23/93 cookies 12/23/93 apples 12/23/93

cheese 12/23/93

for-in 循环控制结构在管理文件时非常方便。你可以使用特殊字符来生成一个文件名列表，然后在 for-in 循环控制结构中使用这个文件名列表。例如，特殊字符 “ * ” 将列出当前目录下的所有文件，而 “ *.c ” 将列出当前目录下所有扩展名为 .c 的文件。如果在 for-in 控制结构中使用特殊字符 “ * ” （见下例）将生成由你当前目录下的所有文件名组成的列表。

for myfiles in * do commands done

下面的脚本程序 cbackup 用来把当前目录下的所有扩展名为 .c 的文件拷贝到名为 sourcebak

的目录下。请注意，该例子中特殊字符 “ * ” 的使用。

cbackup 脚本程序清单：

for backfile in *.c do

cp $backfile sourcebak/$backfile

echo $backfile done

$ cbackup io.c

lib.c main.c

for 循环控制结构

for 循环控制结构中没有如 for-in 控制结构中使用的值列表（ for-in 控制结

构中用该值列表来作为命令行参数）。对于 for 循环控制结构，它把运行脚本程序时输入的命令行参数作为其循环值列表，而 for 命令将自动依次把这些值赋值给 for 循环中的变量。

在执行第一次循环时，命令行的第一个参数将被赋值给 for 循环中变量，而在执行第二次循环时，命令行的第二个参数将被赋值给 for 循环中变量，依此类推。 for 循环控制结构没有指定值列表，但你必须在执行脚本程序的命令行上输入必要的参数去指定列表中的项。 “ $@ ” 是一个特殊参数变量，它的值就是命令行上的所有参数组成的一个列表。看下面的例子：当运行例子脚本程序cbackuparg 时，命令行上的 C 程序文件名将组成一个值列表，而该列表中的每个文件名将被自动依次赋值给 for 循环控制结构中的变量 backfile 。在执行 for 控制的第一个循环时，变量 backfile 的值为第一个命令行参数，即 $1 ，而在执行第二个循环时，变量 backfile 的值即为第二个命令行参数，即为 $2 。

cbackuparg 脚本程序清单：

for backfile do

cp $backfile source/$backfile echo "$backfile"

done

$ cbackuparg main.c lib.c io.c main.c

lib.c io.c

BASH Shell 小结

Linux 系统下开发出了三种不同的 Shell ，它们是：BASH Shell 、PDKSH Shell 及 TCSH Shell 。 BASH Shell 同时具有 PDKSH Shell 及 TCSH Shell 的大多数高级特性，包括命令行编辑、历史实用程序及别名等。历史实用命令能列出或查询你先前所执行的命令，你甚至还可以编辑并运行这些编辑后的命令。 BASH Shell 下的 alias 实用命令可以使你给一个 Linux 命令取别名，你甚至还可以给带参数的命令取别名。

BASH Shell 下还有一组 Shell 特征开关变量。三个常见的特征开关变量是：

ignoreeo f、 noclobber 及 noglob。 ignoreeof 开关变量可以防止你意外的退出，

noclobber 开关变量可以防止你在使用重定向时意外地覆盖已经存在的文件，而 noglob 开关变量可以把 Shell 特殊字符看作普通的文本字符。

BASH Shell 下也有一组特殊的变量，通过这些变量，你可以配置你的用户Shell 。在这些特殊变量中，有的变量是由系统定义的，你不能再重新定义或赋值给它们，还有一些是用户定义变量，你必须明确地定义并赋值给它们。通过使用这些特殊变量，你可以配置你的用户环境。例如， PATH 特殊变量用来指定你运行的 Linux 命令或实用程序所在的目录； EXINI 变量用来保存编辑器 Ex 及 Vi 的缺省配置。

有一些特殊变量是在登陆初始化文件中定义与赋值的。登陆初始化文件是

一个 Shell 脚本程序，该脚本程序在 Shell 被创建时自动执行。在 BASH Shell 中，登陆初始化文件是 .bash_profile 。在 C Shell 中，登陆初始化文件是 .login 。在 BASH Shell 中还有一个名为 .bash_logout 的文件，该文件在你退出 Shell 时被自动执行。所有的 Shell 都有其 Shell 初始化文件，这些文件在你进入 Shell 时自动执行。 BASH Shell 下的 Shell 初始化文件是 .bashrc 。

BASH Shell 有象其它程序设计语言一样的程序设计能力。你可以在 BASH Shell 脚本程序中定义变量，并给这些变量赋值。你也可以交互式地给一个变量赋值。 BASH Shell 还有一组控制结构，包括条件控制结构及循环控制结构等。与其它程序设计语言一样，你可以在 Shell 脚本程序中设计程序语句，并执行该脚本程序。

你可以在 Shell 中定义变量，并给这些变量赋值。你可以在变量的前面键入特殊字符 “ $ ” 来引用该变量的值。你也可以把变量作为命令行参数，该变量的值可以是目录路径，甚至还可以是将要运行的 Linux 命令。

你可以用文本编辑器来创建包含 Shell 命令及变量定义的文件，这些文件就是我们所说的 Shell 脚本程序。一个脚本程序甚至还可以有参数变量，这些参数变量用来接收你在命令行上输入的各种参数。通过设置 Shell 脚本程序的可执行权限，你可以把该 Shell 脚本程序看作是另一个新的 Linux 命令。

echo 、read 命令及 Here 文件等可以用来控制脚本程序的输入与输出。echo 命令用来输出数据至标准输出，而 read 命令可以使你以交互式方式读取输入数据至变量。这些数据是来自标准输入输入的数据，它可以是来自键盘的输入数据，或者是来自于一个文件的重定向。 Here 文件使你直接输入文本数据至脚本程序。 Here 操作是在符号 “ << ” 之后输入用户定义的结束定界符，定界符后输入的文本将被赋值给一个命令。

BASH Shell 脚本程序中常使用的变量是字符变量，即它们以字符串作为其变量值。除了等号之外，字符变量再没有其它操作算子，如果你想对变量执行算术、关系操作等，你必须使用 let 命令。在 BASH Shell 中， let 命令可以使你象使用数字变量一样使用定义的变量，例如，你可以执行加、减、乘、除等操作。

BASH Shell 中使用的循环控制结构及条件控制结构与其它程序设计语言使用的控制结构类似。 BASH Shell 中使用的循环控制结构有： while 、 for-in 及 for 循环。条件控制结构是 if 及 case 结构。while 循环与其它程序设计语言中的 while 循环类似，该循环将永远执行，直至该控制结构中的测试条件是假为止。但是，在 BASH Shell 控制结构中的测试条件是一个 Linux 命令。 Linux 系统中的所有命令执行后都会返回一个退出状态（返回值），以表明该该命令是否被成功运行。如果一个 Linux 命令的退出状态是 0 ，则表明该命令被成功运行；如果一

个 Linux 命令的退出状态是非 0 值，则表明该命令没能成功运行。对于 while 循环，其测试条件也是一个 Linux 命令。如果该 Linux 命令成功运行，那么，while 循环将继续；如果该 Linux 命令运行失败，那么， while 循环将结束。

BASH Shell 下的特殊命令 test 可以用来实现与其它程序设计语言中类似的测试条件。 test 命令可以对两个变量值进行比较操作或关系操作。如果比较操作的结果为真，那么， test 命令的退出状态将为 0 ，表明该命令成功运行；如果比较操作的结果为假，那么， test 命令的退出状态将为非 0 值，表明该命令运行失败。在 test 命令中，你可以使用关系操作算子（即比较两个操作数）来控制一个循环结构。

if 条件控制结构根据一个测试条件的运行结果来决定是否运行该控制结构内的命令。与 while 控制结构一样，这个测试条件也是一个 Linux 命令。如果该 Linux 命令成功运行，那么，if 控制结构内的命令将被执行。if 条件控制结构也使用 test 命令来实现类似于程序设计语言中条件结构。 test 命令可以对两个变量执行关系操作，如果关系操作的结果为真，那么， if 控制结构将继续执行其后的命令。你可以使用 elif 及 else 结构在 if 控制结构中嵌入多个条件控制。与 if 结构一样， elif 控制结构内有它自己的 Linux 测试命令。

case 条件控制结构类似于一个受限的 if 结构，它把一个变量的值与多个可能的模式进行比较，如果找到与变量值匹配的字符串，与该匹配的模式相关联的一组命令将被执行。 case 条件控制结构非常适合实现菜单，即它可以让用户在多个可能的菜单选项之间作出选择。

for-in 循环控制结构用来把列表中的一系列值依次赋值给一个指定的变量。该结构中没有测试条件。 for-in 控制结构中的一系列值可以由任何一个 Linux 命

令生成。例如， ls 命令可以生成一个文件名列表。这个列表中的值也可以是一组指定的单词，该列表中的每个单词都将会被依次赋值给 for-in 结构中指定的变量。该循环将一直进行下去，直至列表中的所有项都赋值给指定的变量为止。对于 for 循环控制结构，脚本程序不会指定其列表项中的每一项，而在运行其脚本程序时把该脚本程序的命令行参数作为其列表项。

表 15-1 命令行编辑、 history 命令及查询历史事件命令行编辑命令功能

CTRL-b 或左光标键左移一个字符（移至前一个字符）

CTRL-f 或右光标键右移一个字符（移至后一个字符）

CTRL-a 移至行首

CTRL-e 移至行尾

ESC f 后移（ forward ）一个单词

ESC b 前移（ backward ）一个单词

DEL 删除光标所在的字符

BACKSPACE 或 CTRL-d	CTRL-h	删除光标前的字符删除光标后的字符
CTRL-k CTRL-n		删除至行尾或向下光标键移至历史事件列表中当前事件的下
CTRL-p		一历史事件或上光标键移至历史事件列表中当前事件的前一
		历史事件

CTRL-k

CTRL-n

删除至行尾

或向下光标键移至历史事件列表中当前事件的下

CTRL-p

一历史事件

或上光标键移至历史事件列表中当前事件的前一

历史事件

ESC < 移至历史事件列表表首

ESC > 移至历史事件列表表尾

EASC TAB 历史事件名自动匹配与自动扩展

fc event-reference 用标准编辑器编辑一个事件，然后执行之选项：

-l 列出最近的历史事件，与 history 命令相同

-e 编辑 event-reference ，即启动一个指定的编辑器去编辑指定的历史事件

!event num 用历史事件号来查询一个历史事件

!characters 用历史事件的字符前缀来查询历史事件

!?pattern? 用模式来查询历史事件列表中的事件

!-event num 通过偏移量（相对于事件表中的第一个事件）来查询历史事件

!num1-num2 引用历史事件号在 num1 与 num2 之间的事件

表 15-2BASH Shell 特殊变量与 Shell 特征开关变量

Shell 特殊变量功能系统定义变量

HOME 用户的主路径名

LOGNAME 用户登陆名

USER 用户登陆名

TZ 系统使用的时区

可重定义变量

SHELL 用户正在使用的 Shell 类别及其应用程序所在路径

PATH 在执行命令时系统要搜索的目录路径列表

PS1 主 Shell 命令提示符

PS2 次选 Shell 命令提示符

IFS 定界符

MAIL 在接收电子邮件时 mail 实用程序需要检查保存邮件的文件名

MAILCHECK 检查是否收到新邮件的时间间隔用户定义特殊变量

MAILPATH 在接收电子邮件时 mail 实用程序需要检查的邮件文件路径名列表

TERM 终端名

CDPATH 执行 cd 命令时要搜索的子目录路径名

EXINITEx/Vi 编辑器的初始化命令

BASH Shell 特性开关变量

set -+o feature 可以用 set 命令来设置 BASH Shell 特性开关变

量， -o 选项打开开关变量，而 +o 选项关闭开关变量

$ set -o noclobber 打开开关变量 noclobber

$ set +o noclobber 关闭开关变量 noclobber

ingoreeof 禁止使用 CTRL-D 退出

noclobber noglob		重定向操作时不覆盖已存在文件禁止文件名中特殊字符扩展（如 * 、? 、~ 、及［］）
	表	15-3 BASH Shell 命令与参数
BASH Shell 命令		功能
break		从 fo r、 while 及 loop 循环中退出
Continue		跳过循环中余下的命令，并继续下一次循环
Echo		显示变量值
		-n 选项排除输出时的换行符
Eval		执行命令行
Exec		在当前进程中执行命令，运行时不创建新的子
Exit		Shell 而使用当前的 Shell 从当前 Shell 中退出
export var		在每个子 Shell 中生成变量 var 的一个拷贝（值
		引用）
History		列出历史事件列表中的事件
let "expression"		用表 15-4 中的操作算子给数字、关系表达式赋值
		（表达式必须用双引号括起来）
Read Return		从标准输入上读取一行从函数中退出
Set		当在命令行上执行且带参数时，表示给变量赋新
		的值，当不带任何参数时，表示将列出当前定义

的所有变量

Shift 把所有的命令行参数左移，于是引用该参数时的参数号将比先前小 1 ，也就是参数 $3 将赋值给参数 $2 ，依次类推。先前的参数 $1 将丢失

test value option value

［ value option value ］

比较两个参数，用在 Linux 命令的控制结构中 test

2 -eq $coun t［ 2 -eq $coun t］

unset 取消一个变量的定义命令行参数

$0 Linux 命令名

$n 从 1 开始的第 n 个命令行参数，你可以用 set 命令去改变它们的值

$* 从 1 开始的所有命令行参数，比可以用 set 命令去改变它们的值

$@ 可以被逐个单独引用的命令行参数

$# 命令行参数的个数

$$ 当前进程的进程 ID 号及 PID 号

$! 当前后台进程的 PID 号

$? 最后执行的一个 Linux 命令的退出状态（ exit

status ），即返回结果

	表	15-4 let 表达式操作算子
算术操作算子		功能
+		加
-		减
*		乘
/		除
%		取模 - 除法的余数
关子操作算子
> <		大于小于
>=		大于等于
<=		小于等于
!=		不等于
==		等于
&		逻辑与
\| !		逻辑或逻辑非
	表	15-5 Test 命令操作选项
整数比较		功能
-gt		大于
-lt		小于

-ge 大于等于

-le 小于等于

-eq 等于

-ne 不等于

字符串比较功能

-z 测试空窜

-n 测试字符串的值

= 字符串相等

!= 字符串不等

str 测试一个字符串是否不是空窜

逻辑操作算子功能

-a 逻辑与

-o 逻辑或

! 逻辑非文件测试操作算子功能

-f 文件存在，且是一常规文件

-s 文件非空

-r 文件是可读文件

-w 文件可以被修改（写入）

-x 文件可以被执行

-d 文件是一个目录名

-h 文件是符号链

-c 文件与一特定设备关联

-b 文件与一块文件关联

表 15-6BASH Shell 控制结构与循环

if, else,elif,case 功能

if ( command ) then commands fi 如果其测试命令被成功运行，那么， if

控制结构将执行 then 后的一个或一组命令

if ( command ) then commands esle commands fi

if ( command ) then command

elif ( comamnd ) then command

else command

case string in pattern)

command;;

esac

如果其测试命令被成功运行，那么， if-else 控制结构将执行 then 后的一个或一组命令，否则， else 后的一个或一组命令将被执行

elif 可以允许你在该控制结构中嵌入一个 if 控制结构，从而可以使你在几个可能选项之间进行选择，如果 if 后的测试命令的返回结果为真，其后的命令将被执行，而控制结构将退出整个 elif 控制结构

case 控制结构中的 string 与多个可能的模式进行匹配，如果找到匹配的模式，那么，与该匹配模式相关联的命令将被执行

command && command 如果两个命令的返回值都是 0 ，那么，

逻辑与的返回结果将为 0 ；如果其中的一个命令的返回结果为非 0 值，则逻辑与的返回结果为非 0 ，逻辑与的返回值为假

command || command 如果两命令中的一个命令返回值为0 ，那么，逻辑 OR 条件命令返回的结果将为 0 ，逻辑或将返回 0 ；如果两个命令都返回值一个非 0 值，那么，逻辑或条件命令的返回值将为假，并返回一个非 0 值 !command 逻辑非将反置命令的返回值

循环控制结构：功能

while ， until， for， for-in select while (command)

do command done

until command do

command done

for variable in list-values

do command

只有当 while 控制结构的测试命令为真时， do 后面的命令才被执行

只有当 until 控制结构的测试命令为假时， do 后面的命令才被执行

for-in 控制结构用来引用列表中的一系列值，列表中的值被逐个赋值给变

done 量 variable

for variable do command done

select string in item-list do

command

done

for 循环控制结构用来引用执行脚本程序时输入的命令行参数。命令行参数上的每个参数将被逐个赋值给变量variable

select 控制结构可以根据 item-list 中的项创建一个菜单，然后，执行相应的命令，该命令通常是一个 case 控制结构

第 15 章 BASH Shell

第 15 章 BASH Shell

命 令 和 文 件 名 扩 展 特 性

命 令 行 编 辑

实 用 命 令

历 史 事 件 编 辑

配 置 H istory: HISTFILE 及 HISTSIZE

别 名

控 制 Shell 的 运 行 方 式

15.5.1ignoreeof

15.5.2noclobber

15.5.3noglob

环 境 变 量 与 子 Shell ： export 命 令

用 特 殊 Shell 变 量 设 置 登 陆 Shell

“ 系 统 自 赋 值 ” （ system-determined ） 特 殊 变 量

BASH Shell 可 重 定 义 特 殊 变 量

PATH

BASH Shell “ 用 户 级 定 义 ” （ user-defined ） 特 殊 变 量

BASH Shell 登 陆 初 始 化 文 件 ： .profile

BASH Shell 初 始 化 文 件 ： .bashrc

BASH Shell 退 出 初 始 化 文 件 ： .bash_logout

BASH Shell 程 序 设 计

15.8.1 Shell 脚 本 程 序 ： 命 令 行 及 注 释 行

变 量 与 脚 本 程 序

变 量 的 定 义 与 赋 值 ： = 、 $ 、 set 及 unset

变 量 值 ： 字 符 串

字 符 串 引 用 ： 双 引 号 、 单 引 号 和 反 斜 扛

Linux 命 令 的 值 ： 回 引 号 “ '” （ back qutoes ）

引 用 命 令 ： 单 引 号

脚 本 输 入 与 输 出 命 令 ： echo 、 read 及 <<

脚 本 程 序 命 令 行 参 数

输 出 变 量 与 脚 本 Shell

Shell 算 术 赋 值 操 作 ： let 命 令

控 制 结 构

测 试 命 令

条 件 控 制 结 构 ： if、 if-else 、 elif 及 case

if-then 条 件 控 制 结 构

逻 辑 命 令 ： && 及 ||

循 环 控 制 结 构 ： wh ile ， for-in 及 for

Wh ile 循 环 控 制 结 构

for 循 环 控 制 结 构

BASH Shell 小 结

命令和文件名扩展特性

命令行编辑

实用命令

历史事件编辑

配置 H istory: HISTFILE 及 HISTSIZE

别名

控制 Shell 的运行方式

环境变量与子 Shell ： export 命令

用特殊 Shell 变量设置登陆 Shell

“ 系统自赋值 ” （ system-determined ）特殊变量

BASH Shell 可重定义特殊变量

BASH Shell “ 用户级定义 ” （ user-defined ）特殊变量

BASH Shell 登陆初始化文件： .profile

BASH Shell 初始化文件： .bashrc

BASH Shell 退出初始化文件： .bash_logout

BASH Shell 程序设计

15.8.1 Shell 脚本程序：命令行及注释行

变量与脚本程序

变量的定义与赋值： = 、 $ 、 set 及 unset

变量值：字符串

字符串引用：双引号、单引号和反斜扛

Linux 命令的值：回引号 “ '” （ back qutoes ）

引用命令：单引号

脚本输入与输出命令： echo 、 read 及 <<

脚本程序命令行参数

输出变量与脚本 Shell

Shell 算术赋值操作： let 命令

控制结构

测试命令

条件控制结构： if、 if-else 、 elif 及 case

if-then 条件控制结构

逻辑命令： && 及 ||

循环控制结构： wh ile ， for-in 及 for

Wh ile 循环控制结构

for 循环控制结构

BASH Shell 小结