[ykwj121]

发信人: Altmayer (alt>>追求>>堕落>>极限>>), 信区: GNULinux
标 题: Bourne Shell及shell编程(1)
发信站: 饮水思源 (2001年12月30日00:21:48 星期天), 站内信件

【 以下文字转载自 Altmayer 的信箱 】
【 原文由 Altmayer.bbs@altmayer.dhs.org 所发表 】
来 源: from altmayer.dhs.org ([211.80.41.106])
日 期: Sun Dec 30 00:20:35 2001

标 题: LINUX选修课讲义：Bourne Shell及shell编程(1)
发信站: 碧海青天 (Wed Apr 21 23:41:45 1999), 转信

版权声明：
本文内容为大连理工大学LINUX选修课讲义，欢迎大家转载，但禁止使用本材料进行
任何商业性或赢利性活动。转载时请保留本版权声明。

作者：何斌武，hbwork@dlut.edu.cn,大连理工大学网络中心，April 1999.

URL: ftp://ftp.dlut.edu.cn/pub/PEOPLE/albin/

/********抱歉，为了格式不乱，我就用代码模式粘贴了*********/

------------------------------------------------------------------------------ 
Bourne Shell 
  
介绍：Bourne Shell 基础及其他很多有用的特性，shell编程及组织。 
  
主要内容： 
.shell基础      基本介绍，环境，选项，特殊字符 
.shell变量      用户定义变量，环境变量，位置变量(shell 参数) 
.shell script编程 
        条件测试，循环及重复控制 
.shell定制 
  
1.shell基础知识 
  作者：Stephen Bourne 在Bell实验室开发 
  建议：man sh  查看相关UNIX上的改进或特性 
  
(1)shell提示符及其环境 
   /etc/passwd文件 
   提示符：$ 
   /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 
  
    不能执行如下操作：cd, 更改PATH,指定全路径名，输出重定向，因此可以提供一个较 
    好的控制和安全机制。通常rsh用于应用型用户及拨号用户，这些用户通常是看不到提 
    示符的。通常受限制用户的主目录是不可写的。 
  
    不足：如果用户可以调用sh,则rsh的限制将不在起作用，事实上如果用户在vi及more 
        程序中调用shell,而这时rsh的限制将不再起作用。 
  
(4)用set改变 shell选项 
   用户可以在$提示符下用set命令来设置或取消shell的选项。使用-设置选项，+取消相应 
   选项，大多数UNIX系统允许a,e,f,h,k,n,u,v和x的开关设置/取消。 
  
   set -xv 
        启动跟踪方式;显示所有的命令及替换，同样显示输入。 
   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等 
  
        示例：$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        输出重定向 
   <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/hbw 
ork/bin 
  
   其他： 
        $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 
  
2. shell变量 
  变量：代表某些值的符号，如$HOME,cd命令查找$HOME,在计算机语言中可以使用变量可以 
        进行多种运算和控制。 
  
  Bourne Shell有如下四种变量： 
        .用户自定义变量 
        .位置变量即 shell script之参数 
        .预定义变量（特殊变量） 
        .环境变量(参考shell定制部分) 
 (1)用户自定义变量（数据的存储） 
        $ COUNT=1 
        $ NAME="He Binwu" 
  
     技巧：因为大部分UNIX命令使用小写字符，因此在shell编程中通常使用全大写变量， 
        当然这并不是强制性的，但使用大写字符可以在编程中方便地识别变量。 
  
     变量的调用：在变量前加$ 
        $ 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 
  
     $ 
  
     使用unset命令删除变量的赋值 
     $ Z=hello 
     $ echo $Z 
     hello 
     $ unset Z 
     $ echo $Z 
  
     $ 
  
     有条件的命令替换 
        在Bourne Shell中可以使变量替换在特定条件下执行，即有条件的环境变量替换。 
        这种变量替换总是用大括号括起来的。 
  
        .设置变量的默认值 
            在变量未赋值之前其值为空。Bourne Shell允许对变量设置默认值，其格式如 
下： 
            ${variable:-defaultvalue} 
            例： 
                $ echo Hello $UNAME 
                Hello 
                $ echo Hello ${UNAME:-there} 
                Hello there 
                $ echo $UNAME   #变量值并未发生变化 
  
                $ UNAME=hbwork 
                $ echo Hello ${UNAME:-there} 
                Hello hbwork 
                $ 
        .另一种情况：改变变量的值，格式如下： 
            ${variable:=value} 
  
            例： 
                $ echo Hello $UNAME 
                Hello 
                $ echo Hello ${UNAME:=there} 
                Hello there 
                $ echo $UNAME   #变量值并未发生变化 
                there 
                $ 
        .变量替换中使用命令替换 
                $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 
  
  (2)位置变量(Shell参数) 
  在shell script中位置参数可用$1..$9表示，$0表示内容通常为当前执行程序的文件名。 
  .防止变量值被替换 readonly variable 
  .使用export命令输出变量，使得变量对子shell可用，当shell执行一下程序时，shell 
   将为其设置一个新的环境让其执行，这称之了subshell.  在Bourne Shell中变量通常 
   被认为是本地变量，也就是说在对其赋值之外的shell环境之外是不认识此变量的。使 
   用export对subshell可用。 
  
   例：对变量PS1的export操作，shell的提示符将发生变化。 
   $ PS1=`hostname`$ 
        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 
  
   每天数据的备份： 
   $ cd /usr/yourname; ls * |cpio -o > /dev/rmt/0h 
  
   书写程序的目的是一次编程，多次使用（执行）！ 
  
   $ cat > backup.sh 
   cd /home/hbwork 
   ls * | cpio -o > /dev/rmt/0h 
   ^D 
  
   执行： 
   $ sh backup.sh 
  
   或： 
   $ chmod +x backup.sh 
   $ ./backup.sh 
  
   技巧：在shell script中加入必要的注释，以便以后阅读及维护。 
  
(2)shell是一个（编程）语言 
  同传统的编程语言一样，shell提供了很多特性，这些特性可以使你的shell script 
  编程更为有用，如：数据变量、参数传递、判断、流程控制、数据输入和输出，子 
  程序及以中断处理等。 
  
  . 在shell编程中使用数据变量可以将程序变量更为通用，如在上面backup.sh中： 
    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 
  
(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 
  
        $restore1 file1 
  
        恢复多个文件restoreany : 
        #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总是执行. 
  
   示例程序unload: 在备份成功时删除原始文件,带有错误检查 
  
        cd $1 
        #备份时未考虑不成功的情况! 
        ls -a | cpio -o > /dev/rmt/0h 
        rm -rf * 
  
        改进如下: 
  
        #当使用了管道命令时,管理命令的返回代码为最后一个命令的返回代码 
        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 
  
        技巧: 由于shell对命令中的多余的空格不作任何处理,一个好的程序员会用这一特 
性 
              对自己的程序采用统一的缩进格式,以增强自己程序的可读性. 
  
    . 使用test命令进行进行条件测试 
      格式: test conditions 
  
      test在以下四种情况下使用: a. 字符比较 b.两个整数值的比较 
                c. 文件操作,如文件是否存在及文件的状态等 
                d. 逻辑操作,可以进行and/or,与其他条件联合使用 
  
      a. 测试字符数据: shell变量通常民政部下均作为字符变量 
        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 
                $ 
  
      b. 整数测试: test与expr相同,可以将字符型变量转换为整数进行操作,expr进行 
         整数的算术运算,而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=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)相关的设备是一个终端设备? 
  
      d. 测试条件之否定,使用! 
        例: 
                $ 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测试括起来: 
  
         $ int1=4 
         $ [ $int1 -gt 2 ] 
         $ echo $? 
         0 
  
         例: 重写unload程序,使用test测试 
         #!/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 
  
         #check for valid directory name 
         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 
  
         在如上示例中出现了exit, exit有两个作用:一是停止程序中其他命令的执行,二 
是 
         设置程序的退出状态 
  
      g. if嵌套及elif结构 
        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 
  
        elif结构同if结构类似,但结构更清淅,其执行结果完全相同.

--
※ 转寄:·极乐世界 altmayer.dhs.org·[FROM: NIRVANA]

[ykwj121]

发信人: Altmayer (alt>>追求>>堕落>>极限>>), 信区: GNULinux
标 题: Bourne Shell及shell编程(2)
发信站: 饮水思源 (2001年12月30日00:21:51 星期天), 站内信件

【 以下文字转载自 Altmayer 的信箱 】
【 原文由 Altmayer.bbs@altmayer.dhs.org 所发表 】
来 源: from altmayer.dhs.org ([211.80.41.106])
日 期: Sun Dec 30 00:20:37 2001

标 题: LINUX选修课讲课义:Bourne Shell及shell编程(2)
发信站: 碧海青天 (Thu Apr 22 23:33:45 1999), 转信

版权声明：
本文内容为大连理工大学LINUX选修课讲义，欢迎大家转载，但禁止使用本材料进行
任何商业性或赢利性活动。转载时请保留本版权声明。

作者：何斌武，hbwork@dlut.edu.cn,大连理工大学网络中心，April 1999.

URL: ftp://ftp.dlut.edu.cn/pub/PEOPLE/albin/

/********抱歉，为了格式不乱，我用代码模式粘贴全文*********/
------------------------------------------------------------------------------

Bourne Shell及Shell编程(2) 
      h.交互式从键盘读入数据 
        使用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为空 
        $ 
  
        在shell script中可使用read语句进行交互操作： 
  
        ... 
        #echo -n message 输出结果后不换行 
        echo -n "Do you want to continue: Y or N" 
        read ANSWER 
  
        if [ $ANSWER=N -o $ANSWER=n ] 
        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 
  
        相应的case结构： 
  
        case value in 
            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 
  
       #Read and excute the user's selection 
       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 
  
        在上例中，*指默认匹配动作。此外，case模式中也可以使用逻辑操作，如下所示 
： 
  
        pattern1 | pattern2 )   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 
  
(5)循环控制 
    <1> while循环: 
        格式： 
                while   command 
                do 
                        command 
                        command 
                        command 
                        ... 
                done 
  
        例： 计算1到5的平方 
        #!/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" 
  
        $ sh square.sh 
        1 
        4 
        9 
        16 
        25 
        Job completed 
  
      <2> until循环结构： 
        格式： 
                until command 
                do 
                        command 
                        command 
                        .... 
                        command 
                done 
  
        示例：使用until结构计算1-5的平方 
        #!/bin/sh 
  
        int=1 
  
        until [ $int -gt 5 ] 
        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在移位后将不在存在。 
  
        示例如下： 
  
        #!/bin/sh 
        # 
        #Filename: shifter 
  
         until [ $# -eq 0 ] 
         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: 
  
        #!/bin/sh 
        # sumints - a program to sum a series of integers 
        # 
  
         if [ $# -eq 0 ] 
         then 
            echo "Usage: sumints integer list" 
            exit 1 
         fi 
  
         sum=0 
  
         until [ $# -eq 0 ] 
         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. 
  
        另外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 i in * 
          do 
                if [ -f $i ] 
                then 
                        echo "$i is a file" 
                elif    [ -d $i ] 
                        echo "$i is a directory" 
                fi 
          done 
  
        求命令行上所有整数之和： 
        #!/bin/sh 
  
        sum=0 
  
        for INT in $* 
        do 
                sum=`expr $sum + $INT` 
        done 
  
        echo $sum 
  
  
      <6> 从循环中退出： break和continue命令 
        break           立即退出循环 
        continue        忽略本循环中的其他命令，继续下一下循环 
  
        在shell编程中有时我们要用到进行无限循环的技巧，也就是说这种循环一直执行 
碰 
        到break或continue命令。这种无限循环通常是使用true或false命令开始的。UNIX 
        系统中的true总是返加0值，而false则返回非零值。如下所示： 
  
        #一直执行到程序执行了break或用户强行中断时才结束循环 
        while true 
        do 
                command 
                .... 
                command 
        done 
  
        上面所示的循环也可以使用until false, 如下： 
  
        until false 
        do 
                command 
                .... 
                command 
        done 
  
        在如下shell script中同时使用了continue,break以及case语句中的正规表达式用 
法： 
  
         #!/bin/sh 
         # 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 
  
         # Read the user's selection 
            echo -n "Enter Choice: " 
  
            read CHOICE 
  
            case $CHOICE in 
               [1-3] ) echo 
                       # Read and validate the name of the directory 
  
                       echo -n "What directory do you want? " 
                       read WORKDIR 
  
                       if [ ! -d "$WORKDIR" ] 
                       then 
                          echo "Sorry, $WORKDIR is not a directory" 
                          continue 
                       fi 
  
                       # Make the directory the current working directory 
                       cd $WORKDIR;; 
  
                    4) :;;    # :为空语句，不执行任何动作 
                    *) echo "Sorry, $CHOICE is not a valid choice" 
                       continue 
            esac 
  
            case "$CHOICE" in 
               1) echo "Restoring..." 
                  cpio -i </dev/rmt/0h;; 
  
               2) echo "Archiving..." 
                  ls | cpio -o >/dev/rmt/0h;; 
  
               3) echo "Unloading..." 
                  ls | cpio -o >/dev/rmt/0h;; 
  
               4) echo "Quitting" 
                  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 
  
               echo "Please check the device and try again" 
               continue 
            else 
               if [ $CHOICE = 3 ] 
               then 
                  rm * 
               fi 
            fi 
         done 
  
  
(6)结构化编程：定义函数 
   同其他高级语言一样，shell也提供了函数功能。函数通常也称之为子过程(subroutine) 
, 
   其定义格式如下： 
  
   funcname() 
   { 
        command 
        ... 
        command;  #分号 
   } 
  
   定义函数之后，可以在shell中对此函数进行调用，使用函数定义可以将一个复杂的程序 
分 
   为多个可管理的程序段，如下所示： 
  
        # start program 
  
         setup () 
         {  command list ; } 
  
         do_data () 
         {  command list ; } 
  
         cleanup () 
         {  command list ; } 
  
         errors () 
         {  command list ; } 
  
         setup 
         do_data 
         cleanup 
         # end program 
  
     技巧： 
        . 在对函数命名时最好能使用有含义的名字，即函数名能够比较准确的描述函数所 
完成 
          的任务。 
        . 为了程序的维护方便，请尽可能使用注释 
  
  
     使用函数的另一个好处就是可以在一个程序中的不同地方执行相同的命令序列(函数), 
     如下所示： 
  
     iscontinue() 
     { 
        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 
     } 
  
     这样可以在shell编程中调用iscontinue确定是否继续执行： 
  
     if iscontinue 
     then 
        continue 
     else 
        break 
     fi 
  
  
  ** shell函数与shell程序非常相似，但二者有一个非常重要的差别：shell程序是由子sh 
ell 
     执行的，而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 
        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变量。如下所示： 
  
     $ . .profile 
     (csh相对于.命令的是source命令). 
  
(7)使用And/Or结构进行有条件的命令执行 
 <1> And , 仅当第一个命令成功时才有执行后一个命令,如同在逻辑与表达式中如果前面的 
     结果为真时才有必要继续运算，否则结果肯定为假。 
  
     格式如下： 
  
     command1 && command2 
  
     例：rm $TEMPDIR/* && echo "File successfully removed" 
  
         等价于 
  
         if rm $TEMPDIR/* 
         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 
  
 <3> 混合命令条件执行 
     command1 && command2 && command3 
        当command1, command2成功时才执行command3 
  
     command1 && command2 || comamnd3 
         仅当command1成功，command2失败时才执行command3 
  
     当然可以根据自己的需要进行多种条件命令的组合，在此不多讲述。 
  
  
(8) 使用getopts命令读取unix格式选项 
    UNIX格式选项指如下格式的命令行参数： 
    command -options parameters 
  
    使用格式： 
    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 
  
         $ newdate -J 
         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 
  
         COPIES=1 
         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 
  
  
         shift `expr $OPTIND -1` 
  
         FILE=$1 
         COPY=0 
  
         while [ $COPIES -gt $COPY ] 
         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的操作方式，比如改变命令行提示符。 
  
   .使用IFS增加命令行分隔符 
     默认状态下shell的分隔符为空格、制表符及换行符，但可以通过改变IFS的值加入自 
己 
     的分隔符。如下所示： 
  
  
     $ IFS=":" 
     $ echo:Hello:my:Friend 
     Hello my Friend 
  
(2)加入自己的命令及函数 
   如下程序： 
   #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`$ 
   export PS1 
  
   $ chdir /usr/home/teresa 
   $ 
  
   但此程序在执行时系统提示符并不会改变，因为此程序是在子shell中执行的。因此其变 
量 
对当前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 
  
   cd $1 
   PS1=`pwd`$ 
   export PS1; 
   } 
  
   再执行： 
   $ . .persfuncs 
   $ chdir temp 
   /home/hbbwork/temp$ 
  
   也可在自己的.profile文件中用 . .persfuncs调用.persfuncs. 
  
   说明：在bash/tcsh中已经使用别名，相对而言别名比此方法更为方便。 
  
  
5. 有关shell的专门讨论 
(1)shell程序的调试 
   切记：程序员（人）总是会犯错误的，而计算机是不会错的。 
   使用-x进行跟踪执行，执行并显示每一条指令。 
  
(2)命令组 
   用小括号将一组命令括起来，则这些命令会由子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 
  
  
总结： 
   在本章中讲述了Bourne Shell的基本知识,使用shell变量，shell script基础。这些概 
念 
   对于理解学习Korn Shell, csh以及其他script编程都是非常有用的。 
  
   很多OS都有不少语言及一些script功能，但很少有象UNIX SHELL这样灵活强大的script 
脚 
   本语言能力。 
  
   对于系统管理员或程序员来说，熟练地使用shell script将对日常工作(系统维护及管理 
) 
   非常有用，如果你想作一个合格的系统管理员，强烈建议你进一步深入的了解和使用 
   shell. 
  
   另外，对于系统管理员来说，PERL也是一个必不可少的script编程语言，尤其是对于处 
理 
   文本格式的各种文件，PERL具有shell, awk, sed, grep等的功能，但使用起来更为灵活 
， 
   功能也更强大。大家可以参考“Perl By Examples"来学习和使用PERL。 
  
--

※ 转寄:·极乐世界 altmayer.dhs.org·[FROM: NIRVANA]
--

[KornLee]

在使您的应用程序成型过程中节省时间和精力
Angel Rivera (rivera@us.ibm.com)
软件工程师，VisualAge TeamConnection, IBM
2001 年 3 月
-------------------------------------------------------
创建脚本
功能测试是软件开发的一个关键部分 -- 而已经装入 Linux 的 Bash 可以帮您轻而易举地完成功能测试。在本文中，Angel Rivera 将说明如何运用 Bash shell 脚本通过行命令来执行 Linux 应用程序的功能测试。由于此脚本依赖于命令行的返回码，因而您不能将这种方法运用于 GUI 应用程序。

功能测试是开发周期的一个阶段，在这个阶段中将测试软件应用程序以确保软件的函数如预期的那样，同时能正确处理代码中错误。此项工作通常在单个模块的单元测试结束之后，在负载／重压条件下整个产品的系统测试之前进行的。

市场上有许多测试工具提供了有助于功能测试的功能。然而，首先要获取它们，然后再安装、配置，这将占用您宝贵的时间和精力。Bash 可以帮您免去这些烦琐的事从而可以加快测试的进程。

使用 Bash shell 脚本进行功能测试的优点在于：
Bash shell 脚本已经在 Linux 系统中安装和配置好了。不必再花时间准备它。
可以使用由 Linux 提供的文本编辑器如 vi 创建和修改 Bash shell 脚本。不需要再为创建测试程序而获取专门的工具。
如果已经知道了如何开发 Bourne 或 Korn shell 脚本，那对于如何运用 Bash shell 脚本已经足够了。对您来说，学习曲线已不存在了。
Bash shell 提供了大量的编程构造用于开发从非常简单到中等复杂的脚本。

将脚本从 Korn 移植到 Bash 时的建议
如果已有现成的 Korn shell 脚本，而想要将它们移植到 Bash，就需要考虑下列情况：

Korn 的 "print" 命令在 Bash 中不能使用；而是改为使用 "echo" 命令。
需要将脚本的第一行：
#!/usr/bin/ksh
修改成：
#!/bin/bash

创建 Bash shell 脚本进行功能测试
这些基本的步骤和建议适用于许多在 Linux 上运行的客户机／服务器应用程序。

记录运行脚本的先决条件和主要步骤
将操作分成若干个逻辑组
基于一般方案制定执行步骤
在每个 shell 脚本中提供注释和说明
做一个初始备份以创建基准线
检查输入参数和环境变量
尝试提供 "usuage" 反馈
尝试提供一个"安静"的运行模式
当出现错误时，提供一个函数终止脚本
如可能，提供可以执行单个任务的函数
当显示正在生成的输出时，捕获每个脚本的输出
在每个脚本内，捕获每个行命令的返回码
计算失败事务的次数
在输出文件中，突出显示错误消息，以便于标识
如有可能，"实时"生成文件
在执行脚本的过程中提供反馈
提供脚本执行的摘要
提供一个容易解释的输出文件
如有可能，提供清除脚本及返回基准线的方法



下面详细讲述了每一条建议以及用于说明问题的脚本。若要下载此脚本，请参阅本文后面的参考资料部分。


1. 记录运行脚本的先决条件和主要步骤
记录，尤其是以有自述标题的单个文件（例如 "README-testing.txt"）记录功能测试的主要想法是很重要的，包括，如先决条件、服务器和客户机的设置、脚本遵循的整个（或详细的）步骤、如何检查脚本的成功／失败、如何执行清除和重新启动测试。


2. 将操作分成若干个逻辑组
如果仅仅执行数量非常少的操作，可以将它们全部放在一个简单的 shell 脚本中。


但是，如果需要执行一些数量很多的操作，那最好是将它们分成若干个逻辑集合，例如将一些服务器操作放在一个文件而将客户机操作放在在另一个文件中。通过这种方法，划分适当的颗粒度来执行测试和维护测试。


3. 基于一般方案制定执行步骤
一旦决定对操作进行分组，需要根据一般方案考虑执行操作的步骤。此想法是模拟实际生活中最终用户的情形。作为一个总体原则，只需集中测试 80% 最常调用函数的 20% 用法即可。


例如，假设应用程序要求 3 个测试组以某个特定的顺序排列。每个测试组可以放在一个带有自我描述文件名（如果可能）的文件中，并用号码来帮助识别每个文件的顺序，例如：

1.  fvt-setup-1:    To perform initial setup.
2.  fvt-server-2:   To perform server commands.
3.  fvt-client-3:   To perform client commands.
4.  fvt-cleanup:    To cleanup the temporary files, 
                        in order to prepare for the repetition
                        of the above test cases.

4. 在每个 shell 脚本中提供注释和说明
在每个 shell 脚本的头文件中提供相关的注释和说明是一个良好的编码习惯。这样的话，当另一个测试者运行该脚本时，测试者就能清楚地了解每个脚本中测试的范围、所有先决条件和警告。


下面是一个 Bash 脚本 "test-bucket-1" 的示例 。

#!/bin/bash
#
# Name: test-bucket-1
#
# Purpose:
#    Performs the test-bucket number 1 for Product X.
#    (Actually, this is a sample shell script, 
#     which invokes some system commands 
#     to illustrate how to construct a Bash script) 
#
# Notes:
# 1) The environment variable TEST_VAR must be set 
#    (as an example).
# 2) To invoke this shell script and redirect standard 
#    output and standard error to a file (such as 
#    test-bucket-1.out) do the following (the -s flag 
#    is "silent mode" to avoid prompts to the user):
#
#    ./test-bucket-1  -s  2>&1  | tee test-bucket-1.out
#
# Return codes:
#  0 = All commands were successful
#  1 = At least one command failed, see the output file 
#      and search for the keyword "ERROR".
#
########################################################

5. 做一个初始备份以创建基准线
您可能需要多次执行功能测试。第一次运行它时，也许会找到脚本或进程中的一些错误。因而，为了避免因从头重新创建服务器环境而浪费大量时间 -- 特别是如果涉及到数据库 -- 您在测试之前或许想做个备份。


在运行完功能测试之后，就可以从备份中恢复服务器了，同时也为下一轮测试做好了准备。


6. 检查输入参数和环境变量
最好校验一下输入参数，并检查环境变量是否设置正确。如果有问题，显示问题的原因及其修复方法，然后终止脚本。


当测试者准备运行脚本，而此时如果没有正确设置脚本所调用的环境变量，但由于发现及时，终止了脚本，那测试者会相当感谢。没有人喜欢等待脚本执行了很久却发现没有正确设置变量。

# --------------------------------------------
# Main routine for performing the test bucket
# --------------------------------------------

CALLER=`basename $0`         # The Caller name
SILENT="no"                  # User wants prompts
let "errorCounter = 0"

# ----------------------------------
# Handle keyword parameters (flags).
# ----------------------------------

# For more sophisticated usage of getopt in Linux, 
# see the samples file: /usr/lib/getopt/parse.bash

TEMP=`getopt hs $*`
if [ $? != 0 ]
then
 echo "$CALLER: Unknown flag(s)"
  usage
fi 

# Note quotes around `$TEMP': they are essential! 
eval set -- "$TEMP"

while true                   
 do
  case "$1" in
   -h) usage "HELP";    shift;; # Help requested
   -s) SILENT="yes";    shift;; # Prompt not needed
   --) shift ; break ;; 
   *) echo "Internal error!" ; exit 1 ;;
  esac
 done

# ------------------------------------------------
# The following environment variables must be set
# ------------------------------------------------

if [ -z "$TEST_VAR" ]
then
  echo "Environment variable TEST_VAR is not set."
  usage
fi

关于此脚本的说明如下：

使用语句 CALLER=`basename $0` 可以得到正在运行的脚本名称。这样的话，无须在脚本中硬编码脚本名称。因此当复制脚本时，采用新派生的脚本可以减少工作量。
调用脚本时，语句 TEMP=`getopt hs $*` 用于得到输入变量（例如 -h 代表帮助，-s 代表安静模式）。
语句 [ -z "$X" ] 和 echo "The environment variable X is not set." 以及 usage 都是用于检测字符串是否为空 (-z)，如果为空，随后就执行 echo 语句以显示未设置字符串并调用下面要讨论的 "usage" 函数。
若脚本未使用标志，可以使用变量 "$#"，它可以返回正在传递到脚本的变量数量。

7. 尝试提供"usage"反馈
脚本中使用 "usage" 语句是个好主意，它用来说明如何使用脚本。

# ----------------------------
# Subroutine to echo the usage
# ----------------------------

usage()
{
 echo "USAGE: $CALLER [-h] [-s]"
 echo "WHERE: -h = help       "
 echo "       -s = silent (no prompts)"
 echo "PREREQUISITES:"
 echo "* The environment variable TEST_VAR must be set,"
 echo "* such as: "
 echo "   export TEST_VAR=1"
 echo "$CALLER: exiting now with rc=1."
  exit 1
}

调用脚本时，使用"-h"标志可以调用 "usage" 语句，如下所示：
./test-bucket-1 -h


8. 尝试使用"安静"的运行模式
您或许想让脚本有两种运行模式：

在 "verbose" 模式（您也许想将此作为缺省值）中提示用户输入值，或者只需按下 Enter 继续运行。
在 "silent" 模式中将不提示用户输入数据。

下列摘录说明了在安静模式下运用所调用标志 "-s" 来运行脚本：

# -------------------------------------------------
# Everything seems OK, prompt for confirmation
# -------------------------------------------------

if [ "$SILENT" = "yes" ]
then
 RESPONSE="y"
else
 echo "The $CALLER will be performed."
 echo "Do you wish to proceed [y or n]? "
 read RESPONSE                  # Wait for response
 [ -z "$RESPONSE" ] && RESPONSE="n"
fi 

case "$RESPONSE" in
 [yY]|[yY][eE]|[yY][eE][sS])
 ;;
 *)
  echo "$CALLER terminated with rc=1."
  exit 1
 ;;
esac

9. 当出现错误时，提供一个函数终止脚本
遇到严重错误时，提供一个中心函数以终止运行的脚本不失为一个好主意。此函数还可提供附加的说明，用于指导在此情况下应做些什么：

# ----------------------------------
# Subroutine to terminate abnormally
# ----------------------------------

terminate()
{
 echo "The execution of $CALLER was not successful."
 echo "$CALLER terminated, exiting now with rc=1."
 dateTest=`date`
 echo "End of testing at: $dateTest"
 echo ""
  exit 1
}

10. 如有可能，提供可以执行简单任务的函数
例如，不使用许多很长的行命令，如：

# --------------------------------------------------
echo ""
echo "Creating Access lists..."
# --------------------------------------------------

 Access -create -component Development -login ted -authority plead -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login ted 
    -authority plead"
     let "errorCounter = errorCounter + 1" 
 fi

 Access -create -component Development -login pat -authority general -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login pat 
    -authority general"
     let "errorCounter = errorCounter + 1" 
 fi

 Access -create -component Development -login jim -authority general -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component Development -login jim 
    -authority general"
     let "errorCounter = errorCounter + 1" 
 fi

……而是创建一个如下所示的函数，此函数也可以处理返回码，如果有必要，还可以增加错误计数器：

CreateAccess()
{
 Access -create -component $1 -login $2 -authority $3 -verbose
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in Access -create -component $1 -login $2 -authority $3"
     let "errorCounter = errorCounter + 1" 
 fi
}

……然后，以易读和易扩展的方式调用此函数：

# ------------------------------------------- 
echo ""
echo "Creating Access lists..."
# ------------------------------------------- 

CreateAccess Development ted    projectlead
CreateAccess Development pat    general
CreateAccess Development jim    general

11. 当显示正在生成的输出时，捕获每个脚本的输出
如果脚本不能自动地将输出发送到文件的话，可以利用 Bash shell 的一些函数来捕获所执行脚本的输出，如：

./test-bucket-1 -s 2>&1 | tee test-bucket-1.out

让我们来分析上面的命令：

"2>&1" 命令：

使用 "2>&1" 将标准错误重定向到标准输出。字符串 "2>&1" 表明任何错误都应送到标准输出，即 UNIX/Linux 下 2 的文件标识代表标准错误，而 1 的文件标识代表标准输出。如果不用此字符串，那么所捕捉到的仅仅是正确的信息，错误信息会被忽略。

管道 "|" 和 "tee" 命令：

UNIX/Linux 进程和简单的管道概念很相似。既然这样，可以做一个管道将期望脚本的输出作为管道的输入。下一个要决定的是如何处理管道所输出的内容。在这种情况下，我们会将它捕获到输出文件中，在此示例中将之称为 "test-bucket-1.out"。


但是，除了要捕获到输出结果外，我们还想监视脚本运行时产生的输出。为达到此目的，我们连接允许两件事同时进行的 "tee" （T- 形管道）：将输出结果放在文件中同时将输出结果显示在屏幕上。 其管道类似于：

process --> T ---> output file
             |
             V
           screen

如果只想捕获输出结果而不想在屏幕上看到输出结果，那可以忽略多余的管道： ./test-bucket-1 -s 2>&1 > test-bucket-1.out


假若这样，相类似的管道如下：

process --> output file

12. 在每个脚本内，捕获每个行命令所返回码
决定功能测试成功还是失败的一种方法是计算已失败行命令的数量，即返回码不是 0。变量 "$?" 提供最近所调用命令的返回码；在下面的示例中，它提供了执行 "ls" 命令的返回码。

# -------------------------------------------
# The commands are called in a subroutine 
# so that return code can be
# checked for possible errors.
# -------------------------------------------
ListFile()
{ 
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in: ls -al $1"
     let "errorCounter = errorCounter + 1" 
fi 
}

13. 记录失败事务的次数
在功能测试中决定其成功或失败的一个方法是计算返回值不是 0 的行命令数量。但是，从我个人的经验而言，我习惯于在我的 Bash shell 脚本中仅使用字符串而不是整数。在我所参考的手册中没有清楚地说明如何使用整数，这就是我为什么想在此就关于如何使用整数和计算错误（行命令失败）数量的方面多展开讲的原因：
首先，需要按如下方式对计数器变量进行初始化：

let "errorCounter = 0"

然后，发出行命令并使用 $? 变量捕获返回码。如果返回码不是 0，那么计数器增加 1（见蓝色粗体语句）：

ListFile()
{
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in: ls -al $1"
  let "errorCounter = errorCounter + 1"
 fi
}

顺便说一下，与其它变量一样，可以使用 "echo" 显示整数变量。


14. 在输出文件中，为了容易标识，突出显示错误消息
当遇到错误（或失败的事务）时，除了错误计数器的数量会增加外，最好标识出此处有错。较理想的做法是，字符串有一个如 ERROR 或与之相似的子串（见蓝色粗体的语句），这个子串允许测试者很快地在输出文件中查找到错误。此输出文件可能很大，而且它对于迅速找到错误非常重要。

ListFile()
{
 echo "ls -al $1"
 ls -al $1
  if [ $? -ne 0 ] 
  then 
  echo "ERROR found in: ls -al $1"
     let "errorCounter = errorCounter + 1" 
 fi
}

15. 如有可能，"实时"生成文件
在某些情况下，有必要处理应用程序使用的文件。可以使用现有文件，也可以在脚本中添加语句来创建文件。如果要使用的文件很长，那最好将其作为独立的实体。如果文件很小而且内容简单或不相关（重要的一点是文本文件而不考虑它的内容），那就可以决定"实时"创建这些临时文件。


下面几行代码显示如何"实时"创建临时文件：

cd $HOME/fvt

echo "Creating file softtar.c"

echo "Subject: This is softtar.c" >  softtar.c
echo "This is line 2 of the file" >> softtar.c

第一个 echo 语句使用单个的 > 强行创建新文件。第二个 echo 语句使用两个 >> 将数据附加到现有文件的后面。顺便说一下，如果该文件不存在，那么会创建一个文件。


16. 在执行脚本的过程中提供反馈
最好在脚本中包含 echo 语句以表明它执行的逻辑进展状况。可以添加一些能迅速表明输出目的的语句。


如果脚本要花费一些时间执行，那或许应在执行脚本的开始和结束的地方打印时间。这样可以计算出所花费的时间。


在脚本样本中，一些提供进展说明的 echo 语句如下所示：

# --------------------------------------------
echo "Subject: Product X, FVT testing"
dateTest=`date`
echo "Begin testing at: $dateTest"
echo ""
echo "Testcase: $CALLER"
echo ""
# --------------------------------------------

# --------------------------------------------
echo ""
echo "Listing files..."
# --------------------------------------------

# The following file should be listed:
ListFile   $HOME/.profile

...

# --------------------------------------------
echo ""
echo "Creating file 1"
# --------------------------------------------

17. 提供脚本执行的摘要
如果正在计算错误或失败事务的次数，那最好表明是否有错误。此方法使得测试者在看到输出文件的最后能迅速地辨认出是否存在错误。


在下面的脚本示例中，代码语句提供了上述脚本的执行摘要：

# --------------
# Exit
# --------------
if [ $errorCounter -ne 0 ]
then
 echo ""
 echo "*** $errorCounter ERRORS found during ***"
 echo "*** the execution of this test case.  ***"
 terminate
else
 echo ""
 echo "*** Yeah! No errors were found during ***"
 echo "*** the execution of this test case. Yeah! ***"
fi 

echo ""
echo "$CALLER complete."
echo ""
dateTest=`date`
echo "End of testing at: $dateTest"
echo ""

exit 0

# end of file

18. 提供一个容易解释的输出文件
在脚本生成的实际输出中提供一些关键信息是非常有用的。那样，测试者就可以很容易地确定正在查看的文件是否与自己所做的相关以及它是否是当前产生的。附加的时间戳记对于是否是当前状态是很重要的。摘要报告对于确定是否有错误也是很有帮助的；如果有错误，那么测试者就必须搜索指定的关键字，例如 ERROR，并确认出个别失败的事务。

以下是一段输出文件样本的片段：

Subject: CMVC 2.3.1, FVT testing, Common, Part 1 
Begin testing at: Tue Apr 18 12:50:55 EDT 2000   
                                                 
Database: DB2                                    
Family:   cmpc3db2                               
Testcase: fvt-common-1                           
                                                 
Creating Users...                                
User pat was created successfully.               
...

Well done! No errors were found during the 
execution of this test case :)
                                                                           
fvt-common-1 complete.                                                      
                                                                            
End of testing at: Tue Apr 18 12:56:33 EDT 2000

当遇到错误时输出文件最后部分的示例如下所示：

ERROR found in Report -view DefectView

*** 1 ERRORS found during the execution of this test case. ***           
The populate action for the CMVC family was not successful.               
Recreating the family may be necessary before 
running fvt-client-3 again, that is, you must use 'rmdb', 
'rmfamily', 'mkfamily' and 'mkdb -d',       
then issue: fvt-common-1 and optionally, fvt-server-2.                    
fvt-client-3 terminated, exiting now with rc=1.                           
End of testing at: Wed Jan 24 17:06:06 EST 2001

19. 如有可能，提供清除脚本及返回基准线的方法
测试脚本可以生成临时文件；假若这样，最好能让脚本删除所有临时文件。这就会避免由于测试者也许没有删除所有临时文件而引起的错误，更糟糕的是将所需要的文件当作临时文件而删除了。

运行功能测试的 Bash shell 脚本
本节描述如何运用 Bash shell 脚本进行功能测试。假设您已经执行了在前面部分中所述步骤。


设置必要的环境变量
根据需要在 .profile 中或手工指定下列环境变量。该变量用于说明在脚本中如何处理，所需环境变量的验证必须在脚本执行前定义。

export TEST_VAR=1

将 Bash shell 脚本复制到正确的目录下
Bash shell 脚本和相关文件需要复制到要进行功能测试的用户标识的目录结构下。

登录进某个帐户。您应该在主目录下。假设它是 /home/tester。
为测试案例创建目录：mkdir fvt
复制 Bash shell 脚本和相关文件。获取压缩文件（请参阅参考资料）并将其放在 $HOME 下。然后将其按下列方式解压：unzip trfvtbash.zip
为了执行这个文件，更改文件的许可权：chmod u+x *
更改名称以除去文件的后缀：mv test-bucket-1.bash test-bucket-1

运行脚本
执行下列步骤以运行脚本：

以测试者的用户标识登录
更改目录至所复制脚本的位置：cd $HOME/fvt
从 $HOME/fvt 运行脚本：./test-bucket-1 -s 2>&1 | tee test-bucket-1.out
看一下输出文件 "test-bucket-1.out" 的尾部并查看摘要报告的结论。

[wyclif]

顶，呵呵

[flaboy]

好东西

shell是linux的基础
不会shell就象 走路不穿鞋子一样

[activeion]

好东西呀



谢谢

[shengjie]

精！

[TomCruise]

呵呵，挺有意思的，
有人初吗，给点见意啊：)
刚才弄了几下，感觉还可以：)

[mereUnix]

此shel教程对于linux似乎老了一些!
有些语法特性似乎不能用了!l

[KornLee]

兄弟说得是!
不过基础就是最重要的!,如果我们掌握了最基础的shell知识,我想无论在什么linux平台上,都可以一展身手的!

[KornLee]

兄弟说得是!
不过基础就是最重要的!,如果我们掌握了最基础的shell知识,我想无论在什么linux平台上,都可以一展身手的!

[777]

-c "string" 从strings中读取命令

什么意思??

那个 string 是什么意思 我一直不懂安

thanks!!!

[KornLee]

-c "string"大概的意思是:
-c是shell的一个选项,如我用的是KSH,那么我就可以这样ksh -c "myscript",实际上那个string就是一个脚本!
你自己可以比较一下:
$bash -c "urscript"
和
$urscript
两种方式有何异同

[lyn]

外国人就是奇怪！！！

谢了。

[lyn]

晕 什么时候能看完。