第五章 Shell 编程

czs321 2013-02-21

展开全文

【目标】

本章的主要目的是为大家介绍 Shell 的编程方法，在讲Shell 编程方法之前，还要介绍一些有关Shell的概念和Shell的启动过程等，对于系统管理员或程序员来说，熟练地使用Shell脚本将对日常的系统维护及管理非常有用，如果我们想作一个合格的系统管理员或程序员，建议进一步深入的了解和使用 Shell。

【重点内容】

Shell 概述

Shell 启动

Shell 变量和运算符

过程

脚本执行命令

控制 Shell

Shell 的简单编程

Shell 程序的调试

Shell 脚本举例

专家答疑

下面让我们马上开始继续学习Shell吧！

5.1 Shell 概述

5.1.1 概念

我们平时所说的Shell可以理解为是Linux或UNIX系统提供用户的使用界面。Shell为用户提供了输入命令和参数、并可得到命令执行结果的环境。当一个用户登录Linux系统之后，系统初始化程序init就根据/etc/passwd文件中的设定，为每一个用户运行一个称为shell(外壳)的程序。

确切一点说，Shell是一个命令行解释器，它为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序，用户可以用Shell来启动、挂起、停止甚至是编写一些程序。Shell处在内核与外层应用程序之间，起着协调用户与系统的一致性、在用户与系统之间进行交互的作用，即Shell为用户提供了输入命令和参数并可得到命令执行结果的环境。为了让大家能够更直观的了解Shell的概念，请参考下面的图5_1：

文本框:

图5_1 Linux、UNIX系统层次结构图

Shell解释用户输入的命令行，提交到系统内核处理，并将结果返回给用户；Shell与Linux、UNIX命令一样都是实用程序，但是它们之间还是有区别的。一旦用户注册到系统后，Shell 就被系统装入内存并一直运行到用户退出系统之止；而一般命令仅当被调用时，才由系统装入内存执行。而且与一般命令相比，Shell除了是一个命令行解释器外，同时还是一个功能相当强大的编程语言，而且易编写、易调试、灵活性较强，作为一种命令级语言，Shell是解释性的，多数高级语言是编译性的, Shell命令组合功能很强, 与系统有密切的关系。大多数Linux系统的启动相关文件(一般在 /etc/rc.d 目录下)都是使用shell脚本。同传统的编程语言一样，shell提供了很多特性，这些特性可以使我们的shell 脚本编程更为有用，如：数据变量、参数传递、判断、流程控制、数据输入和输出，子程序及以中断处理等。

目前Shell的版本有很多种，如Bourne Shell、C shell、Bash、ksh、tcsh等，它们各有特点，下面我们来简要介绍一下。

第一个重要的 shell 是 Bourne shell，这个命名是为了纪念此shell的发明者Steven Bourne。1979起Unix就开始使用Bourne shell。Bourne shell的主文件名为sh,以后的开发者们便以sh做为Bourne shell的主要识别名称。

虽然Linux与Unix一样，可以支持多种shell, 但 Bourne shell 的重要地位至今仍然没有改变. 许多Unix系统中仍然使用sh做为重要的管理工具。它的工作从开机到关机, 几乎无所不包。Linux中用户shell主要是bash，但在启动脚本、编辑等很多工作中仍然使用Bourne shell。

C shell是最广为流行使用的shell变种。C shell主要在 BSD 版的Unix 系统中使用，作者是柏克莱大学的 Bill Joy。C shell因为其语法和C语言相类似而得名。这也使得Unix的系统工程师在学习C shell时感到相当的方便。

Bourne Shell和C Shell形成了shell 的两大主流,后来的变种大都吸取这两种shell的特点。比如 Korn, tcsh 及 bash。

Bash shell是GNU计划的重要工具软件之一, 也是 GNU系统中标准的shell。Bash与sh兼容,所以许多早期开发出来的 Bourne shell程序都可以继续在bash中运行。现在我们使用的Linux就是使用Bash做为用户的基本shell。

Bash在1988年发布，并在1995~1996 期间推出 bash 2.0。在这之前, 广为使用的版本是 1.14, 它增加了许多新的功能, 以及更好的兼容性。要想具体的了解这些shell，请参看下面Shell版本列表中所示的详细内容：

Shell 类别	易学性	可移植性	编辑性	快捷性
Bourne (sh)	容易	好	较差	较差
Korn (ksh)	较难	较好	好	较好
Bourne Again (bash)	难	较好	好	好
POSIX (psh)	较难	好	好	较好
C (csh)	较难	差	较好	较好
TC (tcsh)	难	差	好	好
Z (zsh)	难	差	好	好

表5_2 Shell版本列表

注意：

Shell的两种主要语法类型：Bourne和C，这两种语法彼此不兼容。Bourne家族主要包括：sh、ksh、bash、psh、zsh；C家族主要包括：csh、tcsh （bash和zsh在不同程度上支持csh 的语法。）

大家可能会问，有这么多的Shell版本，那我们该应用那个版本呢？通常选择合适的Shell版本应考虑的主要因素有下面这几点：（1）Bourne Shell在任何一个Linux、UNIX系统平台上都存在，因此又成为标准Shell；（2）Bourne Shell家族有更丰富的程序语言，而 C Shell家族有简单的程序接口；（3）Shell各类变种功能越来越强大，但学习和使用也越难，因此可依据使用者编程经验来选择；（4）Shell编程的脚本是个人使用还是公用，即要考虑移植性问题。

5.2 Shell 启动

通常Shell的启动有两种方式：系统启动时Shell的启动和命令行状态下Shell的启动，也称Shell的交互使用。下面分别介绍给大家这两种Shell 的启动方式。

5.2.1 系统启动时Shell启动

即在系统启动前，先在/etc/passwd文件中指定要启动的Shell。例如：

root:x:0:1:super user:/:/bin/sh

oralce:x:201:starf:/home:/bin/csh

这样，当系统启动后，如果是root用户登陆,那么使用的Shell版本将会是sh；如果是oracle用户登陆,那么使用的Shell版本将会是csh。

5.2.2 命令行状态下Shell启动

在命令行状态下启动Shell的方法很简单，因为在系统中本身有多种版本的Shell存在，可通过下面相应的命令来启动，如：

sh-2.04$ bash

[oracle@mirror oracle]$ sh

sh-2.04$ csh

[oracle@mirror ~]$

在命令提示符下，输入bash可进入bash环境，输入sh可进入sh环境，输入csh可进入csh环境。这样即可实现Shell不同版本之间的交互使用。

5.2.3 Shell与内核的交互作用

系统启动过程中内核将加载至内存直到系统关机，在启动过程中，init进程将扫描Linux系统中的/etc/inittab文件,在此文件中将列出可用的终端及其属性，一旦找到活动的终端，getty(mingetty,LINUX)函数将会给出login提示符和口令，确认完成后将启动相应的shell(即在/etc/passwd文件中指定用户使用的Shell环境)。

上面介绍的过程可以用下面的流程图表示：

在上面的流程图中，getty(mingetty)提示输入用户及口令，然后将用户名及口令传递给login, login验证用户及口令是否匹配，如果身分验证通过，login将会自动转到其用户的$HOME环境中,并启动在/etc/passwd文件中所列出的shell程序（如在/etc/passwd文件中用户的shell域为/bin/sh），然后将控制权移交到所启动的任务。

5.3 Shell 变量和运算符

下面先给大家介绍一下Shell的变量，当Shell脚本需要保存一些信息时（或许是一个文件名），就把它存放在一个变量中。变量是计算机内存的单元，其中存放的值可以改变。每个变量有一个名字，所以很容易引用它。变量可以定制用户本身的工作环境。使用变量可以保存有用信息，使系统获知用户相关设置。变量也用于保存暂时信息。

变量的名字必须以字母或下划线开头，可以包括字母、数字和下划线。Shell变量能够而且只能存储正文字符串,即它只有一种类型的变量——串变量。从赋值的形式上看，则可以分成四种类型的变量，也变量形式。

在Linux系统中经常使用的Bourne Shell中有如下四种变量：

用户自定义变量

位置变量

环境变量

预定义变量

5.3.1 Shell编程中的特殊字符

美元符号。用来表示变量的值。如变量NAME的值为Mike，则使用$NAME就可以得到“Mike”这个值。

井号。除了做为超级用户的提示符之外，还可以在脚本中做为注释的开头字母，每一行语句中，从#号开始的部分就不执行了。

{}

大括号。一般与变量值标识符号$配合使用，表示变量的起始位置，还可以在其中进行各种变量的赋值。如${NAME}string表示变量名是NAME，它的值与后面的“string”字符串连接。

“”

双引号。shell不会将一对双引号之间的文本中的大多数特殊字符进行解释，如#不再是注释的开头，它只表示一个井号“#”。但$仍然保持特殊含义。

'’

单引号。shell不会将一对单引号之间的任何字符做特殊解释。

倒引号。命令替换。在倒引号内部的shell命令首先被执行，其结果输出代替用倒引号括起来的文本，不过特殊字符会被shell解释。

斜杠。用来去掉在shell解释中字符的特殊含义。在文本中，跟在\后面的一个字符不会被shell特殊解释，但其余的不受影响。

5.3.2 用户自定义变量

用户自定义变量指登陆用户自身进行定义的变量，例如：

$ COUNT=1

$ NAME="Frank Chu"

上面的例子中用户定义了两个变量分别为COUNT和NAME，并分别赋值为“1”和“Frank Chu”。

注意：

因为大部分Linux、UNIX命令使用小写字符，因此在shell编程中通常使用全大写变量，当然这并不是强制性的，但使用大写字符可以在编程中方便地识别变量。

对用户自定义变量进行调用需要在变量前加$，而且有时需要用{}括起来，同其他字符分开，例如：

# echo $HOME

/root

# WEEK=Satur

# echo Today is $WEEKday

Today is

# echo Today is ${WEEK}day

Today is Saturday

这说明只有用大括号{}将变量名称确定后，shell才能识别加以执行。

设置变量的默认值

在变量未赋值之前其值为空。但Bourne Shell允许对变量设置默认值，其格式如下：${variable:-defaultvalue}

注意：

在Bourne Shell中可以使变量替换在特定条件下执行，即有条件的环境变量替换。这种变量替换总是用大括号括起来的。

例如：

# echo Hello $UNAME

Hello

这时UNAME未被赋值，所以显示为空

# echo Hello ${UNAME:-there}

Hello there

# UNAME=hbwork

# echo Hello ${UNAME:-there}

Hello hbwork

在UNAME已经被赋值为hbwork时，默认值there就被取代了。

改变变量的值

既然我们可以对变量赋值，当然也就可以改变变量的值，改变变量的格式如下：${variable:=value}

让我们举例说明：

# echo Hello $UNAME

Hello

# echo Hello ${UNAME:=there}

Hello there

# echo $UNAME

there

上面的例子中第一行的变量 UNAME由于没有赋值，所以为空，第三行中变量 UNAME的值被改变为 there。所以在最后一行显示变量UNAME的值时，显示的值为there。

当然还有其它一些关于对自定义用户变量操作的使用方法。如下所示：

5.3.3 位置变量

Shell变量可以使用位置变量来存取脚本参数。例如我们创建的一个脚本会处理两个参数，那么就可以编写读取位置变量的脚本，来得到实际的数值。传给脚本的文件名存放在变量$1和$2中。在相关数字之前加上一个美元符号，就可以存取任意多个参数。在Shell 脚本中位置变量可用$1、$2、$3..$9表示，$0表示内容通常为当前执行程序的文件名。当存取的参数超过第10个时，就要用大括号把这个数字括起来，如：${14} 和${18}等。

在下面的这个rm命令执行中带着3个文件名做为参数。

$1的值=mom.txt

$2的值=/usr/local/bin/kl.sh

$3的值=/etc/hosts.bak

举例：

# cat count.sh

#!/bin/sh

A=$1 # 将位置$1的数值读入，并赋给变量A

B=$2 # 将位置$2的数值读入，并赋给变量B

C=$[$A+$B] # 将变量A与B的值相加，将结果赋给C

echo $C # 显示C的数值

这个脚本count.sh可以运算两个数字的和并显示出来。在运行的时候，就需要同时输入需要相加的两个数字：

# ./count.sh 3 6

# ./count.sh 34 28

注意：我们下面就要开始尝试自己编写脚本程序了。这些程序实质上都是文本文件，在被创建的时候默认权限是644，不具备执行权限，需要用chmod为它们加上执行权限。可以参考下面的例子。

举例说明，我们来看下面的脚本例子5_1:

例子5_1 showdata — 利用位置变量显示脚本参数

#! /bin/bash

echo "\ $ 0= * $0 *"

echo "\ $ 1= * $1 *"

echo "\ $ 2= * $2 *"

echo "\ $ 3= * $3 *"

以下是这个脚本运行的示例：

$ chmod +x showdata # 附加执行权限

$ ./showdata teacher student

\ $ 0= * ./showdata *

\ $ 1= * teacher *

\ $ 2= * student *

\ $ 3= * *

这个脚本主要说明两点：第一，有时把值用（*）括起来很有用，这样可以更容易地指出一个变量何时为空。因为只有两个参数传给该脚本，所以$3的值是空的。第二，变量 $0 存放脚本自身的名字。这个变量可以用来创建日志文件，更容易使用这些文件与脚本关联起来。

有关位置变量还有另外三个：

$* 这个变量包括参数的列表

$@ 这个变量包括参数的列表

$# 这个变量包括参数的个数

Bash 保留$* 和$@ 这两个变量，从而更容易从其他Shell程序中移植脚本。下面的脚本例子5_2中，展示了$* 、$# 和$@ 变量的用法。

例子5_2 showparam — 利用位置变量显示脚本参数

#! /bin/bash

echo "There are $# parameters."

echo "The parameters are * ${*} * "

echo "The parameters are * $@ *"

以下是这个脚本执行的示例：

$ chmod +x showparam

$ ./showparam one two three

There are 3 parameters.

The parameters are * two two three *

提示：

注意在第二个echo命令中是如何使用大括号的，从而使变量值被星号括起来。大括号迟早有用，不限于上面一种情况。

5.3.4 环境变量

Shell执行环境由一系列环境变量组成，这些变量是由Shell维护和管理的。所有这些变量都可被用户重新设置，变量名由大写字母或数字组成。

例如下面的环境变量：

CDPATH:执行cd命令时使用的搜索路径;

HOME: 用户的home目录;

IFS: 内部的域分隔符，一般为空格符、制表符或换行符;

MAIL: 指定特定文件(信箱)的路径，供邮件系统用；

PATH: 寻找命令或可执行文件的搜索路径；

PS1 : 主命令提示符，默认为“$”;

PS2 : 从命令提示符，默认为“>”;

TERM: 使用的终端类型。

例如我们显示下面的环境变量：

$ PS1="test:";export PS1

test:

$ echo $MAIL

/var/spool/mail/username

5.3.4 预定义变量

在Shell中有一组预定义变量也称为特殊变量，其变量名和变量值只有Shell本身才可以设置。预定义的变量主要有下面几个：

$ shell变量名的开始，如$var

| 管道，将标准输出转到下一个命令的标准输入

$# 记录传递给Shell的自变量个数

# 注释开始

& 在后台执行一个进程

？匹配一个字符

* 匹配0到多个字符(与DOS不同，可在文件名中间使用，并且含.)

$- 使用set及执行时传递给shell的标志位

$! 最后一个子进程的进程号

$? 取最近一次命令执行后的退出状态(返回码)

$* 传递给shell script的参数

$@ 所有参数，个别的用双引号括起来

$0 当前shell的名字

$n (n:1-) 位置参数

$$ 进程标识号(Process Identifier Number, PID)

> 输出重定向

< 输入重定向

>> 附加输出重定向

[] 列出字符变化范围，如[a-z]

例如预定义变量 $# 是用来记录传递给Shell的自变量个数，那么下面的命令行：

$ showparam a b c

其中 showparam 是上面所讲位置变量内容中的脚本例子3_2中，用来利用位置变量显示脚本参数，那么此时预定义变量 $#的值为3。

上面内容中的预定义变量$? ，是用来取最近一次命令执行后的退出状态(返回码)，一般情况下，如果执行成功返回码为0，执行失败则返回码为非0。

举例如下：

# test -r my_file

# echo $?

#cat nofile

cat: nofile: No such file or directory

# echo $?

当试图cat不存在的nofile文件时出错，则$?为非空。

5.3.5 运算符

运算符告诉计算机要执行什么动作。像大多数语言一样，Shell也有很多运算符。运算符是对计算机发送的指令，指示它执行某些任务。所有运算符产生的动作都在运算对象上执行。运算对象可以是字面值（或3或者23.3）、变量（如$ count）或者表达式（如$ count + 1）。一个良好的表达定义是某些运算符和运算对象的组合体，它们作为一个单位进行求值运算。

运算对象本质上是递归的。表达式1 + 9（两个运算对象和一个加法运算符）可以被看作是其值为10的一个运算对象。（1 + 9）-2是一个表达式，它由两个运算对象相减组成，其中第一个运算对象是（1 + 9），第二个运算对象是2。

理解运算符优先级是能够解释表达式的关键。运算优先级的顺序表明在每个表达式或子表达式中哪一个运算对象首先被求值。

表5-2以降级顺序列出Shell所用的全部运算符。具有较高优先级级别的运算符先于较低级别的运算符进行求值运算。

表5-2 Shell运算符和它们的优先级顺序

级别	运算符	说明
13	-, +	单目负、单目正
12	!, ~	逻辑非、按位取反或补码
11	* , / , %	乘、除、取模
10	+, -	加、减
9	<< , >>	按位左移、按位右移
8	< =, > =, < , >	小于或等于、大于或等于、小于、大于
7	= = , ! =	等于、不等于
6	&	按位与
5	^	按位异或
4	\|	按位或
3	&&	逻辑与
2	\| \|	逻辑或
1	=, + =, - =, * =, /=, % =, & =, ^ =, \| =, << =, >> =	赋值、运算且赋值

注意：

读者或许认为表5-2 列出了大量运算符，其实不然，这个列表实际上是相当有限的。例如，Shell不支持幂运算符。对此以及更高级的运算符需要用Perl或者Tcl。

在讨论某些更深奥的运算符之前，先看一下运算符优先级的顺序是如何影响表达式求值过程的：

$ echo $[1+2*4]

$ echo $[(1+2)*4]

注意：

$ [ ]表示形式告诉Shell对方括号中的表达式求值。

第一个命令首先计算乘运算符，因为它的优先级是11，而加运算符的优先级是10。因此，第一个命令就成为echo $ [1 + 8] ，即9。第二个命令使用圆括号，使加运算符首先计算。圆括号中的表达式总是首先计算的。

取模运算符

取模运算符用来求出两个运算对象相除得到的余数。例如，9 %7等于2，因为9 / 7 等于1余下2。

当脚本需要对整个列表反复进行，对多个元素的每一个都执行某些处理时，取模运算符很有用。例5-3示出如何确定一个列表中每隔2个元素的内容。

例5-3 modulus 利用取模运算符每隔2个元素进行一次处理

# ! /bin/bash

count=1

for element in $@

if test $[$count%3] = 0

then

echo $element

let count=$count+1

done

以下是这个脚本的执行示例：

$ chmod + x moudulus

$ . /modulus one two three four five six

three

six

这个取模脚本中唯一懂的部分是test命令。test命令将在本章下面小节中给出全面介绍，所以在这里仅做简单要介绍。需要计算的表达式是$count % 3 ，它在$ [ ]表示形式中，与该表达式进行比较的值在等号的右边。这样，当$ count的值达到了时，方括号中表达式的计算结果是0，则echo语句执行。

应注意每隔两项打印一个值。通过修改取模运算符右边的值，可以影响到哪些项被处理。把该值改为5 就意味着每隔4项打印一个消息。

按位运算符

按位（bitwise）运算符对两个运算对象的单个的二进制进行操作。第一个运算对象的每个位与第二个运算对象的相应位进行比较（除按位取反运算符以外，它只作用在一个运算符对象上）。

表5- 3 提供了Shell中使用的每个按位运算符的详细说明。

表5-3 按位运算符

运算符	说明
~ op1	取反运算符把op1中所有的二进制位的1变为0，所有的0变为1
op1<< op2	左移运算符把op1中的二进制位向左移动op2位，忽略最左端移出的各位，最右端的各位补上0值，每做一次按位左移就有效地实现op1乘以2
op1>>op2	右移运算符把op1中的二进制位向右移动op2位，忽略最右端移出的各位，最左端的各位补上0值。每做一次按位右移就有效地实现op1除以2
op1 & op2	与运算符比较op1和op2的对应位，对于每个二进制位来说，如果二者该位都是1，则结果位为1；否则，结果位为0
op1 ^ op2	异或运算符比较op1和op2的对应位，对于每个二进制位来说，如果二者该位互补（即不相同），则结果位为1；否则，结果位为0
op1 \| op2	或运算符比较op1和op2的对应位，对于每个二进制位来说，如果二者该位有一个是1或者都是1，则结果位为1；否则，结果位为0

逻辑运算符

逻辑运算符允许程序根据多种条件做出判断。每个运算对象求得的值为真或者为假，然后利用各运算对象的真值或者假值来确定整个表达式的值。

表5-4列出两个运算对象利用&&运算符组合起来的四种不同方式。从中可以看出，仅当两个运算对象都为真时，其结果才为真。

表5-4 &&结果表

运算对象1	运算对象2	运算对象1& &运算对象2
0	0	0
1	0	0
0	1	0
1	1	1

表5-5列出两个运算对象利用 | | 运算符组合起来的四种不同方式。从中可以看出，只要有一个运算对象为真，其结果就为真。

表5-5 | | 结果表逻辑运算符

运算对象1	运算对象2	运算对象1 \|\| 运算对象2
0	0	0
1	0	1
0	1	1
1	1	1

赋值运算符

基本赋值运算符在本章前面的很多示例中已经用过。它简单地把等号右边的表达式的值赋予等号左边的变量。

Shell也有简便赋值运算符，它们把基本赋值运算与另外的运算符组合在一起。例如，不必用let $count = $count + $change，而可以用let $count + = $change。采用简便运算符的优点除了输入的字符较少以外，就是使我们的赋值意图更加明了。

5.3.6 变量替换

上面的内容中我们已经介绍过，当Shell脚本需要保存一些信息（或许是一个文件名）供以后使用, 就把它存放在一个变量中。变量是计算机内存单元，其中存放的值可以改变。每个变量有一个名字，所以很容易引用它。

下面的例5-4是一个简短的脚本，它只是把值monday.dat赋予变量logfile。

例5-4 assign_logfile——简单变量赋值

# ! /bin/bash

# The following line is the assignment command

logfile="monday.dat"

echo "The value of logfile is :"

# The dollar sign is used to access a variable's value

echo "$logfile"

下面是这个脚本运行的示例:

$chmod + x assign_logfile

$. /asslgn_logfile <-execute the file

Tho value of logfile is：

monday dat <-the correct value is

<-displayed

$ echo $logfile

<-yikes! how come no value

<-is displayed?

按照默认情况，例5-4所示的变量仅在创建它们的Shell中可以访问。在进—步解释这个问题之前，让我们看一看在脚本中如何使用$字符来存取变量的值。

当把一个值赋给一个变量时，只是使用该变量的名字(在赋值号的左边)。例如：

logfile = "monday.dat"

然而，当存取该变量的值时，就需要用某个字符来告诉Shell，要进行变量替换。变量替换是用变量的值替代该变量名，并且Bash使用$字符表明要做替换。例如：

echo "The，log file name is $logfile"

5.3.7 source和export命令

在上面的例子中，为什么在命令行上运行echo $logfile时它不显示任何信息，而在该脚本内运行时它可以显示日志文件名？这是因为每一个脚本都在自己的Shell中运行——脚本几乎是全封闭的，除了打开文件之外，它断绝与其他程序的联系。

不管正运行的脚本如何，每个Shell都有内存，专门用来保存自己变量的信息。Shell维护的变量信息称做该Shell的“环境”。当执行赋值语句时，assign_ logfile脚本修改了它自己的环境。第一个echo $logfile命令起作用，因为它与赋值命令在同一环境中运行。第二个echo命令不起作用，因为它运行在assign_logfile脚本的父Shell环境中。asmgn_logfile脚本的父Shell就是我们的注册Shell，它也称做当前Shell(即当前通过键盘与之交互作用的Shell)。

我们利用source命令可以强行让一个脚本影响当前Shell的环境。它执行该脚本中的全部命令，而不管脚本文件的权限如何设置。例如：

$ source assign_logfile

The value of logfile is：

monday.dat

$ echo $ logfile

monday.dat

上面的source 命令让脚本将影响它们父Shell的环境。如果要影响子Shell应怎么办呢这时应该使用export，这个命令可以让脚本影响其子Shell的环境。请看下面的例子.

例5-6 dilplay_logfile——显示logfile变量的值

Variable

#! /bin/bash

echo "Logfile is $logfile."

例5-6 export_olgfile——简单变量赋值

#! /bin/bash

# The following line is the assignment command.

logfile = "Monday.dat"

# call the display script before using export

echo "Before Export: "

. / display_logfile

export logfile

# call the display scriptb after export

echo "After Export: "

. / display_logfile

以下是这个脚本运行情况的示例：

$ unset logfile

$ chmod + x export_logfile

$. /export_logfile

Before Export:

Logfile is

After Export:

Logfile is Monday.dat

$ ./display_logfile

logfile is

上面的unset命令从环境中删除一个变量。要想大致了解何时测试脚本使用环境变量的情况，使用这个命令是很方便的。由于display_logfile脚本第二次运行时显示出logfile变量的值，从而可看出export命令产生的效果。它让子Shell（即display_logfile的第二次运行）访问logfile变量。大家会看到，父Shell（即注册Shell）仍不能见到logfile变量，因为在命令行上运行时，display_logfile脚本不显示logfile变量的值。

注意：

为了如上所示的那样执行，对这个测试需要删除logfile变量或者取消其定义，如同本章先前运行source命令的情况。如果没有给出unset命令，则在命令行上运行display_logfile脚本时就会显示logfile变量。

让我们先看一下另一个使用export命令的示例。下面我们在注册Shell中创建一个变量，然后试着在子Shell中访问它。

试执行以下命令序列：

$ count = 19

$ echo $count

$ bash

$ echo $count

$ exit

$ echo $count

这个命令序列表明，在当前Shell或注册Shell中定义的count变量不能在子Shell中对其进行访问。

注意：

在assignment命令中或者使用let命令时，在等号的前后一定不能有任何空格。

我们下面使用export命令使count变量可用于子Shell：

$ export count = 19

$ bash

$ echo $count

$ exit

注意：，

export命令可以用作assignment命令的一部分。这个特性有助于缩小脚本尺寸，减少交叉访问。如果export命令以后在脚本中运行，我们想了解该脚本正在做什么事情，那么就需要检查assignment命令，看看它的值是什么。

当修改变量时我们应对底部行注意，保证让正确的Shell访问它们。

变量名前后的大括号告诉Shell，变量名从何处开始，到何处结束。Shell有一些表示形式要用到大括号。表5-5给出了所有大括号表示形式。

表5-6 利用大括号表示变量替换

表示形式	说明
${VARIABLE}	基本变量替换。大括号限定变量名的开始和结束
${VARIABLE: - DEFAULT}	如果VARIABLE没有值，则这种表示形式返回DEFAULT的值
${VARIABLE: = DEFAULT}	如果VARIABLE没有值，则这种表达形式返回DEFAULT的值。另外，如果VARIABLE没有设置，则把DEFAULT的值赋予它
${VARIABLE: + VALUE}	如果VARIABLE被设置，则这种表示形式返回VALUE；否则，返回一个空串
${# VARIABLE}	这种表示形式返回VARIABLE值的长度，除非VARIABLE是* 或者@在为*或者@的特殊情况下，则返回$@所表示的元素的个数。要记住，$ @保存传给该脚本的参数清单
${VARIABLE: ? MESSAGE}	如果VARIABLE没有值，则这种表示形式返回MESSAGE的值。Shell也显示出VARIABLE的名字，所以这种形式对捕获得错误很有用

5.3.7 影响命令的变量

Shell有若干以变量为工作对象的命令，其中有些命令似乎重复了。例如，可以用declare、export和typeset命令来创建全局（或转出）的变量。typeset命令是declare的同义词。

Declare 命令

语法：

declare [options] [name [= value]]

摘要：

用于显示或设置变量。

declare命令使用四个选项：

-f 只显示函数名

-r 创建只读变量。只读变量不能被赋予新值或取消设置，除非使用declare或者typeset命令

-x 创建转出（exported）变量

-i 创建整数变量。如果我们想给一个整数变量赋予文本值，实际上是赋予0使用+ 代替-，可以颠倒选项的含义。

如果没有使用参数，则declare显示当前已定义变量和函数的列表。让我们关注一下-r选项：

$ declare –r title=" paradise Lost"

$ title = " Xenogenesis"

bash: title: read-only variable

$ declare title= " Xenogenesis"

$ echo $title

Xecogenesis

$ typeset title = " The Longing Ring”

$ echo $title

The Longing Ring

这个示例表明，只有declare或typeset命令可以修改只读变量的值。

export命令

语法：

export [options] [name [= value]]

摘要：

用于创建传给子Shell的变量。

export命令使用四个选项：

-- 表明选项结束。所有后续参数都是实参

-f 表明在“名-值”对中的名字是函数名

-n 把全局变量转换成局部变量。换句话说，命名的变量不再传给子Shell

-p 显示全局变量列表

如果没有用参数，则假定是一个-p参数，并且显示出全局变量的列表：

$ export

declare –x ENV = "/home/medined/ . bashrc"

declare –x HISTFILESIZE = "1000"

…

declare –xi numPages = "314"

declare –xr title = "The Longing Ring"

declare –xri numChapters = "32"

这种显示的一个有趣的特性是，它告诉我们哪些变量只能是整数、是只读的，或者二者皆可。

let命令

语法：

let expression

摘要：

用于求整数表达式的值。

let命令计算整数表达式的值。它通常用来增加计数器变量的值，如例5-9所示。

例5-9 let——使用let命令

# ! /bin/bash

count=1

for element in $@

echo " $element is element $count"

let count+=1

done

下面是这个脚本运行结果示例：

$ chmod + x let

$ . /let one two three

one is element 1

two is element 2

three is element 3

注意：如果我们习惯在表达式中使用空格，那么要用双引号把表达式括起来，如：

let "count + =1"

否则会导致语句错误。

local 命令

语法：

local [name [= value]]

摘要：

用于创建不能传给子Shell的变量。这个命令仅在过程内部有效。

简单说来，local命令创建的变量不能被子Shell存取。因此，只能在函数内部使用local命令。我们可以在命令行或脚本中使用“变量=值”这种形式的赋值命令。如果使用local时不带实参，那么当前已定义的局部变量列表就送往标准输出显示。

readonly命令

语法：

readonly [options] [name[ = value]]

摘要：

用于显示或者设置只读变量。

Readonly命令使用两个选项：

-- 表明选项结束。所有后续参数都是实参

-f 创建只读函数

如果没有用参数，则readonly显示当前已定义的只读变量和函数的列表。

set命令

语法：

set [--abefhkmnptuvxidCHP] [-o option] [name [= value]]

摘要：

用于设置或者重置各种Shell选项。

set 命令可实现很多不同的功能——并非其中所有的功能都与变量有关。由于本节的其他命令重复了通过set命令可用的那些变量选项，所以这里对set命令不做详细说明。

shift命令

语法

shift [n]

摘要：

用于移动位置变量。

shift命令调整位置变量，使$3的值赋予$2，而$2的值赋予$1。当执行shift命令时，这种波动作用影响到所定义的各个位置变量。往往使用shift命令来检查过程参数的特定值——如为选项设置标志变量时。

typeset命令

语法：

typeset [options] [name [= value]]

摘要：

用于显示或者设置变量。

typeset 命令是declare命令的同义词。

unset命令

语法：

unset [options] name [name …]

摘要：

用于取消变量定义。

unset命令使用两个选项：

-- 表明选项结束，所有后续参数都是实参

-f 创建只读函数

unset命令从Shell环境中删除指定的变量和函数。注意，不能取消对PATH、IFS、PPID、PS1、PS2、UID和EUID的设置。如果我们取消RANDOM、SECONDS、LINENO或HISTCMD等变量的设置，它们就失去特有属性。

5.4 过程

本节介绍如何创建称做过程（procedure）的命令包。每当需要时就可调用这些命令包，它们用来存放在脚本中经常调用的一组命令。它们可以使脚本小而精，因为同样的命令序列不需要在整个脚本中重复多次。

Shell过程很少被使用，因为实质上Shell脚本追求的目标是小而且直截了当。然而，在个别情况下也会需要由过程提供额外帮助。其最大好处之一是允许创建高级别名。不是简单的把ls–l化名为ll，而是通过使用和管理过程中的参数可以得到更多创新。本章仅涉及基本的过程语法和如何使用参数。

过程（Procedure）具有给定名字（供今后使用）的命令块。过程是给定名字的Shell命令块，所以每当需要时就可使用它们。过程把代码组织成易于理解和易于使用的片断。让我们逐渐地构建脚本，按着这种方式测试它们。

当我们准备完成一个复杂的脚本时，应把它划分成若干任务，为每个任务建一个过程。随着我们开发出一小群过程，就会发现，写脚本变得容易了——有时就像用新方法把过程串在一起那样容易。这就称做代码重用（code reuse）。

当过程被source命令作用时，它们就被定义，好像我们输入它们所包含的Shell 命令。利用source命令可以使过程在原环境中执行（也可以用一个·代替source命令）。例3-1的命令行表示source命令在起作用。其中上讲，source命令表明该脚本并不在子Shell内部运行，而是运行在当前Shell环境中。

可以由Shell命令行直接调用过程（被source命令处理后）。事实上，创建很多过程都是为了增强现有的Shell命令，而创建其他过程是为了组合命令或者在显示一个命令的输入之前对它进行处理。

过程看起来像什么呢？例5-10给出了一个过程，它把该tar文件移到存储区分中，跟踪对tar文件的提取，展开tar文件。untar过程建立一个审计流水帐，它列出所用的tar文件的名字和其中的文件。

例5-10 untar——为tar命令创建一个审计流水帐

# ! /bin/bash

untar ( ) {

cp $1 store # 1

echo "-----" >> log/tar.log # 2

echo $1 >> log/tar.log # 3

date >> log/tar.log # 4

tar tf $1 >> log/tar.log # 5

tar xvf $1 # 6

rm -rf $1 # 7

ln -s store/$1 $1 # 8

}

这个脚本可以完成一项比较复杂的工作：

1）把tar文件拷贝到/store目录。在我的系统上，/store目录是一个单独的分区，我只用它存放tar文件，这样以后出现紧急事件时，就可以使用它们。

2）把一个分隔符行附加到用户的主目录的日志（log）文件中。这个日志文件记录tar命令的活动情况，供以后审计使用。

3）把tar文件的名字附加到日志文件。

4）把时间标签附加到日志文件。

5）把tar文件内部的文件清单附加到日志文件。

6）提取tar文件内部的文件并将其展开。

7）删除tar文件，以节省当前分区中的空间。

8）创建一个符号连接，连到当前目录中tar文件（在/data分区中）的新位置。这个符号连接并不是时常需要的，但是按磁盘空间来说它很便宜。

注意：

事实上，运行untar脚本还需要存在 /store目录，并且当前用户对目录可写。如果不是这种情况，那么可以在第1、7和8行之外加注释；或者简单地在主目录中创建一个存放目录，修改第1行和第7行，用~/store代替/store。

读者应该熟悉这个语法。$1位置变量在本章前面的内容中已介绍过，在那里它用来存取命令行参数。在例5-10中，它用来存取给该过程的参数。在这种情况下，它就是正被取消归档的tar文件的名字。

下面是该脚本执行的示例

$ chmod + x untar

$ source untar

$ untar medined.tar

提示：

运行一个过程不需要任何特殊机制，简单地使用它，就像任何其他Shell命令一样——当然，该脚本要被source命令处理之后。我们可以由命令行或者由另一个脚本文件运行untar过程。一旦过程被source命令处理，它就变成该Shell的一部分，可用于“常规”Bash命令能出现的任何地方。

untar命令不显示任何输出。相反，其信息被送往称做~/tar.log的日志文件中。如果我们想试一试这个过程，那么要检查在主目录中创建的这个日志文件。在以上命令序列执行后，日志文件如下所示：

-------

medinets.tar

Sat Mar 14 15: 42: 31 EST 1998

name.pl

desk.pl

pen.pl

这个输出表示，在1998年3月14日下午3：42从medinets.tar文件中提了三个文件。如果我们与tar文件打得交道很多，我们想记住一个特定文件来自哪个tar文件，那么这个消息可能迟早有用。

如前面提到的，可以在脚本内部使用过程（或我们创建的任何其他过程）。调用一个过程就意味着Shell停止执行当前的一系列命令，执行流跳到该过程内部的命令那里。当过程完成时，Shell又跳回到该过程的调用点。程序继续从那一点向下执行。过程定义的基本语法是：

过程名 ( ) {

}

亦即：根本没有任何复杂的东西，在“过程名”这个地方使用我们自己的过程名，并且在一对大括号之间放上过程的各个命令。

在过程内部使用变量

在本章中介绍了位置变量——$1、$2等等，当与过程一道使用这些变量时，Shell在进入以前保留变量的值，在退出过程后恢复它们。

让我们更仔细地看看这种行为。例5-11给出一个过程，它简单地说明如何把很多参数传递给它。

例5-11 03lst02.sh——打印所接收的参数个数的简单过程

test ( ) {

echo $#

}

试执行以下使用例5-11命令：

$ source 03lst02.sh

$ test one two three

$ test one

$ test

$# 特殊变量总是包含传给脚本的参数个数。在一个过程内部$# 的值出现什么情况呢？请见例5-12。

例5-12 03lst03.sh——考察过程内部$ # 的值

# ! /bin /bash

test_two ( ) {

echo "Test Two: $# "

}

test ( ) {

echo "Test One: $# "

test_two one two

test_two

echo "Test One : $# "

}

试执行以下使用例5-12的命令：

$ source 03lst02.sh

$ test one

Test One: 1

Test Two: 2

Test Two: 0

Test One: 1

从输出中可以看出，在test_two被调用之前$# 变量被保存起来，以后，在退出test_two之后，恢复其原有值。

5.4.2 shift 命令

3.2 shift命令

shift命令调整位置变量，使$3的值赋给$2, $2 的值赋给$1。当执行shift命令时，这种波动作用影响所定义的任何位置变量。shift命令往往用于核查传给过程的参数的特定值——如下面示例中为选项设定标志（flag）变量。

例5-13 核查其所有参数是否是-x选项，然后将下面的参数作日志文件的名字。

例5-13 test_shift——使用shift命令设置标志变量

# ! /bin/bash

for element in $@

# ignore all elements except "-x"

if test "$1" = "-x"

then

logfile=$2

shift

done

echo "logfile= $logfile"

下面是这个脚本执行的示例：

$ chmod + x test_shift

$ test_shift one two three

logfile =

$ test_shift one –x shift.log three

logfile = shift.log

当循环语句遇到-x字符串作为一个参数时，就把下一个参数（即$2）的值赋给logfile变量。shift命令保证依次检测每个参数。

5.4.3 建立局部过程变量

从例5-12可以看出，Shell保存并恢复位置变量的值。实际上，当进入一个过程时，其$ #变量(或位置变量)的值都是局部的。然而，普通变量（regular）不能受到这个特殊对待。一般情况下，它们的值是全局的。例5-14解释了多数变量的全局属性。

例5-14 03lst06.sh——变量默认是全局的。

#! /bin/bash

test_two ( ) {

test_var =5

echo "Test Two: $test_var"

}

test ( ) {

test_var =1

echo "Test One: $test_var"

test_two

echo "Test One: $test_var"

}

利用例5-14 试执行以下命令序列：

$ source 03lst06.sh

$ test

Test One: 1

Test Two: 5

Test One: 5

这些结果表明，test_two过程能“永久地”改变$ test_var的值（当过程退出时其初始值不被恢复）。这意味着对两个过程来说$ test_var是全局的。

可以利用local命令改变这种性质。利用local命令对过程的变量所作的修改不影响其他过程。例5-15显示出这种情况。

例5-15 03lst07.sh——local命令所起作用

#! /bin/bash

test_two ( ) {

test_var =5

echo "Test Two: $ test_var"

}

test ( ) {

test_var =1

echo "Test One: $ test_var"

test_two

echo "Test One: $test_var"

}

使用例5-15 试执行以下命令序列：

$ source 03lst07.sh

$ test

Test One: 1

Test Two: 5

Test One: 1

请注意$ test_var最初的值是如何保留的。如果我们创建大的脚本，包括很多过程，那么迟早要用local命令。使变量值局于一个过程就更容易理解它们，因为在一个过程中所做的修改不影响其他过程。

5.4.4 过程返回值

一个过程的返回值始终是其最后执行的那条命令的返回值。

提示：

如果我们愿意，不必使用return ( )函数来返回值，因为Bash会自动返回最后计算的表达式值。

我们用过的程序设计语言或许能区分开函数和子例程。二者的差别在于函数返回值，而子例程不返回值。Bash不做这种区分。所有的过程、命令、程序和脚本都有返回值——即使仅为表示成功的默认值（即0）。

5.5 脚本执行命令

本节介绍控制脚本执行的命令。迄今为止本书所有介绍的Shell脚本基本上是顺序执行的。尽管我们有必要使用顺序脚本，但多数时间却会要求更多的灵活性。本章提供的命令能测试过程和命令的返回值，并且执行一个以上的语句块。我们也能见到如何捕获信号和随意离开脚本，而不是仅在脚本文件的末尾才离开。

表5-7 列出的命令提供了脚本的灵活性或对它的控制。利用这些命令可做出判定。重复执行命令块（也称做循环），以及用其他方式控制脚本。

表5-7 控制脚本执行的命令

命令	说明
break	break命令导致退出当前命令块
case	case命令可以替换if语句。它通常用于需要基于一个有多个可能值的变量做出判定的情况
continue	continue命令跳过命令块中的其余命令。它与for、while和until命令一块使用
exit	exit命令强行使脚本终止。当检测到错误条件时，它就非常有用
for	for命令重复一组值（或值表），对于表中的每个值分别执行专门的语句块一次
if	if命令让我们根据动作的一种或多种情况做出判定
trap	trap命令让我们的脚本接受信号并对它们起作用。如果我们的脚本要作某些特别重要的事情，那么我们或许要捕获某些信号，以避免中断。trap命令也用来恰好在退出脚本之前运行“清理”命令
until	until命令重复执行一个命令块，直至测试成功（返回值为0）
while	像until命令一样，while命令重复一个命令块。然而，在测试成功时并不停止执行。当测试失败（即返回非0值）时它才停止执行

注意：

为了避免对Shell脚本的读者（或我们自己！）造成混乱，给变量和过程起名字时应与Shell命令区分开。

5.5.1 exit 命令

语法：

exit [n]

摘要：

强行使一个脚本终止，将n的值返回给调用进程。

exit命令允许我们用受限方式在两个脚本间进行通信。它给一个脚本分配一个终止值，而该脚本可以在另一个脚本中计算。利用下述三个小的脚本（例5-16~例5-18）看一看这种情况是如何实现的。

例5-16 给出success脚本。当它运行时，直接以0值终止，这是标准的成功指示符。

例5-16 success——永远返回成功值的命令

# ! /bin/bash

exit 0

例 5-17给出failure脚本。当它运行时，直接以值1终止，这是标准的失败指示符。实际上，任何非0值都表示失败。有些程序对不同的非0值赋予特定的意义。

例5-17 failure——永远返回失败值的命令

# ! /bin/bash

exit 1

例5-18 test_return——测试它的第一个参数或实参的命令

# ! /bin/bash

if `$1`

then

echo " The Test Worked. "

else

echo " The Test Failed. "

有关if命令的更多信息，参见本章后面的5.5.3节。

下面是这些脚本执行情况的示例：

$ chmod + x success failure test_return

$ ./test_return ./success

The Test Worked.

$ ./test_return ./failure

The Test Failed.

test_return脚本运行其实参，并测试其终止值。结果终止值为0，那么就表示成功，从而运行第一个echo命令。否则就表示失败，运行第二个echo命令。

success 和failure脚本显式地告诉exit命令用哪个值；我们也可以用Shell命令替换字面值。例如，以下代码行是完美的：

exit `failure`

假设我们已经建立了failure脚本，这可能是增加脚本文件可读性的更好的方式（是以某些额外的CPU周期为代价）。但是当我们把脚本从一台机器移植另一台机器时，也需要把success和failure脚本移过去。或许这不是最好的办法。

5.5.2 trap命令

语法：

trap [-1] [commands] signals]

摘要：

让我们的脚本接受信号，并有选择地对它们起作用。

什么是信号？信号就是当特定事件发生时，由Shell向我们的脚本发送一个信号。例如，如果我们的脚本拨入另一台机器，此时电话线断了，那么就产生一个信号——SIGHUP或者挂断（hangup）信号。

trap命令的最简单用途就是用它忽略信号。如果想让我们的脚本忽略CTRL-C组合键，可在脚本前面使用下述代码行：

trap " " 2

或者

trap " " SIGINT

例5-19的程序从键盘（实际是标准输入，但我们不想太技术性了）上读取输入行。用户可以按CTRL-C不会导致程序中断。当用户只键入“a”，然后按< ENTER>，该脚本就循环。如果读到任何其他输入，同脚本结束。

例5-19 test_ sigint——用SIGINT进行实验的脚本

#! /bin/bash

#trap "" SIGINT

input= "a"

while [$input = "a" ]

echo " Type 'a' to continue, anything else to quit: "

read input

done

echo " The script is done. "

首先运行被注释出的带trap命令的脚本（在第二行开头使用了#字符）。这导致以下输出：

$ chmod + x test_sigint

$ test_sigint