1. Linux 脚本编写基础
--------------------------------------------------------------------------------------------------
(5)用户启动文件 .profile
PATH=$PATH:/usr/loacl/bin; export PATH
3.Shell Script编程
目的：使用UNIX所提供的最常用工具来完成所需复杂任务的强大功能。
(4)条件判断
. if-then语句,格式如下:
if command_1
then
command_2
command_3
fi
command_4
$ shifter 1 2 3 4
Argument is 1 and 3 argument(s) remain
Argument is 2 and 2 argument(s) remain
Argument is 3 and 1 argument(s) remain
Argument is 4 and 0 argument(s) remain
$
$ sh sumints 324 34 34 12 34
438
$
<4>. for循环
格式：
for var in arg1 arg2 ... argn
do
command
....
command
done
<6> 从循环中退出： break和continue命令
break 立即退出循环
continue 忽略本循环中的其他命令，继续下一下循环
(6)结构化编程：定义函数
同其他高级语言一样，shell也提供了函数功能。函数通常也称之为子过程(subroutine),
其定义格式如下：
使用函数的另一个好处就是可以在一个程序中的不同地方执行相同的命令序列(函数),
如下所示：
** shell函数与shell程序非常相似，但二者有一个非常重要的差别：shell程序是由子shell
执行的，而shell函数则是作为当前shell的一部分被执行的，因此在当前shell中可以改
变函数的定义。此外在任意shell(包括交互式的shell)中均可定义函数，如：
(8) 使用getopts命令读取unix格式选项
UNIX格式选项指如下格式的命令行参数：
command -options parameters
示例程序：复制程序
while getopts vc: OPTION
do
case $OPTION
in
c) COPIES=$OPTARG;;
v) VERBOSE=Y;;
\?) echo "Illegal Option"
exit 1;;
esac
done
shift `expr $OPTIND -1`
$ duplicate -v fileA
fileA1
$ duplicate -c 3 -v fileB
fileB1
fileB2
fileB3
4. Shell的定制
通常使用shell的定制来控制用户自己的环境，比如改变shell的外观(提示符)以及增强
自己的命令。
$ IFS=":"
$ echo:Hello:my:Friend
Hello my Friend
5. 有关shell的专门讨论
(1)shell程序的调试
切记：程序员（人）总是会犯错误的，而计算机是不会错的。
使用-x进行跟踪执行，执行并显示每一条指令。
总结：
在本章中讲述了Bourne Shell的基本知识,使用shell变量，shell script基础。这些概念
对于理解学习Korn Shell, csh以及其他script编程都是非常有用的。
1.1 语法基本介绍
1.1.1 开头
程序必须以下面的行开始（必须方在文件的第一行）：
#!/bin/sh
符号#!用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。
当编辑好脚本时，如果要执行该脚本，还必须使其可执行。
要使脚本可执行：
编译 chmod +x filename 这样才能用./filename 来运行
1.1.2 注释
在进行shell编程时，以#开头的句子表示注释，直到这一行的结束。我们真诚地建议您在程序中使用注释。
如果您使用了注释，那么即使相当长的时间内没有使用该脚本，您也能在很短的时间内明白该脚本的作用及工作原理。
1.1.3 变量
在其他编程语言中您必须使用变量。在shell编程中，所有的变量都由字符串组成，并且您不需要对变量进行声明。要赋值给一个变量，您可以这样写：
#!/bin/sh
#对变量赋值：
a="hello world"
# 现在打印变量a的内容：
echo "A is:"
echo $a
有时候变量名很容易与其他文字混淆，比如：
num=2
echo "this is the $numnd"
这并不会打印出"this is the 2nd"，而仅仅打印"this is the "，因为shell会去搜索变量numnd的值，但是这个变量时没有值的。可以使用花括号来告诉shell我们要打印的是num变量：
num=2
echo "this is the ${num}nd"
这将打印： this is the 2nd
1.1.4 环境变量
由export关键字处理过的变量叫做环境变量。我们不对环境变量进行讨论，因为通常情况下仅仅在登录脚本中使用环境变量。
1.1.5 Shell命令和流程控制
在shell脚本中可以使用三类命令：
1)Unix 命令:
虽然在shell脚本中可以使用任意的unix命令，但是还是由一些相对更常用的命令。这些命令通常是用来进行文件和文字操作的。
常用命令语法及功能
echo "some text": 将文字内容打印在屏幕上
ls: 文件列表
wc –l filewc -w filewc -c file: 计算文件行数计算文件中的单词数计算文件中的字符数
cp sourcefile destfile: 文件拷贝
mv oldname newname : 重命名文件或移动文件
rm file: 删除文件
grep 'pattern' file: 在文件内搜索字符串比如：grep 'searchstring' file.txt
cut -b colnum file: 指定欲显示的文件内容范围，并将它们输出到标准输出设备比如：输出每行第5个到第9个字符cut -b5-9 file.txt千万不要和cat命令混淆，
这是两个完全不同的命令
cat file.txt: 输出文件内容到标准输出设备（屏幕）上
file somefile: 得到文件类型
read var: 提示用户输入，并将输入赋值给变量
sort file.txt: 对file.txt文件中的行进行排序
uniq: 删除文本文件中出现的行列比如： sort file.txt | uniq
expr: 进行数学运算Example: add 2 and 3expr 2 "+" 3
find: 搜索文件比如：根据文件名搜索find . -name filename -print
tee: 将数据输出到标准输出设备(屏幕) 和文件比如：somecommand | tee outfile
basename file: 返回不包含路径的文件名比如： basename /bin/tux将返回 tux
dirname file: 返回文件所在路径比如：dirname /bin/tux将返回 /bin
head file: 打印文本文件开头几行
tail file : 打印文本文件末尾几行
sed: Sed是一个基本的查找替换程序。可以从标准输入（比如命令管道）读入文本，并将
结果输出到标准输出（屏幕）。该命令采用正则表达式（见参考）进行搜索。不要和shell中的通配符相混淆。比如：将linuxfocus 替换为LinuxFocus ：cat text.file | sed 's/linuxfocus/LinuxFocus/' > newtext.file awk: awk 用来从文本文件中提取字段。缺省地，字段分割符是空格，可以使用-F指定其他分割符。
cat file.txt | awk -F, '{print $1 "," $3 }'这里我们使用，作为字段分割符，同时打印第一个和第三个字段。如果该文件内容如下： Adam Bor, 34, IndiaKerry Miller, 22, USA命令输出结果为：Adam Bor, IndiaKerry Miller, USA
2) 概念: 管道, 重定向和 backtick
这些不是系统命令，但是他们真的很重要。
管道 (|) 将一个命令的输出作为另外一个命令的输入。
grep "hello" file.txt | wc -l
在file.txt中搜索包含有”hello”的行并计算其行数。
在这里grep命令的输出作为wc命令的输入。当然您可以使用多个命令。
重定向：将命令的结果输出到文件，而不是标准输出（屏幕）。
> 写入文件并覆盖旧文件
>> 加到文件的尾部，保留旧文件内容。
反短斜线
使用反短斜线可以将一个命令的输出作为另外一个命令的一个命令行参数。
命令：
find . -mtime -1 -type f -print
用来查找过去24小时（-mtime –2则表示过去48小时）内修改过的文件。如果您想将所有查找到的文件打一个包，则可以使用以下脚本：
#!/bin/sh
# The ticks are backticks (`) not normal quotes ('):
tar -zcvf lastmod.tar.gz `find . -mtime -1 -type f -print`
3) 流程控制
1.if
"if" 表达式 如果条件为真则执行then后面的部分：
if ....; then
....
elif ....; then
....
else
....
fi
大多数情况下，可以使用测试命令来对条件进行测试。比如可以比较字符串、判断文件是否存在及是否可读等等…
通常用" [ ] "来表示条件测试。注意这里的空格很重要。要确保方括号的空格。
[ -f "somefile" ] ：判断是否是一个文件
[ -x "/bin/ls" ] ：判断/bin/ls是否存在并有可执行权限
[ -n "$var" ] ：判断$var变量是否有值
[ "$a" = "$b" ] ：判断$a和$b是否相等
执行man test可以查看所有测试表达式可以比较和判断的类型。
直接执行以下脚本：
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; then
echo "your login shell is the bash (bourne again shell)"
else
echo "your login shell is not bash but $SHELL"
fi
变量$SHELL包含了登录shell的名称，我们和/bin/bash进行了比较。
快捷操作符
熟悉C语言的朋友可能会很喜欢下面的表达式：
[ -f "/etc/shadow" ] && echo "This computer uses shadow passwors"
这里 && 就是一个快捷操作符，如果左边的表达式为真则执行右边的语句。
您也可以认为是逻辑运算中的与操作。上例中表示如果/etc/shadow文件存在则打印” This computer uses shadow passwors”。同样或操作(||)在shell编程中也是可用的。这里有个例子：
#!/bin/sh
mailfolder=/var/spool/mail/james
[ -r "$mailfolder" ]' '{ echo "Can not read $mailfolder" ; exit 1; }
echo "$mailfolder has mail from:"
grep "^From " $mailfolder
该脚本首先判断mailfolder是否可读。如果可读则打印该文件中的"From" 一行。如果不可读则或操作生效，打印错误信息后脚本退出。这里有个问题，那就是我们必须有两个命令：
-打印错误信息
-退出程序
我们使用花括号以匿名函数的形式将两个命令放到一起作为一个命令使用。一般函数将在下文提及。
不用与和或操作符，我们也可以用if表达式作任何事情，但是使用与或操作符会更便利很多。
1.1.1 开头
程序必须以下面的行开始（必须方在文件的第一行）：
#!/bin/sh
符号#!用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。
当编辑好脚本时，如果要执行该脚本，还必须使其可执行。
要使脚本可执行：
编译 chmod +x filename 这样才能用./filename 来运行
1.1.2 注释
在进行shell编程时，以#开头的句子表示注释，直到这一行的结束。我们真诚地建议您在程序中使用注释。
如果您使用了注释，那么即使相当长的时间内没有使用该脚本，您也能在很短的时间内明白该脚本的作用及工作原理。
1.1.3 变量
在其他编程语言中您必须使用变量。在shell编程中，所有的变量都由字符串组成，并且您不需要对变量进行声明。要赋值给一个变量，您可以这样写：
#!/bin/sh
#对变量赋值：
a="hello world"
# 现在打印变量a的内容：
echo "A is:"
echo $a
有时候变量名很容易与其他文字混淆，比如：
num=2
echo "this is the $numnd"
这并不会打印出"this is the 2nd"，而仅仅打印"this is the "，因为shell会去搜索变量numnd的值，但是这个变量时没有值的。可以使用花括号来告诉shell我们要打印的是num变量：
num=2
echo "this is the ${num}nd"
这将打印： this is the 2nd
1.1.4 环境变量
由export关键字处理过的变量叫做环境变量。我们不对环境变量进行讨论，因为通常情况下仅仅在登录脚本中使用环境变量。
1.1.5 Shell命令和流程控制
在shell脚本中可以使用三类命令：
1)Unix 命令:
虽然在shell脚本中可以使用任意的unix命令，但是还是由一些相对更常用的命令。这些命令通常是用来进行文件和文字操作的。
常用命令语法及功能
echo "some text": 将文字内容打印在屏幕上
ls: 文件列表
wc –l filewc -w filewc -c file: 计算文件行数计算文件中的单词数计算文件中的字符数
cp sourcefile destfile: 文件拷贝
mv oldname newname : 重命名文件或移动文件
rm file: 删除文件
grep 'pattern' file: 在文件内搜索字符串比如：grep 'searchstring' file.txt
cut -b colnum file: 指定欲显示的文件内容范围，并将它们输出到标准输出设备比如：输出每行第5个到第9个字符cut -b5-9 file.txt千万不要和cat命令混淆，
这是两个完全不同的命令
cat file.txt: 输出文件内容到标准输出设备（屏幕）上
file somefile: 得到文件类型
read var: 提示用户输入，并将输入赋值给变量
sort file.txt: 对file.txt文件中的行进行排序
uniq: 删除文本文件中出现的行列比如： sort file.txt | uniq
expr: 进行数学运算Example: add 2 and 3expr 2 "+" 3
find: 搜索文件比如：根据文件名搜索find . -name filename -print
tee: 将数据输出到标准输出设备(屏幕) 和文件比如：somecommand | tee outfile
basename file: 返回不包含路径的文件名比如： basename /bin/tux将返回 tux
dirname file: 返回文件所在路径比如：dirname /bin/tux将返回 /bin
head file: 打印文本文件开头几行
tail file : 打印文本文件末尾几行
sed: Sed是一个基本的查找替换程序。可以从标准输入（比如命令管道）读入文本，并将
结果输出到标准输出（屏幕）。该命令采用正则表达式（见参考）进行搜索。不要和shell中的通配符相混淆。比如：将linuxfocus 替换为LinuxFocus ：cat text.file | sed 's/linuxfocus/LinuxFocus/' > newtext.file awk: awk 用来从文本文件中提取字段。缺省地，字段分割符是空格，可以使用-F指定其他分割符。
cat file.txt | awk -F, '{print $1 "," $3 }'这里我们使用，作为字段分割符，同时打印第一个和第三个字段。如果该文件内容如下： Adam Bor, 34, IndiaKerry Miller, 22, USA命令输出结果为：Adam Bor, IndiaKerry Miller, USA
2) 概念: 管道, 重定向和 backtick
这些不是系统命令，但是他们真的很重要。
管道 (|) 将一个命令的输出作为另外一个命令的输入。
grep "hello" file.txt | wc -l
在file.txt中搜索包含有”hello”的行并计算其行数。
在这里grep命令的输出作为wc命令的输入。当然您可以使用多个命令。
重定向：将命令的结果输出到文件，而不是标准输出（屏幕）。
> 写入文件并覆盖旧文件
>> 加到文件的尾部，保留旧文件内容。
反短斜线
使用反短斜线可以将一个命令的输出作为另外一个命令的一个命令行参数。
命令：
find . -mtime -1 -type f -print
用来查找过去24小时（-mtime –2则表示过去48小时）内修改过的文件。如果您想将所有查找到的文件打一个包，则可以使用以下脚本：
#!/bin/sh
# The ticks are backticks (`) not normal quotes ('):
tar -zcvf lastmod.tar.gz `find . -mtime -1 -type f -print`
3) 流程控制
1.if
"if" 表达式 如果条件为真则执行then后面的部分：
if ....; then
....
elif ....; then
....
else
....
fi
大多数情况下，可以使用测试命令来对条件进行测试。比如可以比较字符串、判断文件是否存在及是否可读等等…
通常用" [ ] "来表示条件测试。注意这里的空格很重要。要确保方括号的空格。
[ -f "somefile" ] ：判断是否是一个文件
[ -x "/bin/ls" ] ：判断/bin/ls是否存在并有可执行权限
[ -n "$var" ] ：判断$var变量是否有值
[ "$a" = "$b" ] ：判断$a和$b是否相等
执行man test可以查看所有测试表达式可以比较和判断的类型。
直接执行以下脚本：
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; then
echo "your login shell is the bash (bourne again shell)"
else
echo "your login shell is not bash but $SHELL"
fi
变量$SHELL包含了登录shell的名称，我们和/bin/bash进行了比较。
快捷操作符
熟悉C语言的朋友可能会很喜欢下面的表达式：
[ -f "/etc/shadow" ] && echo "This computer uses shadow passwors"
这里 && 就是一个快捷操作符，如果左边的表达式为真则执行右边的语句。
您也可以认为是逻辑运算中的与操作。上例中表示如果/etc/shadow文件存在则打印” This computer uses shadow passwors”。同样或操作(||)在shell编程中也是可用的。这里有个例子：
#!/bin/sh
mailfolder=/var/spool/mail/james
[ -r "$mailfolder" ]' '{ echo "Can not read $mailfolder" ; exit 1; }
echo "$mailfolder has mail from:"
grep "^From " $mailfolder
该脚本首先判断mailfolder是否可读。如果可读则打印该文件中的"From" 一行。如果不可读则或操作生效，打印错误信息后脚本退出。这里有个问题，那就是我们必须有两个命令：
-打印错误信息
-退出程序
我们使用花括号以匿名函数的形式将两个命令放到一起作为一个命令使用。一般函数将在下文提及。
不用与和或操作符，我们也可以用if表达式作任何事情，但是使用与或操作符会更便利很多。
2.case
case :表达式可以用来匹配一个给定的字符串，而不是数字。
case ... in
...) do something here ;;
esac
让我们看一个例子。 file命令可以辨别出一个给定文件的文件类型，比如：
file lf.gz
这将返回：
lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
我们利用这一点写了一个叫做smartzip的脚本，该脚本可以自动解压bzip2, gzip 和zip 类型的压缩文件：
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
unzip "$1" ;;
"$1: gzip compressed"*)
gunzip "$1" ;;
"$1: bzip2 compressed"*)
bunzip2 "$1" ;;
*) echo "File $1 can not be uncompressed with smartzip";;
esac
您可能注意到我们在这里使用了一个特殊的变量$1。该变量包含了传递给该程序的第一个参数值。
也就是说，当我们运行：
smartzip articles.zip
$1 就是字符串 articles.zip
case ... in
...) do something here ;;
esac
让我们看一个例子。 file命令可以辨别出一个给定文件的文件类型，比如：
file lf.gz
这将返回：
lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
我们利用这一点写了一个叫做smartzip的脚本，该脚本可以自动解压bzip2, gzip 和zip 类型的压缩文件：
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
unzip "$1" ;;
"$1: gzip compressed"*)
gunzip "$1" ;;
"$1: bzip2 compressed"*)
bunzip2 "$1" ;;
*) echo "File $1 can not be uncompressed with smartzip";;
esac
您可能注意到我们在这里使用了一个特殊的变量$1。该变量包含了传递给该程序的第一个参数值。
也就是说，当我们运行：
smartzip articles.zip
$1 就是字符串 articles.zip
3. selsect
select 表达式是一种bash的扩展应用，尤其擅长于交互式使用。用户可以从一组不同的值中进行选择。
select var in ... ; do
break
done
.... now $var can be used ....
下面是一个例子：
#!/bin/sh
echo "What is your favourite OS?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do
break
done
echo "You have selected $var"
下面是该脚本运行的结果：
What is your favourite OS?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#? 1
You have selected Linux
select var in ... ; do
break
done
.... now $var can be used ....
下面是一个例子：
#!/bin/sh
echo "What is your favourite OS?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do
break
done
echo "You have selected $var"
下面是该脚本运行的结果：
What is your favourite OS?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#? 1
You have selected Linux
4.loop
loop表达式：
while ...; do
....
done
while-loop 将运行直到表达式测试为真。will run while the expression that we test for is true.
关键字"break" 用来跳出循环。而关键字”continue”用来不执行余下的部分而直接跳到下一个循环。
for-loop表达式查看一个字符串列表 (字符串用空格分隔) 然后将其赋给一个变量：
for var in ....; do
....
done
在下面的例子中，将分别打印ABC到屏幕上：
#!/bin/sh
for var in A B C ; do
echo "var is $var"
done
下面是一个更为有用的脚本showrpm，其功能是打印一些RPM包的统计信息：
#!/bin/sh
# list a content summary of a number of RPM packages
# USAGE: showrpm rpmfile1 rpmfile2 ...
# EXAMPLE: showrpm /cdrom/RedHat/RPMS/*.rpm
for rpmpackage in $*; do
if [ -r "$rpmpackage" ];then
echo "=============== $rpmpackage =============="
rpm -qi -p $rpmpackage
else
echo "ERROR: cannot read file $rpmpackage"
fi
done
这里出现了第二个特殊的变量$*，该变量包含了所有输入的命令行参数值。
如果您运行showrpm openssh.rpm w3m.rpm webgrep.rpm
此时 $* 包含了 3 个字符串，即openssh.rpm, w3m.rpm and webgrep.rpm.
while ...; do
....
done
while-loop 将运行直到表达式测试为真。will run while the expression that we test for is true.
关键字"break" 用来跳出循环。而关键字”continue”用来不执行余下的部分而直接跳到下一个循环。
for-loop表达式查看一个字符串列表 (字符串用空格分隔) 然后将其赋给一个变量：
for var in ....; do
....
done
在下面的例子中，将分别打印ABC到屏幕上：
#!/bin/sh
for var in A B C ; do
echo "var is $var"
done
下面是一个更为有用的脚本showrpm，其功能是打印一些RPM包的统计信息：
#!/bin/sh
# list a content summary of a number of RPM packages
# USAGE: showrpm rpmfile1 rpmfile2 ...
# EXAMPLE: showrpm /cdrom/RedHat/RPMS/*.rpm
for rpmpackage in $*; do
if [ -r "$rpmpackage" ];then
echo "=============== $rpmpackage =============="
rpm -qi -p $rpmpackage
else
echo "ERROR: cannot read file $rpmpackage"
fi
done
这里出现了第二个特殊的变量$*，该变量包含了所有输入的命令行参数值。
如果您运行showrpm openssh.rpm w3m.rpm webgrep.rpm
此时 $* 包含了 3 个字符串，即openssh.rpm, w3m.rpm and webgrep.rpm.
5. 引号
在向程序传递任何参数之前，程序会扩展通配符和变量。这里所谓扩展的意思是程序会把通配符（比如*）替换成合适的文件名，它变量替换成变量值。为了防止程序作这种替换，您可以使用引号：让我们来看一个例子，假设在当前目录下有一些文件，两个jpg文件， mail.jpg 和tux.jpg。
1.2 编译SHELL脚本
#ch#!/bin/sh mod +x filename
cho *.jpg ∪缓螅梢酝ü淙耄?./filename 来执行您的脚本。
这将打印出"mail.jpg tux.jpg"的结果。
引号 (单引号和双引号) 将防止这种通配符扩展：
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
这将打印"*.jpg" 两次。
单引号更严格一些。它可以防止任何变量扩展。双引号可以防止通配符扩展但允许变量扩展。
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
运行结果为：
/bin/bash
/bin/bash
$SHELL
最后，还有一种防止这种扩展的方法，那就是使用转义字符——反斜杆：
echo *.jpg
echo $SHELL
这将输出：
*.jpg
$SHELL
1.2 编译SHELL脚本
#ch#!/bin/sh mod +x filename
cho *.jpg ∪缓螅梢酝ü淙耄?./filename 来执行您的脚本。
这将打印出"mail.jpg tux.jpg"的结果。
引号 (单引号和双引号) 将防止这种通配符扩展：
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
这将打印"*.jpg" 两次。
单引号更严格一些。它可以防止任何变量扩展。双引号可以防止通配符扩展但允许变量扩展。
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
运行结果为：
/bin/bash
/bin/bash
$SHELL
最后，还有一种防止这种扩展的方法，那就是使用转义字符——反斜杆：
echo *.jpg
echo $SHELL
这将输出：
*.jpg
$SHELL
6. Here documents
当要将几行文字传递给一个命令时，here documents（译者注：目前还没有见到过对该词适合的翻译）一种不错的方法。对每个脚本写一段帮助性的文字是很有用的，此时如果我们四有那个 here documents就不必用echo函数一行行输出。 一个 "Here document" 以 << 开头，后面接上一个字符串，这个字符串还必须出现在here document的末尾。下面是一个例子，在该例子中，我们对多个文件进行重命名，并且使用here documents打印帮助：
#!/bin/sh
# we have less than 3 arguments. Print the help text:
if [ $# -lt 3 ] ; then
cat <
ren -- renames a number of files using sed regular expressions
USAGE: ren 'regexp' 'replacement' files...
EXAMPLE: rename all *.HTM files in *.html:
ren 'HTM
HELP
exit 0
fi
OLD="$1"
NEW="$2"
# The shift command removes one argument from the list of
# command line arguments.
shift
shift
# $* contains now all the files:
for file in $*; do
if [ -f "$file" ] ; then
newfile=`echo "$file" | sed "s/${OLD}/${NEW}/g"`
if [ -f "$newfile" ]; then
echo "ERROR: $newfile exists already"
else
echo "renaming $file to $newfile ..."
mv "$file" "$newfile"
fi
fi
done
这是一个复杂一些的例子。让我们详细讨论一下。第一个if表达式判断输入命令行参数是否小于3个 (特殊变量$# 表示包含参数的个数) 。如果输入参数小于3个，则将帮助文字传递给cat命令，然后由cat命令将其打印在屏幕上。打印帮助文字后程序退出。如果输入参数等于或大于3个，我们就将第一个参数赋值给变量OLD，第二个参数赋值给变量NEW。下一步，我们使用shift命令将第一个和第二个参数从参数列表中删除，这样原来的第三个参数就成为参数列表$*的第一个参数。然后我们开始循环，命令行参数列表被一个接一个地被赋值给变量$file。接着我们判断该文件是否存在，如果存在则通过sed命令搜索和替换来产生新的文件名。然后将反短斜线内命令结果赋值给newfile。这样我们就达到了我们的目的：得到了旧文件名和新文件名。然后使用mv命令进行重命名。
#!/bin/sh
# we have less than 3 arguments. Print the help text:
if [ $# -lt 3 ] ; then
cat <
ren -- renames a number of files using sed regular expressions
USAGE: ren 'regexp' 'replacement' files...
EXAMPLE: rename all *.HTM files in *.html:
ren 'HTM
'html' *.HTM
HELP
exit 0
fi
OLD="$1"
NEW="$2"
# The shift command removes one argument from the list of
# command line arguments.
shift
shift
# $* contains now all the files:
for file in $*; do
if [ -f "$file" ] ; then
newfile=`echo "$file" | sed "s/${OLD}/${NEW}/g"`
if [ -f "$newfile" ]; then
echo "ERROR: $newfile exists already"
else
echo "renaming $file to $newfile ..."
mv "$file" "$newfile"
fi
fi
done
这是一个复杂一些的例子。让我们详细讨论一下。第一个if表达式判断输入命令行参数是否小于3个 (特殊变量$# 表示包含参数的个数) 。如果输入参数小于3个，则将帮助文字传递给cat命令，然后由cat命令将其打印在屏幕上。打印帮助文字后程序退出。如果输入参数等于或大于3个，我们就将第一个参数赋值给变量OLD，第二个参数赋值给变量NEW。下一步，我们使用shift命令将第一个和第二个参数从参数列表中删除，这样原来的第三个参数就成为参数列表$*的第一个参数。然后我们开始循环，命令行参数列表被一个接一个地被赋值给变量$file。接着我们判断该文件是否存在，如果存在则通过sed命令搜索和替换来产生新的文件名。然后将反短斜线内命令结果赋值给newfile。这样我们就达到了我们的目的：得到了旧文件名和新文件名。然后使用mv命令进行重命名。
4)函数
如果您写了一些稍微复杂一些的程序，您就会发现在程序中可能在几个地方使用了相同的代码，并且您也会发现，如果我们使用了函数，会方便很多。一个函数是这个样子的：
functionname()
{
# inside the body $1 is the first argument given to the function
# $2 the second ...
body
}
您需要在每个程序的开始对函数进行声明。
下面是一个叫做xtitlebar的脚本，使用这个脚本您可以改变终端窗口的名称。
这里使用了一个叫做help的函数。正如您可以看到的那样，这个定义的函数被使用了两次。
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
xtitlebar -- change the name of an xterm, gnome-terminal or kde konsole
USAGE: xtitlebar [-h] "string_for_titelbar"
OPTIONS: -h help text
EXAMPLE: xtitlebar "cvs"
HELP
exit 0
}
# in case of error or if -h is given we call the function help:
[ -z "$1" ] && help
[ "$1" = "-h" ] && help
# send the escape sequence to change the xterm titelbar:
echo -e "33]0;$107"
#
在脚本中提供帮助是一种很好的编程习惯，这样方便其他用户（和您）使用和理解脚本。
命令行参数
我们已经见过$* 和 $1, $2 ... $9 等特殊变量，这些特殊变量包含了用户从命令行输入的参数。迄今为止，我们仅仅了解了一些简单的命令行语法（比如一些强制性的参数和查看帮助的-h选项）。但是在编写更复杂的程序时，您可能会发现您需要更多的自定义的选项。通常的惯例是在所有可选的参数之前加一个减号，后面再加上参数值 (比如文件名)。
有好多方法可以实现对输入参数的分析，但是下面的使用case表达式的例子无遗是一个不错的方法。
#!/bin/sh
help()
{
cat <
This is a generic command line parser demo.
USAGE EXAMPLE: cmdparser -l hello -f -- -somefile1 somefile2
HELP
exit 0
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
-f) opt_f=1;shift 1;; # variable opt_f is set
-l) opt_l=$2;shift 2;; # -l takes an argument -> shift by 2
--) shift;break;; # end of options
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done
echo "opt_f is $opt_f"
echo "opt_l is $opt_l"
echo "first arg is $1"
echo "2nd arg is $2"
您可以这样运行该脚本：
cmdparser -l hello -f -- -somefile1 somefile2
返回的结果是：
opt_f is 1
opt_l is hello
first arg is -somefile1
2nd arg is somefile2
这个脚本是如何工作的呢？脚本首先在所有输入命令行参数中进行循环，将输入参数与case表达式进行比较，如果匹配则设置一个变量并且移除该参数。根据unix系统的惯例，首先输入的应该是包含减号的参数.
第2部分 实例
现在我们来讨论编写一个脚本的一般步骤。任何优秀的脚本都应该具有帮助和输入参数。并且写一个伪脚本（framework.sh），该脚本包含了大多数脚本都需要的框架结构，是一个非常不错的主意。这时候，在写一个新的脚本时我们只需要执行一下copy命令：
cp framework.sh myscript
然后再插入自己的函数。
让我们再看两个例子：
二进制到十进制的转换
脚本 b2d 将二进制数 (比如 1101) 转换为相应的十进制数。这也是一个用expr命令进行数学运算的例子：
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
b2h -- convert binary to decimal
USAGE: b2h [-h] binarynum
OPTIONS: -h help text
EXAMPLE: b2h 111010
will return 58
HELP
exit 0
}
error()
{
# print an error and exit
echo "$1"
exit 1
}
lastchar()
{
# return the last character of a string in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
# now cut out the last char
rval=`echo -n "$1" | cut -b $numofchar`
}
chop()
{
# remove the last character in string and return it in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
if [ "$numofchar" = "1" ]; then
# only one char in string
rval=""
return
fi
numofcharminus1=`expr $numofchar "-" 1`
# now cut all but the last char:
rval=`echo -n "$1" | cut -b 0-${numofcharminus1}`
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
--) shift;break;; # end of options
-*) error "error: no such option $1. -h for help";;
*) break;;
esac
done
# The main program
sum=0
weight=1
# one arg must be given:
[ -z "$1" ] && help
binnum="$1"
binnumorig="$1"
while [ -n "$binnum" ]; do
lastchar "$binnum"
if [ "$rval" = "1" ]; then
sum=`expr "$weight" "+" "$sum"`
fi
# remove the last position in $binnum
chop "$binnum"
binnum="$rval"
weight=`expr "$weight" "*" 2`
done
echo "binary $binnumorig is decimal $sum"
该脚本使用的算法是利用十进制和二进制数权值 (1,2,4,8,16,..)，比如二进制"10"可以这样转换成十进制：
0 * 1 + 1 * 2 = 2
为了得到单个的二进制数我们是用了lastchar 函数。该函数使用wc –c计算字符个数，然后使用cut命令取出末尾一个字符。Chop函数的功能则是移除最后一个字符。
文件循环程序
或许您是想将所有发出的邮件保存到一个文件中的人们中的一员，但是在过了几个月以后，这个文件可能会变得很大以至于使对该文件的访问速度变慢。下面的脚本rotatefile可以解决这个问题。这个脚本可以重命名邮件保存文件（假设为outmail）为outmail.1，而对于outmail.1就变成了outmail.2 等等等等...
#!/bin/sh
# vim: set sw=4 ts=4 et:
ver="0.1"
help()
{
cat <
rotatefile -- rotate the file name
USAGE: rotatefile [-h] filename
OPTIONS: -h help text
EXAMPLE: rotatefile out
This will e.g rename out.2 to out.3, out.1 to out.2, out to out.1
and create an empty out-file
The max number is 10
version $ver
HELP
exit 0
}
error()
{
echo "$1"
exit 1
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;;
--) break;;
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done
# input check:
if [ -z "$1" ] ; then
error "ERROR: you must specify a file, use -h for help"
fi
filen="$1"
# rename any .1 , .2 etc file:
for n in 9 8 7 6 5 4 3 2 1; do
if [ -f "$filen.$n" ]; then
p=`expr $n + 1`
echo "mv $filen.$n $filen.$p"
mv $filen.$n $filen.$p
fi
done
# rename the original file:
if [ -f "$filen" ]; then
echo "mv $filen $filen.1"
mv $filen $filen.1
fi
echo touch $filen
touch $filen
这个脚本是如何工作的呢？在检测用户提供了一个文件名以后，我们进行一个9到1的循环。文件9被命名为10，文件8重命名为9等等。循环完成之后，我们将原始文件命名为文件1同时建立一个与原始文件同名的空文件。
调试
最简单的调试命令当然是使用echo命令。您可以使用echo在任何怀疑出错的地方打印任何变量值。这也是绝大多数的shell程序员要花费80%的时间来调试程序的原因。Shell程序的好处在于不需要重新编译，插入一个echo命令也不需要多少时间。
shell也有一个真实的调试模式。如果在脚本"strangescript" 中有错误，您可以这样来进行调试：
sh -x strangescript
这将执行该脚本并显示所有变量的值。
shell还有一个不需要执行脚本只是检查语法的模式。可以这样使用：
sh -n your_script
这将返回所有语法错误
如果您写了一些稍微复杂一些的程序，您就会发现在程序中可能在几个地方使用了相同的代码，并且您也会发现，如果我们使用了函数，会方便很多。一个函数是这个样子的：
functionname()
{
# inside the body $1 is the first argument given to the function
# $2 the second ...
body
}
您需要在每个程序的开始对函数进行声明。
下面是一个叫做xtitlebar的脚本，使用这个脚本您可以改变终端窗口的名称。
这里使用了一个叫做help的函数。正如您可以看到的那样，这个定义的函数被使用了两次。
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
xtitlebar -- change the name of an xterm, gnome-terminal or kde konsole
USAGE: xtitlebar [-h] "string_for_titelbar"
OPTIONS: -h help text
EXAMPLE: xtitlebar "cvs"
HELP
exit 0
}
# in case of error or if -h is given we call the function help:
[ -z "$1" ] && help
[ "$1" = "-h" ] && help
# send the escape sequence to change the xterm titelbar:
echo -e "33]0;$107"
#
在脚本中提供帮助是一种很好的编程习惯，这样方便其他用户（和您）使用和理解脚本。
命令行参数
我们已经见过$* 和 $1, $2 ... $9 等特殊变量，这些特殊变量包含了用户从命令行输入的参数。迄今为止，我们仅仅了解了一些简单的命令行语法（比如一些强制性的参数和查看帮助的-h选项）。但是在编写更复杂的程序时，您可能会发现您需要更多的自定义的选项。通常的惯例是在所有可选的参数之前加一个减号，后面再加上参数值 (比如文件名)。
有好多方法可以实现对输入参数的分析，但是下面的使用case表达式的例子无遗是一个不错的方法。
#!/bin/sh
help()
{
cat <
This is a generic command line parser demo.
USAGE EXAMPLE: cmdparser -l hello -f -- -somefile1 somefile2
HELP
exit 0
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
-f) opt_f=1;shift 1;; # variable opt_f is set
-l) opt_l=$2;shift 2;; # -l takes an argument -> shift by 2
--) shift;break;; # end of options
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done
echo "opt_f is $opt_f"
echo "opt_l is $opt_l"
echo "first arg is $1"
echo "2nd arg is $2"
您可以这样运行该脚本：
cmdparser -l hello -f -- -somefile1 somefile2
返回的结果是：
opt_f is 1
opt_l is hello
first arg is -somefile1
2nd arg is somefile2
这个脚本是如何工作的呢？脚本首先在所有输入命令行参数中进行循环，将输入参数与case表达式进行比较，如果匹配则设置一个变量并且移除该参数。根据unix系统的惯例，首先输入的应该是包含减号的参数.
第2部分 实例
现在我们来讨论编写一个脚本的一般步骤。任何优秀的脚本都应该具有帮助和输入参数。并且写一个伪脚本（framework.sh），该脚本包含了大多数脚本都需要的框架结构，是一个非常不错的主意。这时候，在写一个新的脚本时我们只需要执行一下copy命令：
cp framework.sh myscript
然后再插入自己的函数。
让我们再看两个例子：
二进制到十进制的转换
脚本 b2d 将二进制数 (比如 1101) 转换为相应的十进制数。这也是一个用expr命令进行数学运算的例子：
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
b2h -- convert binary to decimal
USAGE: b2h [-h] binarynum
OPTIONS: -h help text
EXAMPLE: b2h 111010
will return 58
HELP
exit 0
}
error()
{
# print an error and exit
echo "$1"
exit 1
}
lastchar()
{
# return the last character of a string in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
# now cut out the last char
rval=`echo -n "$1" | cut -b $numofchar`
}
chop()
{
# remove the last character in string and return it in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
if [ "$numofchar" = "1" ]; then
# only one char in string
rval=""
return
fi
numofcharminus1=`expr $numofchar "-" 1`
# now cut all but the last char:
rval=`echo -n "$1" | cut -b 0-${numofcharminus1}`
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
--) shift;break;; # end of options
-*) error "error: no such option $1. -h for help";;
*) break;;
esac
done
# The main program
sum=0
weight=1
# one arg must be given:
[ -z "$1" ] && help
binnum="$1"
binnumorig="$1"
while [ -n "$binnum" ]; do
lastchar "$binnum"
if [ "$rval" = "1" ]; then
sum=`expr "$weight" "+" "$sum"`
fi
# remove the last position in $binnum
chop "$binnum"
binnum="$rval"
weight=`expr "$weight" "*" 2`
done
echo "binary $binnumorig is decimal $sum"
该脚本使用的算法是利用十进制和二进制数权值 (1,2,4,8,16,..)，比如二进制"10"可以这样转换成十进制：
0 * 1 + 1 * 2 = 2
为了得到单个的二进制数我们是用了lastchar 函数。该函数使用wc –c计算字符个数，然后使用cut命令取出末尾一个字符。Chop函数的功能则是移除最后一个字符。
文件循环程序
或许您是想将所有发出的邮件保存到一个文件中的人们中的一员，但是在过了几个月以后，这个文件可能会变得很大以至于使对该文件的访问速度变慢。下面的脚本rotatefile可以解决这个问题。这个脚本可以重命名邮件保存文件（假设为outmail）为outmail.1，而对于outmail.1就变成了outmail.2 等等等等...
#!/bin/sh
# vim: set sw=4 ts=4 et:
ver="0.1"
help()
{
cat <
rotatefile -- rotate the file name
USAGE: rotatefile [-h] filename
OPTIONS: -h help text
EXAMPLE: rotatefile out
This will e.g rename out.2 to out.3, out.1 to out.2, out to out.1
and create an empty out-file
The max number is 10
version $ver
HELP
exit 0
}
error()
{
echo "$1"
exit 1
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;;
--) break;;
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done
# input check:
if [ -z "$1" ] ; then
error "ERROR: you must specify a file, use -h for help"
fi
filen="$1"
# rename any .1 , .2 etc file:
for n in 9 8 7 6 5 4 3 2 1; do
if [ -f "$filen.$n" ]; then
p=`expr $n + 1`
echo "mv $filen.$n $filen.$p"
mv $filen.$n $filen.$p
fi
done
# rename the original file:
if [ -f "$filen" ]; then
echo "mv $filen $filen.1"
mv $filen $filen.1
fi
echo touch $filen
touch $filen
这个脚本是如何工作的呢？在检测用户提供了一个文件名以后，我们进行一个9到1的循环。文件9被命名为10，文件8重命名为9等等。循环完成之后，我们将原始文件命名为文件1同时建立一个与原始文件同名的空文件。
调试
最简单的调试命令当然是使用echo命令。您可以使用echo在任何怀疑出错的地方打印任何变量值。这也是绝大多数的shell程序员要花费80%的时间来调试程序的原因。Shell程序的好处在于不需要重新编译，插入一个echo命令也不需要多少时间。
shell也有一个真实的调试模式。如果在脚本"strangescript" 中有错误，您可以这样来进行调试：
sh -x strangescript
这将执行该脚本并显示所有变量的值。
shell还有一个不需要执行脚本只是检查语法的模式。可以这样使用：
sh -n your_script
这将返回所有语法错误
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
shell编程简介
作者: 何斌武 ( ,大连理工大学网络中心，April 1999.)
Bourne Shell
作者: 何斌武 ( ,大连理工大学网络中心，April 1999.)
Bourne Shell
介绍：Bourne Shell 基础及其他很多有用的特性，shell编程及组织。
主要内容：
.shell基础 基本介绍，环境，选项，特殊字符
.shell变量 用户定义变量，环境变量，位置变量(shell 参数)
.shell script编程
条件测试，循环及重复控制
.shell定制
.shell基础 基本介绍，环境，选项，特殊字符
.shell变量 用户定义变量，环境变量，位置变量(shell 参数)
.shell script编程
条件测试，循环及重复控制
.shell定制
1.shell基础知识
作者：Stephen Bourne 在Bell实验室开发
建议：man sh 查看相关UNIX上的改进或特性
作者：Stephen Bourne 在Bell实验室开发
建议：man sh 查看相关UNIX上的改进或特性
(1)shell提示符及其环境
/etc/passwd文件
提示符：mce_markernbsp;
/etc/profile $HOME/.profile
(2)shell执行选项
-n 测试shell script语法结构，只读取shell script但不执行
-x 进入跟踪方式，显示所执行的每一条命令，用于调度
-a Tag all variables for export
-c "string" 从strings中读取命令
-e 非交互方式
-f 关闭shell文件名产生功能
-h locate and remember functions as defind
-i 交互方式
-k 从环境变量中读取命令的参数
-r 限制方式
-s 从标准输入读取命令
-t 执行命令后退出(shell exits)
-u 在替换中如使用未定义变量为错误
-v verbose,显示shell输入行
/etc/passwd文件
提示符：mce_markernbsp;
/etc/profile $HOME/.profile
(2)shell执行选项
-n 测试shell script语法结构，只读取shell script但不执行
-x 进入跟踪方式，显示所执行的每一条命令，用于调度
-a Tag all variables for export
-c "string" 从strings中读取命令
-e 非交互方式
-f 关闭shell文件名产生功能
-h locate and remember functions as defind
-i 交互方式
-k 从环境变量中读取命令的参数
-r 限制方式
-s 从标准输入读取命令
-t 执行命令后退出(shell exits)
-u 在替换中如使用未定义变量为错误
-v verbose,显示shell输入行
这些选项可以联合使用，但有些显然相互冲突，如-e和-i.
(3)受限制shell(Restircted Shell)
sh -r 或 /bin/rsh
sh -r 或 /bin/rsh
不能执行如下操作：cd, 更改PATH,指定全路径名，输出重定向，因此可以提供一个较
好的控制和安全机制。通常rsh用于应用型用户及拨号用户，这些用户通常是看不到提
示符的。通常受限制用户的主目录是不可写的。
好的控制和安全机制。通常rsh用于应用型用户及拨号用户，这些用户通常是看不到提
示符的。通常受限制用户的主目录是不可写的。
不足：如果用户可以调用sh,则rsh的限制将不在起作用，事实上如果用户在vi及more
程序中调用shell,而这时rsh的限制将不再起作用。
程序中调用shell,而这时rsh的限制将不再起作用。
(4)用set改变 shell选项
用户可以在$提示符下用set命令来设置或取消shell的选项。使用-设置选项，+取消相应
选项，大多数UNIX系统允许a,e,f,h,k,n,u,v和x的开关设置/取消。
用户可以在$提示符下用set命令来设置或取消shell的选项。使用-设置选项，+取消相应
选项，大多数UNIX系统允许a,e,f,h,k,n,u,v和x的开关设置/取消。
set -xv
启动跟踪方式;显示所有的命令及替换，同样显示输入。
set -tu
关闭在替换时对未定义变量的检查。
启动跟踪方式;显示所有的命令及替换，同样显示输入。
set -tu
关闭在替换时对未定义变量的检查。
使用echo $-显示所有已设置的shell选项。
(5)用户启动文件 .profile
PATH=$PATH:/usr/loacl/bin; export PATH
(6)shell环境变量
CDPATH 用于cd命令的查找路径
HOME /etc/passwd文件中列出的用户主目录
IFS Internal Field Separator,默认为空格，tab及换行符
MAIL /var/mail/$USERNAME mail等程序使用
PATH
PS1，PS2 默认提示符($)及换行提示符(>)
TERM 终端类型，常用的有vt100,ansi,vt200,xterm等
CDPATH 用于cd命令的查找路径
HOME /etc/passwd文件中列出的用户主目录
IFS Internal Field Separator,默认为空格，tab及换行符
MAIL /var/mail/$USERNAME mail等程序使用
PATH
PS1，PS2 默认提示符($)及换行提示符(>)
TERM 终端类型，常用的有vt100,ansi,vt200,xterm等
示例：$PS1="test:";export PS1
test: PS1="\$";export PS1
$echo $MAIL
/var/mail/username
(7)保留字符及其含义
$ shell变量名的开始，如$var
| 管道，将标准输出转到下一个命令的标准输入
# 注释开始
& 在后台执行一个进程
？ 匹配一个字符
* 匹配0到多个字符(与DOS不同，可在文件名中间使用，并且含.)
$- 使用set及执行时传递给shell的标志位
$! 最后一个子进程的进程号
$# 传递给shell script的参数个数
$* 传递给shell script的参数
$@ 所有参数，个别的用双引号括起来
$? 上一个命令的返回代码
$0 当前shell的名字
$n (n:1-) 位置参数
$ 进程标识号(Process Identifier Number, PID)
>file 输出重定向
`command` 命令替换，如 filename=`basename /usr/local/bin/tcsh`
>>fiile 输出重定向，append
test: PS1="\$";export PS1
$echo $MAIL
/var/mail/username
(7)保留字符及其含义
$ shell变量名的开始，如$var
| 管道，将标准输出转到下一个命令的标准输入
# 注释开始
& 在后台执行一个进程
？ 匹配一个字符
* 匹配0到多个字符(与DOS不同，可在文件名中间使用，并且含.)
$- 使用set及执行时传递给shell的标志位
$! 最后一个子进程的进程号
$# 传递给shell script的参数个数
$* 传递给shell script的参数
$@ 所有参数，个别的用双引号括起来
$? 上一个命令的返回代码
$0 当前shell的名字
$n (n:1-) 位置参数
$ 进程标识号(Process Identifier Number, PID)
>file 输出重定向
`command` 命令替换，如 filename=`basename /usr/local/bin/tcsh`
>>fiile 输出重定向，append
转义符及单引号：
$echo "$HOME $PATH"
/home/hbwork /opt/kde/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:
$echo '$HOME $PATH'
$HOME $PATH
$echo \$HOME $PATH
$HOME /opt/kde/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/hbwork/bin
$echo "$HOME $PATH"
/home/hbwork /opt/kde/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:
$echo '$HOME $PATH'
$HOME $PATH
$echo \$HOME $PATH
$HOME /opt/kde/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/hbwork/bin
其他：
$dir=ls
$dir
$alias dir ls
$dir
$dir=ls
$dir
$alias dir ls
$dir
ls > filelist
ls >> filelist
wc -l < filelist
wc -l filelist
sleep 5; echo 5 seconds reaches; ls -l
ps ax |egrep inetd
find / -name core -exec rm {} \; &
filename=`date "+%Y%m%d"`.log
ls >> filelist
wc -l < filelist
wc -l filelist
sleep 5; echo 5 seconds reaches; ls -l
ps ax |egrep inetd
find / -name core -exec rm {} \; &
filename=`date "+%Y%m%d"`.log
2. shell变量
变量：代表某些值的符号，如$HOME,cd命令查找$HOME,在计算机语言中可以使用变量可以
进行多种运算和控制。
变量：代表某些值的符号，如$HOME,cd命令查找$HOME,在计算机语言中可以使用变量可以
进行多种运算和控制。
Bourne Shell有如下四种变量：
.用户自定义变量
.位置变量即 shell script之参数
.预定义变量（特殊变量）
.环境变量(参考shell定制部分)
(1)用户自定义变量（数据的存储）
$ COUNT=1
$ NAME="He Binwu"
.用户自定义变量
.位置变量即 shell script之参数
.预定义变量（特殊变量）
.环境变量(参考shell定制部分)
(1)用户自定义变量（数据的存储）
$ COUNT=1
$ NAME="He Binwu"
技巧：因为大部分UNIX命令使用小写字符，因此在shell编程中通常使用全大写变量，
当然这并不是强制性的，但使用大写字符可以在编程中方便地识别变量。
当然这并不是强制性的，但使用大写字符可以在编程中方便地识别变量。
变量的调用：在变量前加mce_markernbsp;
$ echo $HOME
/home/hbwork
$ WEEK=Satur
$ echo Today is $WEEKday
Today is
$echo Today is ${WEEK}day
Today is Saturday
$ echo $HOME
/home/hbwork
$ WEEK=Satur
$ echo Today is $WEEKday
Today is
$echo Today is ${WEEK}day
Today is Saturday
Shell变量赋值从右从左进行(Linux Shell/bash从左向右赋值!)
$ X=$Y Y=y
$ echo $X
y
$ Z=z Y=$Z
$ echo $Y
$ X=$Y Y=y
$ echo $X
y
$ Z=z Y=$Z
$ echo $Y
$
使用unset命令删除变量的赋值
$ Z=hello
$ echo $Z
hello
$ unset Z
$ echo $Z
$ Z=hello
$ echo $Z
hello
$ unset Z
$ echo $Z
$
有条件的命令替换
在Bourne Shell中可以使变量替换在特定条件下执行，即有条件的环境变量替换。
这种变量替换总是用大括号括起来的。
在Bourne Shell中可以使变量替换在特定条件下执行，即有条件的环境变量替换。
这种变量替换总是用大括号括起来的。
.设置变量的默认值
在变量未赋值之前其值为空。Bourne Shell允许对变量设置默认值，其格式如下：
${variable:-defaultvalue}
例：
$ echo Hello $UNAME
Hello
$ echo Hello ${UNAME:-there}
Hello there
$ echo $UNAME #变量值并未发生变化
在变量未赋值之前其值为空。Bourne Shell允许对变量设置默认值，其格式如下：
${variable:-defaultvalue}
例：
$ echo Hello $UNAME
Hello
$ echo Hello ${UNAME:-there}
Hello there
$ echo $UNAME #变量值并未发生变化
$ UNAME=hbwork
$ echo Hello ${UNAME:-there}
Hello hbwork
mce_markernbsp;
.另一种情况：改变变量的值，格式如下：
${variable:=value}
$ echo Hello ${UNAME:-there}
Hello hbwork
mce_markernbsp;
.另一种情况：改变变量的值，格式如下：
${variable:=value}
例：
$ echo Hello $UNAME
Hello
$ echo Hello ${UNAME:=there}
Hello there
$ echo $UNAME #变量值并未发生变化
there
mce_markernbsp;
.变量替换中使用命令替换
$USERDIR=${$MYDIR:-`pwd`}
$ echo Hello $UNAME
Hello
$ echo Hello ${UNAME:=there}
Hello there
$ echo $UNAME #变量值并未发生变化
there
mce_markernbsp;
.变量替换中使用命令替换
$USERDIR=${$MYDIR:-`pwd`}
.在变量已赋值时进行替换 ${variable:+value}
.带有错误检查的有条件变量替换
${variable:?value}
例：
$ UNAME=
$ echo ${UNAME:?"UNAME has not been set"}
UNAME: UNAME has not been set
$ echo ${UNAME:?}
UNAME: parameter null or not set
.带有错误检查的有条件变量替换
${variable:?value}
例：
$ UNAME=
$ echo ${UNAME:?"UNAME has not been set"}
UNAME: UNAME has not been set
$ echo ${UNAME:?}
UNAME: parameter null or not set
(2)位置变量(Shell参数)
在shell script中位置参数可用$1..$9表示，$0表示内容通常为当前执行程序的文件名。
.防止变量值被替换 readonly variable
.使用export命令输出变量，使得变量对子shell可用，当shell执行一下程序时，shell
将为其设置一个新的环境让其执行，这称之了subshell. 在Bourne Shell中变量通常
被认为是本地变量，也就是说在对其赋值之外的shell环境之外是不认识此变量的。使
用export对subshell可用。
在shell script中位置参数可用$1..$9表示，$0表示内容通常为当前执行程序的文件名。
.防止变量值被替换 readonly variable
.使用export命令输出变量，使得变量对子shell可用，当shell执行一下程序时，shell
将为其设置一个新的环境让其执行，这称之了subshell. 在Bourne Shell中变量通常
被认为是本地变量，也就是说在对其赋值之外的shell环境之外是不认识此变量的。使
用export对subshell可用。
例：对变量PS1的export操作，shell的提示符将发生变化。
$ PS1=`hostname`mce_markernbsp;
peony$sh
$ echo $PS1
$ <-输出结果
$ exit
peony$export PS1
peony$sh
peony$ echo $PS1
peony$ <-输出结果
peony$
$ PS1=`hostname`mce_markernbsp;
peony$sh
$ echo $PS1
$ <-输出结果
$ exit
peony$export PS1
peony$sh
peony$ echo $PS1
peony$ <-输出结果
peony$
3.Shell Script编程
目的：使用UNIX所提供的最常用工具来完成所需复杂任务的强大功能。
(1)最简单的Shell 编程
$ls -R / |grep myname |more
$ls -R / |grep myname |more
每天数据的备份：
$ cd /usr/yourname; ls * |cpio -o > /dev/rmt/0h
$ cd /usr/yourname; ls * |cpio -o > /dev/rmt/0h
书写程序的目的是一次编程，多次使用（执行）！
$ cat > backup.sh
cd /home/hbwork
ls * | cpio -o > /dev/rmt/0h
^D
cd /home/hbwork
ls * | cpio -o > /dev/rmt/0h
^D
执行：
$ sh backup.sh
$ sh backup.sh
或：
$ chmod +x backup.sh
$ ./backup.sh
$ chmod +x backup.sh
$ ./backup.sh
技巧：在shell script中加入必要的注释，以便以后阅读及维护。
(2)shell是一个（编程）语言
同传统的编程语言一样，shell提供了很多特性，这些特性可以使你的shell script
编程更为有用，如：数据变量、参数传递、判断、流程控制、数据输入和输出，子
程序及以中断处理等。
同传统的编程语言一样，shell提供了很多特性，这些特性可以使你的shell script
编程更为有用，如：数据变量、参数传递、判断、流程控制、数据输入和输出，子
程序及以中断处理等。
. 在shell编程中使用数据变量可以将程序变量更为通用，如在上面backup.sh中：
cd $WORKDIR
ls * | cpio -o > /dev/rmt/0h
cd $WORKDIR
ls * | cpio -o > /dev/rmt/0h
. Shell编程中的注释以#开头
. 对shell变量进行数字运算，使用expr命令
expr integer operator integer
其中operator为+ - * / %, 但对*的使用要用转义符\,如：
$expr 4 \* 5
20
$int=`expr 5 + 7`
$echo $int
12
. 对shell变量进行数字运算，使用expr命令
expr integer operator integer
其中operator为+ - * / %, 但对*的使用要用转义符\,如：
$expr 4 \* 5
20
$int=`expr 5 + 7`
$echo $int
12
(3)Shell编程的参数传递, 可通过命令行参数以及交互式输入变量(read)
restoreall.sh 对backup.sh程序的备份磁带进行恢复
$cat > restoreall.sh
cd $WORKDIR
cpio -i < /dev/rmt/0h
^D
restore1.sh:只能恢复一个文件
#restore1 --program to restore a single file
cd $WORKDIR
cpio -i $i < /dev/rmt/0h
$cat > restoreall.sh
cd $WORKDIR
cpio -i < /dev/rmt/0h
^D
restore1.sh:只能恢复一个文件
#restore1 --program to restore a single file
cd $WORKDIR
cpio -i $i < /dev/rmt/0h
$restore1 file1
恢复多个文件restoreany :
#restoreany --program to restore a single file
cd $WORKDIR
cpio -i $* < /dev/rmt/0h
#restoreany --program to restore a single file
cd $WORKDIR
cpio -i $* < /dev/rmt/0h
$ restoreany file1 file2 file3
(4)条件判断
. if-then语句,格式如下:
if command_1
then
command_2
command_3
fi
command_4
在if-then语句中使用了命令返回码$?,即当command_1执行成功时才执行command_2和
command_3,而command_4总是执行.
command_3,而command_4总是执行.
示例程序unload: 在备份成功时删除原始文件,带有错误检查
cd $1
#备份时未考虑不成功的情况!
ls -a | cpio -o > /dev/rmt/0h
rm -rf *
#备份时未考虑不成功的情况!
ls -a | cpio -o > /dev/rmt/0h
rm -rf *
改进如下:
#当使用了管道命令时,管理命令的返回代码为最后一个命令的返回代码
if ls -a | cpio -o > /dev/rmt/0h
then
rm -rf *
fi
if ls -a | cpio -o > /dev/rmt/0h
then
rm -rf *
fi
. if-then-else语句
if command_1
then
command_2
else
command_3
fi
if command_1
then
command_2
else
command_3
fi
技巧: 由于shell对命令中的多余的空格不作任何处理,一个好的程序员会用这一特性
对自己的程序采用统一的缩进格式,以增强自己程序的可读性.
对自己的程序采用统一的缩进格式,以增强自己程序的可读性.
. 使用test命令进行进行条件测试
格式: test conditions
格式: test conditions
test在以下四种情况下使用: a. 字符比较 b.两个整数值的比较
c. 文件操作,如文件是否存在及文件的状态等
d. 逻辑操作,可以进行and/or,与其他条件联合使用
c. 文件操作,如文件是否存在及文件的状态等
d. 逻辑操作,可以进行and/or,与其他条件联合使用
a. 测试字符数据: shell变量通常民政部下均作为字符变量
str1 = str2 二者相长,相同
str1 != str2 不同
-n string string不为空(长度不为零)
-z string string为空
string string不为空
str1 = str2 二者相长,相同
str1 != str2 不同
-n string string不为空(长度不为零)
-z string string为空
string string不为空
例:
$ str1=abcd #在含有空格时必须用引号括起来
$ test $str1=abcd
$ echo $?
0
$ str1="abcd "
$ test $str1=abcd
$ echo $?
1
Note: 在test处理含有空格的变量时最好用引号将变量括起来,否则会出现错误的结果,
因为shell在处理命令行时将会去掉多余的空格,而用引号括起来则可以防止
shell去掉这些空格.
例:
$ str1=" "
$ test $str1
$ echo $?
1
$ test "$str1"
$ echo $?
0
$ test -n $str1
test: argument expected
$ test -n "$str1"
$ echo $?
0
$
$ str1=abcd #在含有空格时必须用引号括起来
$ test $str1=abcd
$ echo $?
0
$ str1="abcd "
$ test $str1=abcd
$ echo $?
1
Note: 在test处理含有空格的变量时最好用引号将变量括起来,否则会出现错误的结果,
因为shell在处理命令行时将会去掉多余的空格,而用引号括起来则可以防止
shell去掉这些空格.
例:
$ str1=" "
$ test $str1
$ echo $?
1
$ test "$str1"
$ echo $?
0
$ test -n $str1
test: argument expected
$ test -n "$str1"
$ echo $?
0
$
b. 整数测试: test与expr相同,可以将字符型变量转换为整数进行操作,expr进行
整数的算术运算,而test则进行逻辑运算.
整数的算术运算,而test则进行逻辑运算.
表达式 说明
---------------------------------------
int1 -eq int2 相等?
int1 -ne int2 不等?
int1 -gt int2 int1 > int2 ?
int1 -ge int2 int1 >= int2 ?
int1 -lt int2 int1 < int2 ?
int1 -le int2 int1 <= int2 ?
---------------------------------------
int1 -eq int2 相等?
int1 -ne int2 不等?
int1 -gt int2 int1 > int2 ?
int1 -ge int2 int1 >= int2 ?
int1 -lt int2 int1 < int2 ?
int1 -le int2 int1 <= int2 ?
例:
$ int1=1234
$ int2=01234
$ test $int1 -eq $int2
$ echo $?
0
$ int1=1234
$ int2=01234
$ test $int1 -eq $int2
$ echo $?
0
c. 文件测试:检查文件状态如存在及读写权限等
-r filename 用户对文件filename有读权限?
-w filename 用户对文件filename有写权限?
-x filename 用户对文件filename有可执行权限?
-f filename 文件filename为普通文件?
-d filename 文件filename为目录?
-c filename 文件filename为字符设备文件?
-b filename 文件filename为块设备文件?
-s filename 文件filename大小不为零?
-t fnumb 与文件描述符fnumb(默认值为1)相关的设备是一个终端设备?
-w filename 用户对文件filename有写权限?
-x filename 用户对文件filename有可执行权限?
-f filename 文件filename为普通文件?
-d filename 文件filename为目录?
-c filename 文件filename为字符设备文件?
-b filename 文件filename为块设备文件?
-s filename 文件filename大小不为零?
-t fnumb 与文件描述符fnumb(默认值为1)相关的设备是一个终端设备?
d. 测试条件之否定,使用!
例:
$ cat /dev/null > empty
$ test -r empty
$ echo $?
0
$ test -s empty
1
$ test ! -s empty
$ echo $?
0
e. 测试条件之逻辑运算
-a And
-o Or
例:
$ cat /dev/null > empty
$ test -r empty
$ echo $?
0
$ test -s empty
1
$ test ! -s empty
$ echo $?
0
e. 测试条件之逻辑运算
-a And
-o Or
例: $ test -r empty -a -s empty
$ echo $?
1
f. 进行test测试的标准方法
因为test命令在 shell编程中占有很重要的地位,为了使shell能同其他编程语言一样
便于阅读和组织, Bourne Shell在使用test测试时使用了另一种方法:用方括号将整个
test测试括起来:
$ echo $?
1
f. 进行test测试的标准方法
因为test命令在 shell编程中占有很重要的地位,为了使shell能同其他编程语言一样
便于阅读和组织, Bourne Shell在使用test测试时使用了另一种方法:用方括号将整个
test测试括起来:
$ int1=4
$ [ $int1 -gt 2 ]
$ echo $?
0
$ [ $int1 -gt 2 ]
$ echo $?
0
例: 重写unload程序,使用test测试
#!/bin/sh
#unload - program to backup and remove files
#syntax: unload directory
#!/bin/sh
#unload - program to backup and remove files
#syntax: unload directory
#check arguments
if [ $# -ne 1 ]
then
echo "usage: $0 directory"
exit 1
fi
if [ $# -ne 1 ]
then
echo "usage: $0 directory"
exit 1
fi
#check for valid directory name
if [ ! -d "$1" ]
then
echo "$1 is not a directory"
exit 2
fi
if [ ! -d "$1" ]
then
echo "$1 is not a directory"
exit 2
fi
cd $1
ls -a | cpio -o > /dev/rmt/0h
if [ $? -eq 0 ]
then
rm -rf *
else
echo "A problem has occured in creating backup"
echo "The directory will not be ereased"
echo "Please check the backup device"
exit 3
fi
# end of unload
then
rm -rf *
else
echo "A problem has occured in creating backup"
echo "The directory will not be ereased"
echo "Please check the backup device"
exit 3
fi
# end of unload
在如上示例中出现了exit, exit有两个作用:一是停止程序中其他命令的执行,二是
设置程序的退出状态
设置程序的退出状态
g. if嵌套及elif结构
if command
then
command
else
if command
then
command
else
if command
then
command
fi
fi
fi
if command
then
command
else
if command
then
command
else
if command
then
command
fi
fi
fi
改进:使用elif结构
if command
then
command
elif command
then
command
elif command
then
command
fi
if command
then
command
elif command
then
command
elif command
then
command
fi
elif结构同if结构类似,但结构更清淅,其执行结果完全相同.
h.交互式从键盘读入数据
使用read语句，其格式如下：
使用read语句，其格式如下：
read var1 var2 ... varn
read将不作变量替换，但会删除多余的空格，直到遇到第一个换行符（回车），
并将输入值依次赋值给相应的变量。
并将输入值依次赋值给相应的变量。
例：
$ read var1 var2 var3
Hello my friends
$ echo $var1 $var2 $var3
Hello my friends
$ echo $var1
Hello
$ read var1 var2 var3
Hello my dear friends
$ echo $var3
dear friends <-输入多余变量时，输入值余下的内容赋给最后一个变量
$ read var1 var2 var3
Hello friends
$ echo $var3
<- var3为空
$
$ read var1 var2 var3
Hello my friends
$ echo $var1 $var2 $var3
Hello my friends
$ echo $var1
Hello
$ read var1 var2 var3
Hello my dear friends
$ echo $var3
dear friends <-输入多余变量时，输入值余下的内容赋给最后一个变量
$ read var1 var2 var3
Hello friends
$ echo $var3
<- var3为空
$
在shell script中可使用read语句进行交互操作：
...
#echo -n message 输出结果后不换行
echo -n "Do you want to continue: Y or N"
read ANSWER
#echo -n message 输出结果后不换行
echo -n "Do you want to continue: Y or N"
read ANSWER
if [ $ANSWER=N -o $ANSWER=n ]
then
exit
fi
then
exit
fi
i. case结构：结构较elif-then结构更清楚
比较if-then语句：
if [ variable1 = value1 ]
then
command
command
elif [ variable1 = value2 ]
then
command
command
elif [ variable1 = value3 ]
then
command
command
fi
then
command
command
elif [ variable1 = value2 ]
then
command
command
elif [ variable1 = value3 ]
then
command
command
fi
相应的case结构：
case value in
pattern1)
command
command;;
pattern2)
command
command;;
...
patternn)
command;
esac
pattern1)
command
command;;
pattern2)
command
command;;
...
patternn)
command;
esac
* case语句只执行第一个匹配模式
例：使用case语句建立一个菜单选择shell script
#Display a menu
echo _
echo "1 Restore"
echo "2 Backup"
echo "3 Unload"
echo
echo _
echo "1 Restore"
echo "2 Backup"
echo "3 Unload"
echo
#Read and excute the user's selection
echo -n "Enter Choice:"
read CHOICE
echo -n "Enter Choice:"
read CHOICE
case "$CHOICE" in
1) echo "Restore";;
2) echo "Backup";;
3) echo "Unload";;
*) echo "Sorry $CHOICE is not a valid choice
exit 1
esac
1) echo "Restore";;
2) echo "Backup";;
3) echo "Unload";;
*) echo "Sorry $CHOICE is not a valid choice
exit 1
esac
在上例中，*指默认匹配动作。此外，case模式中也可以使用逻辑操作，如下所示：
pattern1 | pattern2 ) command
command ;;
command ;;
这样可以将上面示例程序中允许用户输入数字或每一个大写字母。
case "$CHOICE" in
1|R) echo "Restore";;
2|B) echo "Backup";;
3|U) echo "Unload";;
*) echo "Sorry $CHOICE is not a valid choice
exit 1
esac
1|R) echo "Restore";;
2|B) echo "Backup";;
3|U) echo "Unload";;
*) echo "Sorry $CHOICE is not a valid choice
exit 1
esac
(5)循环控制
<1> while循环:
格式：
while command
do
command
command
command
...
done
<1> while循环:
格式：
while command
do
command
command
command
...
done
例： 计算1到5的平方
#!/bin/sh
#
#Filename: square.sh
int=1
#!/bin/sh
#
#Filename: square.sh
int=1
while [ $int -le 5 ]
do
sq=`expr $int \* $int`
echo $sq
int=`expr $int + 1`
done
echo "Job completed"
do
sq=`expr $int \* $int`
echo $sq
int=`expr $int + 1`
done
echo "Job completed"
$ sh square.sh
1
4
9
16
25
Job completed
1
4
9
16
25
Job completed
<2> until循环结构：
格式：
until command
do
command
command
....
command
done
格式：
until command
do
command
command
....
command
done
示例：使用until结构计算1-5的平方
#!/bin/sh
#!/bin/sh
int=1
until [ $int -gt 5 ]
do
sq=`expr $int \* $int`
echo $sq
int=`expr $int + 1`
done
echo "Job completed"
do
sq=`expr $int \* $int`
echo $sq
int=`expr $int + 1`
done
echo "Job completed"
<3> 使用shift对不定长的参数进行处理
在以上的示例中我们总是假设命令行参数唯一或其个数固定，或者使用$*将整个命令
行参数传递给shell script进行处理。对于参数个数不固定并且希望对每个命令参数
进行单独处理时则需要shift命令。使用shift可以将命令行位置参数依次移动位置，
即$2->$1, $3->$2. 在移位之前的第一个位置参数$1在移位后将不在存在。
在以上的示例中我们总是假设命令行参数唯一或其个数固定，或者使用$*将整个命令
行参数传递给shell script进行处理。对于参数个数不固定并且希望对每个命令参数
进行单独处理时则需要shift命令。使用shift可以将命令行位置参数依次移动位置，
即$2->$1, $3->$2. 在移位之前的第一个位置参数$1在移位后将不在存在。
示例如下：
#!/bin/sh
#
#Filename: shifter
#
#Filename: shifter
until [ $# -eq 0 ]
do
echo "Argument is $1 and `expr $# - 1` argument(s) remain"
shift
done
do
echo "Argument is $1 and `expr $# - 1` argument(s) remain"
shift
done
$ shifter 1 2 3 4
Argument is 1 and 3 argument(s) remain
Argument is 2 and 2 argument(s) remain
Argument is 3 and 1 argument(s) remain
Argument is 4 and 0 argument(s) remain
$
使用shift时，每进行一次移位，$#减1，使用这一特性可以用until循环对每个参
数进行处理，如下示例中是一个求整数和的shell script:
数进行处理，如下示例中是一个求整数和的shell script:
#!/bin/sh
# sumints - a program to sum a series of integers
#
# sumints - a program to sum a series of integers
#
if [ $# -eq 0 ]
then
echo "Usage: sumints integer list"
exit 1
fi
then
echo "Usage: sumints integer list"
exit 1
fi
sum=0
until [ $# -eq 0 ]
do
sum=`expr $sum + $1`
shift
done
echo $sum
do
sum=`expr $sum + $1`
shift
done
echo $sum
$ sh sumints 324 34 34 12 34
438
$
使用shift的另一个原因是Bourne Shell的位置参数变量为$1~$9, 因此通过位置变量
只能访问前9个参数。但这并不等于在命令行上最多只能输入9个参数。此时如果想访问
前9个参数之后的参数，就必须使用shift.
只能访问前9个参数。但这并不等于在命令行上最多只能输入9个参数。此时如果想访问
前9个参数之后的参数，就必须使用shift.
另外shift后可加整数进行一次多个移位，如：
shift 3
<4>. for循环
格式：
for var in arg1 arg2 ... argn
do
command
....
command
done
示例：
$ for letter in a b c d e; do echo $letter;done
a
b
c
d
e
$ for letter in a b c d e; do echo $letter;done
a
b
c
d
e
对当前目录下的所有文件操作：
$ for i in *
do
if [ -f $i ]
then
echo "$i is a file"
elif [ -d $i ]
echo "$i is a directory"
fi
done
$ for i in *
do
if [ -f $i ]
then
echo "$i is a file"
elif [ -d $i ]
echo "$i is a directory"
fi
done
求命令行上所有整数之和：
#!/bin/sh
#!/bin/sh
sum=0
for INT in $*
do
sum=`expr $sum + $INT`
done
do
sum=`expr $sum + $INT`
done
echo $sum
<6> 从循环中退出： break和continue命令
break 立即退出循环
continue 忽略本循环中的其他命令，继续下一下循环
在shell编程中有时我们要用到进行无限循环的技巧，也就是说这种循环一直执行碰
到break或continue命令。这种无限循环通常是使用true或false命令开始的。UNIX
系统中的true总是返加0值，而false则返回非零值。如下所示：
到break或continue命令。这种无限循环通常是使用true或false命令开始的。UNIX
系统中的true总是返加0值，而false则返回非零值。如下所示：
#一直执行到程序执行了break或用户强行中断时才结束循环
while true
do
command
....
command
done
while true
do
command
....
command
done
上面所示的循环也可以使用until false, 如下：
until false
do
command
....
command
done
do
command
....
command
done
在如下shell script中同时使用了continue,break以及case语句中的正规表达式用法：
#!/bin/sh
# Interactive program to restore, backup, or unload
# a directory
# Interactive program to restore, backup, or unload
# a directory
echo "Welcome to the menu driven Archive program"
while true
do
# Display a Menu
echo
echo "Make a Choice from the Menu below"
echo _
echo "1 Restore Archive"
echo "2 Backup directory"
echo "3 Unload directory"
echo "4 Quit"
echo
do
# Display a Menu
echo
echo "Make a Choice from the Menu below"
echo _
echo "1 Restore Archive"
echo "2 Backup directory"
echo "3 Unload directory"
echo "4 Quit"
echo
# Read the user's selection
echo -n "Enter Choice: "
echo -n "Enter Choice: "
read CHOICE
case $CHOICE in
[1-3] ) echo
# Read and validate the name of the directory
[1-3] ) echo
# Read and validate the name of the directory
echo -n "What directory do you want? "
read WORKDIR
read WORKDIR
if [ ! -d "$WORKDIR" ]
then
echo "Sorry, $WORKDIR is not a directory"
continue
fi
then
echo "Sorry, $WORKDIR is not a directory"
continue
fi
# Make the directory the current working directory
cd $WORKDIR;;
cd $WORKDIR;;
4) :;; # :为空语句，不执行任何动作
*) echo "Sorry, $CHOICE is not a valid choice"
continue
esac
*) echo "Sorry, $CHOICE is not a valid choice"
continue
esac
case "$CHOICE" in
1) echo "Restoring..."
cpio -i
2) echo "Archiving..."
ls | cpio -o >/dev/rmt/0h;;
1) echo "Restoring..."
cpio -i
2) echo "Archiving..."
ls | cpio -o >/dev/rmt/0h;;
3) echo "Unloading..."
ls | cpio -o >/dev/rmt/0h;;
ls | cpio -o >/dev/rmt/0h;;
4) echo "Quitting"
break;;
esac
break;;
esac
#Check for cpio errors
if [ $? -ne 0 ]
then
echo "A problem has occurred during the process"
if [ $CHOICE = 3 ]
then
echo "The directory will not be erased"
fi
then
echo "A problem has occurred during the process"
if [ $CHOICE = 3 ]
then
echo "The directory will not be erased"
fi
echo "Please check the device and try again"
continue
else
if [ $CHOICE = 3 ]
then
rm *
fi
fi
done
continue
else
if [ $CHOICE = 3 ]
then
rm *
fi
fi
done
(6)结构化编程：定义函数
同其他高级语言一样，shell也提供了函数功能。函数通常也称之为子过程(subroutine),
其定义格式如下：
funcname()
{
command
...
command; #分号
}
{
command
...
command; #分号
}
定义函数之后，可以在shell中对此函数进行调用，使用函数定义可以将一个复杂的程序分
为多个可管理的程序段，如下所示：
为多个可管理的程序段，如下所示：
# start program
setup ()
{ command list ; }
{ command list ; }
do_data ()
{ command list ; }
{ command list ; }
cleanup ()
{ command list ; }
{ command list ; }
errors ()
{ command list ; }
{ command list ; }
setup
do_data
cleanup
# end program
do_data
cleanup
# end program
技巧：
. 在对函数命名时最好能使用有含义的名字，即函数名能够比较准确的描述函数所完成
的任务。
. 为了程序的维护方便，请尽可能使用注释
. 在对函数命名时最好能使用有含义的名字，即函数名能够比较准确的描述函数所完成
的任务。
. 为了程序的维护方便，请尽可能使用注释
使用函数的另一个好处就是可以在一个程序中的不同地方执行相同的命令序列(函数),
如下所示：
iscontinue()
{
while true
do
echo -n "Continue?(Y/N)"
read ANSWER
{
while true
do
echo -n "Continue?(Y/N)"
read ANSWER
case $ANSWER in
[Yy]) return 0;;
[Nn]) return 1;;
*) echo "Answer Y or N";;
esac
done
}
[Yy]) return 0;;
[Nn]) return 1;;
*) echo "Answer Y or N";;
esac
done
}
这样可以在shell编程中调用iscontinue确定是否继续执行：
if iscontinue
then
continue
else
break
fi
then
continue
else
break
fi
** shell函数与shell程序非常相似，但二者有一个非常重要的差别：shell程序是由子shell
执行的，而shell函数则是作为当前shell的一部分被执行的，因此在当前shell中可以改
变函数的定义。此外在任意shell(包括交互式的shell)中均可定义函数，如：
$ dir
dir: not found
$ dir () { ls -l ;}
$ dir
total 5875
-rw-r--r-- 1 hbwork 100 Nov 10 23:16 doc
-rw-r--r-- 1 hbwork 2973806 Nov 10 23:47 ns40docs.zip
-rw-r--r-- 1 hbwork 1715011 Nov 10 23:30 ns840usr.pdf
-rw-r--r-- 1 hbwork 1273409 Sep 23 1998 radsol21b6.tar.Z
-rw-r--r-- 1 hbwork 7526 Nov 10 23:47 wget-log
-rw-r--r-- 1 hbwork 1748 Nov 13 21:51 wget-log.1
$ unset dir
$ dir () {
> echo "Permission Link Owner Group File_SZ LastAccess FileName"
> echo "-----------------------------------------------------------"
> ls -l $*;
> }
dir: not found
$ dir () { ls -l ;}
$ dir
total 5875
-rw-r--r-- 1 hbwork 100 Nov 10 23:16 doc
-rw-r--r-- 1 hbwork 2973806 Nov 10 23:47 ns40docs.zip
-rw-r--r-- 1 hbwork 1715011 Nov 10 23:30 ns840usr.pdf
-rw-r--r-- 1 hbwork 1273409 Sep 23 1998 radsol21b6.tar.Z
-rw-r--r-- 1 hbwork 7526 Nov 10 23:47 wget-log
-rw-r--r-- 1 hbwork 1748 Nov 13 21:51 wget-log.1
$ unset dir
$ dir () {
> echo "Permission Link Owner Group File_SZ LastAccess FileName"
> echo "-----------------------------------------------------------"
> ls -l $*;
> }
$ dir
Permission Link Owner Group File_SZ LastAccess FileName
-----------------------------------------------------------
total 5875
-rw-r--r-- 1 hbwork 100 Nov 10 23:16 doc
-rw-r--r-- 1 hbwork 2973806 Nov 10 23:47 ns40docs.zip
-rw-r--r-- 1 hbwork 1715011 Nov 10 23:30 ns840usr.pdf
-rw-r--r-- 1 hbwork 1273409 Sep 23 1998 radsol21b6.tar.Z
-rw-r--r-- 1 hbwork 7526 Nov 10 23:47 wget-log
-rw-r--r-- 1 hbwork 1748 Nov 13 21:51 wget-log.1
Permission Link Owner Group File_SZ LastAccess FileName
-----------------------------------------------------------
total 5875
-rw-r--r-- 1 hbwork 100 Nov 10 23:16 doc
-rw-r--r-- 1 hbwork 2973806 Nov 10 23:47 ns40docs.zip
-rw-r--r-- 1 hbwork 1715011 Nov 10 23:30 ns840usr.pdf
-rw-r--r-- 1 hbwork 1273409 Sep 23 1998 radsol21b6.tar.Z
-rw-r--r-- 1 hbwork 7526 Nov 10 23:47 wget-log
-rw-r--r-- 1 hbwork 1748 Nov 13 21:51 wget-log.1
通常情况下，shell script是在子shell中执行的，困此在此子shell中对变量所作的
修改对父shell不起作用。点(.) 命令使用shell在不创建子shell而由当前shell读取
并执行一个shell script, 可以通过这种方式来定义函数及变量。此外点(.)命令最
常用的功能就是通过读取.profile来重新配置初始化login变量。如下所示：
修改对父shell不起作用。点(.) 命令使用shell在不创建子shell而由当前shell读取
并执行一个shell script, 可以通过这种方式来定义函数及变量。此外点(.)命令最
常用的功能就是通过读取.profile来重新配置初始化login变量。如下所示：
$ . .profile
(csh相对于.命令的是source命令).
(csh相对于.命令的是source命令).
(7)使用And/Or结构进行有条件的命令执行
<1> And , 仅当第一个命令成功时才有执行后一个命令,如同在逻辑与表达式中如果前面的
结果为真时才有必要继续运算，否则结果肯定为假。
<1> And , 仅当第一个命令成功时才有执行后一个命令,如同在逻辑与表达式中如果前面的
结果为真时才有必要继续运算，否则结果肯定为假。
格式如下：
command1 && command2
例：rm $TEMPDIR/* && echo "File successfully removed"
等价于
if rm $TEMPDIR/*
then
echo "File successfully removed"
fi
then
echo "File successfully removed"
fi
<2>Or, 与AND相反，仅当前一个命令执行出错时才执行后一条命令
例： rm $TEMPDIR/* || echo "File not removed"
等价与：
if rm $TEMPDIR/*
then
command
else
echo "File not removed"
fi
then
command
else
echo "File not removed"
fi
<3> 混合命令条件执行
command1 && command2 && command3
当command1, command2成功时才执行command3
command1 && command2 && command3
当command1, command2成功时才执行command3
command1 && command2 || comamnd3
仅当command1成功，command2失败时才执行command3
仅当command1成功，command2失败时才执行command3
当然可以根据自己的需要进行多种条件命令的组合，在此不多讲述。
(8) 使用getopts命令读取unix格式选项
UNIX格式选项指如下格式的命令行参数：
command -options parameters
使用格式：
getopts option_string variable
getopts option_string variable
具体使用方法请参考getopts的在线文档(man getopts).
示例如下：
#newdate
if [ $# -lt 1 ]
then
date
else
while getopts mdyDHMSTjJwahr OPTION
do
case $OPTION
in
m) date '+%m ';; # Month of Year
d) date '+%d ';; # Day of Month
y) date '+%y ';; # Year
D) date '+%D ';; # MM/DD/YY
H) date '+%H ';; # Hour
M) date '+%M ';; # Minute
S) date '+%S ';; # Second
T) date '+%T ';; # HH:MM:SS
j) date '+%j ';; # day of year
J) date '+%y%j ';;# 5 digit Julian date
w) date '+%w ';; # Day of the Week
a) date '+%a ';; # Day abbreviation
h) date '+%h ';; # Month abbreviation
r) date '+%r ';; # AM-PM time
\?) echo "Invalid option $OPTION";;
esac
done
fi
if [ $# -lt 1 ]
then
date
else
while getopts mdyDHMSTjJwahr OPTION
do
case $OPTION
in
m) date '+%m ';; # Month of Year
d) date '+%d ';; # Day of Month
y) date '+%y ';; # Year
D) date '+%D ';; # MM/DD/YY
H) date '+%H ';; # Hour
M) date '+%M ';; # Minute
S) date '+%S ';; # Second
T) date '+%T ';; # HH:MM:SS
j) date '+%j ';; # day of year
J) date '+%y%j ';;# 5 digit Julian date
w) date '+%w ';; # Day of the Week
a) date '+%a ';; # Day abbreviation
h) date '+%h ';; # Month abbreviation
r) date '+%r ';; # AM-PM time
\?) echo "Invalid option $OPTION";;
esac
done
fi
$ newdate -J
94031
$ newdate -a -h -d
Mon
Jan
31
$ newdate -ahd
Mon
Jan
31
$
94031
$ newdate -a -h -d
Mon
Jan
31
$ newdate -ahd
Mon
Jan
31
$
示例程序：复制程序
# Syntax: duplicate [-c integer] [-v] filename
# where integer is the number of duplicate copies
# and -v is the verbose option
# where integer is the number of duplicate copies
# and -v is the verbose option
COPIES=1
VERBOSE=N
VERBOSE=N
while getopts vc: OPTION
do
case $OPTION
in
c) COPIES=$OPTARG;;
v) VERBOSE=Y;;
\?) echo "Illegal Option"
exit 1;;
esac
done
if [ $OPTIND -gt $# ]
then
echo "No file name specified"
exit 2
fi
then
echo "No file name specified"
exit 2
fi
shift `expr $OPTIND -1`
FILE=$1
COPY=0
COPY=0
while [ $COPIES -gt $COPY ]
do
COPY=`expr $COPY + 1`
cp $FILE ${FILE}${COPY}
if [ VERBOSE = Y ]
then
echo ${FILE}${COPY}
fi
done
do
COPY=`expr $COPY + 1`
cp $FILE ${FILE}${COPY}
if [ VERBOSE = Y ]
then
echo ${FILE}${COPY}
fi
done
$ duplicate -v fileA
fileA1
$ duplicate -c 3 -v fileB
fileB1
fileB2
fileB3
4. Shell的定制
通常使用shell的定制来控制用户自己的环境，比如改变shell的外观(提示符)以及增强
自己的命令。
(1)通常环境变量来定制shell
通常改变环境变量可以定制shell的工作环境。shell在处理信息时会参考这些环境变量
，改变环境变量的值在一定程度上改变shell的操作方式，比如改变命令行提示符。
通常改变环境变量可以定制shell的工作环境。shell在处理信息时会参考这些环境变量
，改变环境变量的值在一定程度上改变shell的操作方式，比如改变命令行提示符。
.使用IFS增加命令行分隔符
默认状态下shell的分隔符为空格、制表符及换行符，但可以通过改变IFS的值加入自己
的分隔符。如下所示：
默认状态下shell的分隔符为空格、制表符及换行符，但可以通过改变IFS的值加入自己
的分隔符。如下所示：
$ IFS=":"
$ echo:Hello:my:Friend
Hello my Friend
(2)加入自己的命令及函数
如下程序：
#Directory and Prompt change program
#Syntax: chdir directory
如下程序：
#Directory and Prompt change program
#Syntax: chdir directory
if [ ! -d "$1" ]
then
echo "$1 is not a directory"
exit 1
fi
then
echo "$1 is not a directory"
exit 1
fi
cd $1
PS1=`pwd`mce_markernbsp;
export PS1
PS1=`pwd`mce_markernbsp;
export PS1
$ chdir /usr/home/teresa
$
$
但此程序在执行时系统提示符并不会改变，因为此程序是在子shell中执行的。因此其变量
对当前shell并无影响，要想对当前shell起作用，最好是将此作为函数写在自己的.profile中
或建立自己的个人函数文件.persfuncs
对当前shell并无影响，要想对当前shell起作用，最好是将此作为函数写在自己的.profile中
或建立自己的个人函数文件.persfuncs
#Personal function file persfuncs
chdir()
{
#Directory and Prompt change program
#Syntax: chdir directory
if [ ! -d "$1" ]
then
echo "$1 is not a directory"
exit 1
fi
{
#Directory and Prompt change program
#Syntax: chdir directory
if [ ! -d "$1" ]
then
echo "$1 is not a directory"
exit 1
fi
cd $1
PS1=`pwd`mce_markernbsp;
export PS1;
}
PS1=`pwd`mce_markernbsp;
export PS1;
}
再执行：
$ . .persfuncs
$ chdir temp
/home/hbbwork/temp$
$ . .persfuncs
$ chdir temp
/home/hbbwork/temp$
也可在自己的.profile文件中用 . .persfuncs调用.persfuncs.
说明：在bash/tcsh中已经使用别名，相对而言别名比此方法更为方便。
5. 有关shell的专门讨论
(1)shell程序的调试
切记：程序员（人）总是会犯错误的，而计算机是不会错的。
使用-x进行跟踪执行，执行并显示每一条指令。
(2)命令组
用小括号将一组命令括起来，则这些命令会由子shell来完成；而{command_list;}则在当
前shell中执行。这两者的主要区别在于其对shell变量的影响，子shell执行的命令不会
影响当前shell中的变量。
用小括号将一组命令括起来，则这些命令会由子shell来完成；而{command_list;}则在当
前shell中执行。这两者的主要区别在于其对shell变量的影响，子shell执行的命令不会
影响当前shell中的变量。
$ NUMBER=2
$ (A=2;B=2;NUMBER=`expr $A + $B`; echo $NUMBER)
4
$ echo $NUMBER
2
$ { A=2;B=2;NUMBER=`expr $A + $B`; echo $NUMBER; }
4
$ echo $NUMBER
4
$ (A=2;B=2;NUMBER=`expr $A + $B`; echo $NUMBER)
4
$ echo $NUMBER
2
$ { A=2;B=2;NUMBER=`expr $A + $B`; echo $NUMBER; }
4
$ echo $NUMBER
4
总结：
在本章中讲述了Bourne Shell的基本知识,使用shell变量，shell script基础。这些概念
对于理解学习Korn Shell, csh以及其他script编程都是非常有用的。
很多OS都有不少语言及一些script功能，但很少有象UNIX SHELL这样灵活强大的script脚
本语言能力。
本语言能力。
对于系统管理员或程序员来说，熟练地使用shell script将对日常工作(系统维护及管理)
非常有用，如果你想作一个合格的系统管理员，强烈建议你进一步深入的了解和使用
shell.
非常有用，如果你想作一个合格的系统管理员，强烈建议你进一步深入的了解和使用
shell.
另外，对于系统管理员来说，PERL也是一个必不可少的script编程语言，尤其是对于处理
文本格式的各种文件，PERL具有shell, awk, sed, grep等的功能，但使用起来更为灵活，
功能也更强大。大家可以参考“Perl By Examples"来学习和使用PERL。
文本格式的各种文件，PERL具有shell, awk, sed, grep等的功能，但使用起来更为灵活，
功能也更强大。大家可以参考“Perl By Examples"来学习和使用PERL。