Bourne shell编程入门及脚本测试

共有 4 条评论

1. kerzy 于 2005-08-01 22:52:50发表:

   非常感谢

2. 何哥 于 2005-07-27 00:19:37发表:

   函数应用实例介绍
   代码:
   $cat dbfunctions
   addon () { # 定义函数addon,他的功能是把新的信息加入datafile
   while true
   do
   echo "Adding information "
   echo "Type the full name of employee "
   read name
   echo "Type address for employee "
   read address
   echo "Type start date for employee (4/10/88 ) :"
   read startdate
   echo $name:$address:$startdate
   echo -n "Is this correct? "
   read ans
   case "$ans" in
   [Yy]*)
   echo "Adding info..."
   echo $name:$address:$startdate>>datafile
   sort -u datafile -o datafile
   echo -n "Do you want to go back to the main menu? "
   read ans
   if [ $ans = Y -o $ans = y ]
   then
   return # return命令把控制送回函数被调用时所在的调用程序
   else
   continue # 把控制返回到while循环顶部
   fi
   ;;
   *)
   echo "Do you want to try again? "
   read answer
   case "$answer" in
   [Yy]*)
   continue;;
   *)
   exit;;
   esac
   ;;
   esac
   done
   } # 结束函数定义
   
   $cat mainprog
   #!/bin/sh
   script name: mainprog
   # This is the main script that will call the function, addon
   
   #datafile=$HOME/bourne/datafile
   datafile=./datafile
   
   . dbfunctions # dot命令把文件dbfunctions装入内存,
   
   if [ ! -f $datafile ]
   then
   echo "`basename $datafile` does not exist" 1>&2
   exit 1
   fi
   echo "Select one: "
   cat < [1] Add info
   [2] Delete info
   [3] Exit
   EOF
   read choice
   case $choice in
   1) addon # 调用函数
   ;;
   2) delete # 调用函数
   ;;
   3) update
   ;;
   4) echo Bye
   exit 0
   ;;
   *) echo Bad choice
   exit 2
   ;;
   esac
   echo Returned from function call
   echo The name is $name
   # Variable set in the function are known in this shell.
   
   附:文件datafile
   cat database
   Ann Stephens 111 Main St, Boston, MA 4/10/88
   TB Savage 222 B Ave, New York, NY 5/11/99

3. 何哥 于 2005-07-27 00:18:46发表:

   使用 Bash shell 脚本进行功能测试[转]
   
   --------------------------------------------------------------------------------
   
   
   在使您的应用程序成型过程中节省时间和精力
   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" 的尾部并查看摘要报告的结论。

4. 何哥 于 2005-07-27 00:18:14发表:

   代码:
   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
   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。