#!/bin/bash
set -o verbose
#Echoes all commands before executing
#---------------------------
set -v
#Exact same effect as above

如果想进制某一个可选项，使用+，而不是-符号：set +o option-name / set +option-abbrev

#!/bin/bash
set -o verbose
# Command echoing on.
command
...
command
set +o verbose
# Command echoing off.
command
# Not echoed.
set -v
# Command echoing on.
command
...
command
set +v
# Command echoing off.
command
exit 0

还有一种方法就是在指定shell解释器的同时设置可选项，就像下面这样：

#!/bin/bash -x
#
# Body of script follows.

当然，你可以在执行脚本的同时设定可选项，比如：

$ bash -v script-name
$ bash -o verbose script-name

上面两条指令效果相同。

有关bash的可选参数及解释见下表

• 简单用法
  可以用在简单的命令输出，交互程序里。给出几个例子：

  #!/bin/bash
   
  wall < <zzz23EndOfMessagezzz23
  E-mail your noontime orders for pizza to the system administrator.
      (Add an extra dollar for anchovy or mushroom topping.)
  # Additional message text goes here.
  # Note: 'wall' prints comment lines.
  zzz23EndOfMessagezzz23
   
  # Could have been done more efficiently by
  #         wall <message-file
  #  However, embedding the message template in a script
  #+ is a quick-and-dirty one-off solution.
   
  exit

  ——–

  !/bin/bash
   
  # Noninteractive use of 'vi' to edit a file.
  # Emulates 'sed'.
   
  E_BADARGS=85
   
  if [ -z "$1" ]
  then
    echo "Usage: `basename $0` filename"
    exit $E_BADARGS
  fi
   
  TARGETFILE=$1
   
  # Insert 2 lines in file, then save.
  #--------Begin here document-----------#
  vi $TARGETFILE <.
   
  #  Bram Moolenaar points out that this may not work with 'vim'
  #+ because of possible problems with terminal interaction.
   
  exit

• 进制前导tab输出
  这是从曾经遇到的一个问题，在Heredocument里，我为了代码格式好看，采取了tab缩进的方式，但是带来的坏处就是这些tab键也会成为输出，而这并不是我所需要的。因此我需要一个即解决代码格式美观，又不影响输出的办法，原来here document能做到这点，那就是在给出的limit string之前加上一个-符号，比如：

  #!/bin/bash
  cat < <- HERE
            include leading tab
        include leading space
  HERE
  exit 0
  ------------------------------
  $ ./test.sh
  includeing a leading tab
     includeing some spaces

  注：他仅仅只是制止前导tab键，对于空格则不受影响。另外要注意的是，如果你的编辑器设置了tab转空格的话，那你会发现以上代码似乎并不是生效。因为所有的tab都转成4个或者8个或者你设置的数量个空格符号了。

• 参数替代
  here document支持参数和命令替代，可以传递不同的参数给here document文本，从而获得不同的输出，比如：

  #!/bin/bash
  # Another 'cat' here document, using parameter substitution.
   
  # Try it with no command-line parameters,   ./scriptname
  # Try it with one command-line parameter,   ./scriptname Mortimer
  # Try it with one two-word quoted command-line parameter,
  #                           ./scriptname "Mortimer Jones"
   
  CMDLINEPARAM=1     #  Expect at least command-line parameter.
   
  if [ $# -ge $CMDLINEPARAM ]
  then
    NAME=$1          #  If more than one command-line param,
                     #+ then just take the first.
  else
    NAME="John Doe"  #  Default, if no command-line parameter.
  fi  
   
  RESPONDENT="the author of this fine script"  
   
   
  cat < <Endofmessage
   
  Hello, there, $NAME.
  Greetings to you, $NAME, from $RESPONDENT.
   
  # This comment shows up in the output (why?).
   
  Endofmessage
   
  # Note that the blank lines show up in the output.
  # So does the comment.
   
  exit

• 关闭参数替代
  给limit string加上转移或者引号，就可以进制here document的文本参数或者命令替代，这对于生成脚本甚至程序代码提供了帮助。

  #!/bin/bash
  #  A 'cat' here-document, but with parameter substitution disabled.
   
  NAME="John Doe"
  RESPONDENT="the author of this fine script"  
   
  cat < <'Endofmessage'
   
  Hello, there, $NAME.
  Greetings to you, $NAME, from $RESPONDENT.
   
  Endofmessage
   
  #   No parameter substitution when the "limit string" is quoted or escaped.
  #   Either of the following at the head of the here document would have
  #+  the same effect.
  #   cat <<"Endofmessage"
  #   cat <<\Endofmessage
   
  exit

  -----

  #!/bin/bash
  # generate-script.sh
  # Based on an idea by Albert Reiner.
   
  OUTFILE=generated.sh         # Name of the file to generate.
   
   
  # -----------------------------------------------------------
  # 'Here document containing the body of the generated script.
  (
  cat < <'EOF'
  #!/bin/bash
   
  echo "This is a generated shell script."
  #  Note that since we are inside a subshell,
  #+ we can't access variables in the "outside" script.
   
  echo "Generated file will be named: $OUTFILE"
  #  Above line will not work as normally expected
  #+ because parameter expansion has been disabled.
  #  Instead, the result is literal output.
   
  a=7
  b=3
   
  let "c = $a * $b"
  echo "c = $c"
   
  exit 0
  EOF
  ) > $OUTFILE
  # -----------------------------------------------------------
   
  #  Quoting the 'limit string' prevents variable expansion
  #+ within the body of the above 'here document.'
  #  This permits outputting literal strings in the output file.
   
  if [ -f "$OUTFILE" ]
  then
    chmod 755 $OUTFILE
    # Make the generated file executable.
  else
    echo "Problem in creating file: \"$OUTFILE\""
  fi
   
  #  This method can also be used for generating
  #+ C programs, Perl programs, Python programs, Makefiles,
  #+ and the like.
   
  exit 0

  我们也可以利用here document的输出来设置变量，这其实算是命令替代的一种迂回方式了。

  variable=$(cat < <SETVAR
  This variable
  runs over multiple lines.
  SETVAR)
   
  echo "$variable"

• 充当函数输入功能
  here document也能提供在同一个脚本里一个函数的输入能力。

  #!/bin/bash
  # here-function.sh
   
  GetPersonalData ()
  {
    read firstname
    read lastname
    read address
    read city 
    read state 
    read zipcode
  } # This certainly looks like an interactive function, but...
   
   
  # Supply input to the above function.
  GetPersonalData < <RECORD001
  Bozo
  Bozeman
  2726 Nondescript Dr.
  Baltimore
  MD
  21226
  RECORD001
   
   
  echo
  echo "$firstname $lastname"
  echo "$address"
  echo "$city, $state $zipcode"
  echo
   
  exit 0

  或者可以像下面这种匿名功能一样：

  #!/bin/bash
   
  : < <TESTVARIABLES
  ${HOSTNAME?}${USER?}${MAIL?}  # Print error message if one of the variables not set.
  TESTVARIABLES
   
  exit $?

• 注释代码块
  用来快速注释注释一段代码，一般用于调试目的，看下面这个比较长的例子：

  #!/bin/bash
  # commentblock.sh
   
  : < <COMMENTBLOCK
  echo "This line will not echo."
  This is a comment line missing the "#" prefix.
  This is another comment line missing the "#" prefix.
   
  &*@!!++=
  The above line will cause no error message,
  because the Bash interpreter will ignore it.
  COMMENTBLOCK
   
  echo "Exit value of above \"COMMENTBLOCK\" is $?."   # 0
  # No error shown.
  echo
   
   
  #  The above technique also comes in useful for commenting out
  #+ a block of working code for debugging purposes.
  #  This saves having to put a "#" at the beginning of each line,
  #+ then having to go back and delete each "#" later.
   
  echo "Just before commented-out code block."
  #  The lines of code between the double-dashed lines will not execute.
  #  ===================================================================
  : <<DEBUGXXX
  for file in *
  do
   cat "$file"
  done
  DEBUGXXX
  #  ===================================================================
  echo "Just after commented-out code block."
   
  exit 0
   
   
   
  ######################################################################
  #  Note, however, that if a bracketed variable is contained within
  #+ the commented-out code block,
  #+ then this could cause problems.
  #  for example:
   
   
  #/!/bin/bash
   
    : <<COMMENTBLOCK
    echo "This line will not echo."
    &*@!!++=
    ${foo_bar_bazz?}
    $(rm -rf /tmp/foobar/)
    $(touch my_build_directory/cups/Makefile)
  COMMENTBLOCK
   
   
  $ sh commented-bad.sh
  commented-bad.sh: line 3: foo_bar_bazz: parameter null or not set
   
  # The remedy for this is to strong-quote the 'COMMENTBLOCK' in line 49, above.
   
    : <<'COMMENTBLOCK'
   
  # Thank you, Kurt Pfeifle, for pointing this out.

• 自我文档化

  #!/bin/bash
  # self-document.sh: self-documenting script
  # Modification of "colm.sh".
   
  DOC_REQUEST=70
   
  if [ "$1" = "-h"  -o "$1" = "--help" ]     # Request help.
  then
    echo; echo "Usage: $0 [directory-name]"; echo
    sed --silent -e '/DOCUMENTATIONXX$/,/^DOCUMENTATIONXX$/p' "$0" |
    sed -e '/DOCUMENTATIONXX$/d'; exit $DOC_REQUEST; fi
   
   
  : < <DOCUMENTATIONXX
  List the statistics of a specified directory in tabular format.
  ---------------------------------------------------------------
  The command-line parameter gives the directory to be listed.
  If no directory specified or directory specified cannot be read,
  then list the current working directory.
   
  DOCUMENTATIONXX
   
  if [ -z "$1" -o ! -r "$1" ]
  then
    directory=.
  else
    directory="$1"
  fi  
   
  echo "Listing of "$directory":"; echo
  (printf "PERMISSIONS LINKS OWNER GROUP SIZE MONTH DAY HH:MM PROG-NAME\n" \
  ; ls -l "$directory" | sed 1d) | column -t
   
  exit 0

  当然以上看上去很复杂的脚本，其实用cat也能实现

  DOC_REQUEST=70
   
  if [ "$1" = "-h"  -o "$1" = "--help" ]     # Request help.
  then                                       # Use a "cat script" . . .
    cat < <DOCUMENTATIONXX
  List the statistics of a specified directory in tabular format.
  ---------------------------------------------------------------
  The command-line parameter gives the directory to be listed.
  If no directory specified or directory specified cannot be read,
  then list the current working directory.
   
  DOCUMENTATIONXX
  exit $DOC_REQUEST
  fi

更详细的例子，可以参考下面的链接：

http://www.heybrain.com/notheal/article/1138.html

我这里是用shell实现了，其实用C实现应该是最好的，毕竟算法的东西，C还是要快很多，我本是打算用C的，结果发现我都忘记得差不多了，连最简单的申明数组并初始化都忘记了，于是只要用效率比较低的shell，不过在做一些匹配和校验的时候，感觉比C要方便一些，不多说了，给代码

#!/bin/bash
#Description: Convert your 15bit old ID card into 18bit ID Card
#Author: mlsx mlsx.xplore(at) gmail.com
#Blog: http://mlsx.xplore.cn

crc=( 1 0 X 9 8 7 6 5 4 3 2 ) #CRC bit
weight=( 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 ) #weight factor
oldcard=${1:-123}
while true
do
  echo $oldcard |egrep -q "^[0-9]{15}$"
  [ $? -eq 0 ] && break
  echo -n "Pls hit your 15bit old ID card:"
  read oldcard
done

#insert two number "19" after sixth
tmpcard="`echo ${oldcard:0:6}`19`echo ${oldcard:6}`"

#split tmpcard into single digtial
y=0
for i in `echo {0..16}`
do
  a=${tmpcard:$i:1}
  (( y += $a * ${weight[$i]} ))
done

crcindex=`expr $y % 11`

echo "Your New 18bit ID Card is : ${tmpcard}${crc[$crcindex]}"

exit 0

一个实际的例子如下：

$ idcard.sh 340524800101001
Your New 18bit ID Card is : 34052419800101001X

• Ctl-A 将光标移到行首
• Ctl-B 退格键（但是我在ubuntu 9.10 bash 3.2.48上测试却是向前移动光标，并不删除该字符）
• Ctl-C 中断. 中断一个前台任务
• Ctl-D 从当前shell退出（类似exit)EOF (end-of-file). 它也能中断在stdin的输入。

  当在一个终端(console)或者虚拟终端(比如xterm)里敲键盘时，ctl-D 会删除当前光标下的字符.如果当前没有任何字符了，则 Ctl-D 表示从当前会话退出，如果时xterm之类的窗口，则会关闭当前窗口。

• Ctl-E 移动光标到行末
• Ctl-F 光标朝前移动一个字符位置
• Ctl-G 响铃(BEL).在一些老式的电传(teletype)终端里，它可能真的会导致电话铃响起，而在xterm之类的终端里，只是发出一个声响。
• Ctl-H 相当于退格键

  #!/bin/bash
  # Embedding Ctl-H in a string.
   
  a="^H^H"                  # Two Ctl-H's -- backspaces
                            # ctl-V ctl-H, using vi/vim
  echo "abcdef"             # abcdef
  echo
  echo -n "abcdef$a "       # abcd f
  #  Space at end  ^              ^  Backspaces twice.
  echo
  echo -n "abcdef$a"        # abcdef
  #  No space at end               ^ Doesn't backspace (why?).
                            # Results may not be quite as expected.
  echo; echo
   
  # Constantin Hagemeier suggests trying:
  # a=$'\010\010'
  # a=$'\b\b'
  # a=$'\x08\x08'
  # But, this does not change the results.

• Ctl-I 水平tab键.
• Ctl-J 新行 (换行符).脚本里，也可能当八进制’\012′或十六进制符号’\x0a’解释。
• Ctl-K 垂直tab当在console或者xterm窗口里键入文本时, Ctl-K 表示删除从当前光标到行末的字符。在脚本里, Ctl-K 的行为表现就不同的，具体的可以看下面 Lee Lee Maschmeyer的例子。
• Ctl-L 换页 (终端清屏)。在终端里，其效果和clear命令类似(区别在于当前光标所在的行并不会清除) 。发送到打印机的话，Ctl-L 导致提前结束纸张。
• Ctl-M 回车.

  #!/bin/bash
  # Thank you, Lee Maschmeyer, for this example.
   
  read -n 1 -s -p \
  $'Control-M leaves cursor at beginning of this line. Press Enter. \x0d'
             # Of course, '0d' is the hex equivalent of Control-M.
  echo >&2   #  The '-s' makes anything typed silent,
             #+ so it is necessary to go to new line explicitly.
   
  read -n 1 -s -p $'Control-J leaves cursor on next line. \x0a'
             #  '0a' is the hex equivalent of Control-J, linefeed.
  echo >&2
   
  ###
   
  read -n 1 -s -p $'And Control-K\x0bgoes straight down.'
  echo >&2   #  Control-K is vertical tab.
   
  # A better example of the effect of a vertical tab is:
   
  var=$'\x0aThis is the bottom line\x0bThis is the top line\x0a'
  echo "$var"
  #  This works the same way as the above example. However:
  echo "$var" | col
  #  This causes the right end of the line to be higher than the left end.
  #  It also explains why we started and ended with a line feed --
  #+ to avoid a garbled screen.
   
  # As Lee Maschmeyer explains:
  # --------------------------
  #  In the [first vertical tab example] . . . the vertical tab
  #+ makes the printing go straight down without a carriage return.
  #  This is true only on devices, such as the Linux console,
  #+ that can't go "backward."
  #  The real purpose of VT is to go straight UP, not down.
  #  It can be used to print superscripts on a printer.
  #  The col utility can be used to emulate the proper behavior of VT.
   
  exit 0

• Ctl-N 从history指令缓冲里删除一行可重新调用的文本
• Ctl-O 发出一个新行
• Ctl-P 重新调用history指令缓冲区调用最后一条指令
• Ctl-Q 恢复(XON)恢复终端的标准输入(stdin)
• Ctl-R 向后搜索history指令缓冲文本
• Ctl-S 暂停 (XOFF).冻结终端的标准输入(用ctl-Q来恢复)
• Ctl-T 将当前光标位置的字符和光标前的字符进行位置交换
• Ctl-U 删除从行首到当前光标位置的字符(不包括当前光标位置的字符).在默写设置下, Ctl-U 删除整行，而不管光标位置
• Ctl-V 输入文本的时候， Ctl-V 允许插入控制字符，下面例子的两条指令效果是相同的

  echo -e '\x0a'
  echo

  Ctl-V 主要在文本编辑器里起作用

• Ctl-W 在终端(console)或者类似xterm窗口里输入文本时， Ctl-W 删除从当前光标位置到之前的第一个空格之间的字符。在某些设置下， Ctl-W 向后删除到第一个非字母数字字符
• Ctl-Z 暂停前台任务

#!/bin/bash
 
# Test an IP address for validity:
# Usage:
#      valid_ip IP_ADDRESS
#      if [[ $? -eq 0 ]]; then echo good; else echo bad; fi
#   OR
#      if valid_ip IP_ADDRESS; then echo good; else echo bad; fi
#
function valid_ip()
{
local  ip=$1
local  stat=1
 
if [[ $ip =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
OIFS=$IFS
IFS='.'
ip=($ip)
IFS=$OIFS
[[ ${ip[0]} -le 255 && ${ip[1]} -le 255 \
&& ${ip[2]} -le 255 && ${ip[3]} -le 255 ]]
stat=$?
fi
return $stat
}
 
# If run directly, execute some tests.
if [[ "$(basename $0 .sh)" == 'valid_ip' ]]; then
ips='
4.2.2.2
a.b.c.d
192.168.1.1
0.0.0.0
255.255.255.255
255.255.255.256
192.168.0.1
192.168.0
1234.123.123.123
'
for ip in $ips
do
if valid_ip $ip; then stat='good'; else stat='bad'; fi
printf "%-20s: %s\n" "$ip" "$stat"
done
fi

测试：

# sh valid_ip.sh
4.2.2.2             : good
a.b.c.d             : bad
192.168.1.1         : good
0.0.0.0             : good
255.255.255.255     : good
255.255.255.256     : bad
192.168.0.1         : good
192.168.0           : bad
1234.123.123.123    : bad

接收自变量
我们使用环境变量 “$1″来引用第一个命令行自变量。类似地，可以使用 “$2″、”$3″等来引用传递给脚本的第二和第三个自变量。这里有一个例子：

#!/usr/bin/env bash

echo name of script is $0
echo first argument is $1
echo second argument is $2
echo seventeenth argument is $17
echo number of arguments is $#

除以下两个细节之外，此例无需说明。第一，”$0″将扩展成从命令行调用的脚本名称，”$#”将扩展成传递给脚本的自变量数目。试验以上脚本，通过传递不同类型的命令行自变量来了解其工作原理。

有时需要一次引用所有命令行自变量。针对这种用途，bash实现了变量 “$@”，它扩展成所有用空格分开的命令行参数。在本文稍后的”for” 循环部分中，您将看到使用该变量的例子。

Bash 编程结构
如果您曾用过如 C、Pascal、Python 或 Perl那样的过程语言编程，则一定熟悉 “if” 语句和 “for”循环那样的标准编程结构。对于这些标准结构的大多数，Bash有自己的版本。在下几节中，将介绍几种 bash结构，并演示这些结构和您已经熟悉的其它编程语言中结构的差异。如果以前编程不多，也不必担心。我提供了足够的信息和示例，使您可以跟上本文的进度。

方便的条件语句
如果您曾用 C编写过与文件相关的代码，则应该知道：要比较特定文件是否比另一个文件新需要大量工作。那是因为C 没有任何内置语法来进行这种比较，必须使用两个 stat() 调用和两个stat 结构来进行手工比较。相反，bash内置了标准文件比较运算符，因此，确定“/tmp/myfile是否可读”与查看“$myvar 是否大于 4”一样容易。

下表列出最常用的 bash比较运算符。同时还有如何正确使用每一选项的示例。示例要跟在 “if”之后。例如：

 if [ -z "$myvar" ]then     echo "myvar is not defined"fi

有时，有几种不同方法来进行特定比较。例如，以下两个代码段的功能相同：

 if [ "$myvar" -eq 3 ]then      echo "myvar equals 3"fi

 if [ "$myvar" = "3" ]then      echo "myvar equals 3"fi

上面两个比较执行相同的功能，但是第一个使用算术比较运算符，而第二个使用字符串比较运算符。

字符串比较说明
大多数时候，虽然可以不使用括起字符串和字符串变量的双引号，但这并不是好主意。为什么呢？因为如果环境变量中恰巧有一个空格或制表键，bash将无法分辨，从而无法正常工作。这里有一个错误的比较示例：

 if [ $myvar = "foo bar oni" ]then      echo "yes"fi

在上例中，如果 myvar 等于”foo”，则代码将按预想工作，不进行打印。但是，如果 myvar 等于 “foobar oni”，则代码将因以下错误失败：

 [: too many arguments

在这种情况下，"$myvar"（等于 "foo bar oni"）中的空格迷惑了bash。bash 扩展 "$myvar" 之后，代码如下：

 [ foo bar oni = "foo bar oni" ]

因为环境变量没放在双引号中，所以 bash认为方括号中的自变量过多。可以用双引号将字符串自变量括起来消除该问题。请记住，如果养成将所有字符串自变量用双引号括起的习惯，将除去很多类似的编程错误。”foobar oni” 比较应该写成：

 if [ "$myvar" = "foo bar oni" ]then      echo "yes"fi

以上代码将按预想工作，而不会有任何令人不快的意外出现。

循环结构：”for”
好了，已经讲了条件语句，下面该探索 bash 循环结构了。我们将从标准的”for” 循环开始。这里有一个简单的例子：

 #!/usr/bin/env bash

 for x in one two three four do     echo number $x done

 输出：

 number one number two  number three  number four

发生了什么？”for” 循环中的 “for x” 部分定义了一个名为 “$x”的新环境变量（也称为循环控制变量），它的值被依次设置为”one”、”two”、”three” 和”four”。每一次赋值之后，执行一次循环体（”do” 和 “done”之间的代码）。在循环体内，象其它环境变量一样，使用标准的变量扩展语法来引用循环控制变量”$x”。还要注意，”for” 循环总是接收 “in”语句之后的某种类型的字列表。在本例中，指定了四个英语单词，但是字列表也可以引用磁盘上的文件，甚至文件通配符。看看下面的例子，该例演示如何使用标准shell 通配符：

 #!/usr/bin/env bash

 for myfile in /etc/r* do     if [ -d "$myfile" ] then        echo "$myfile (dir)"else       echo "$myfile"fi done

 输出：

 /etc/rc.d (dir) /etc/resolv.conf /etc/resolv.conf~ /etc/rpc                  

以上代码列出在 /etc 中每个以 “r” 开头的文件。要做到这点，bash在执行循环之前首先取得通配符 /etc/r*，然后扩展它，用字符串/etc/rc.d /etc/resolv.conf /etc/resolv.conf~ /etc/rpc替换。一旦进入循环，根据 myfile 是否为目录，”-d”条件运算符用来执行两个不同操作。如果是目录，则将 “(dir)”附加到输出行。

还可以在字列表中使用多个通配符、甚至是环境变量：

 for x in /etc/r??? /var/lo* /home/drobbins/mystuff/* /tmp/${MYPATH}/* do     cp $x /mnt/mydir done

Bash将在所有正确位置上执行通配符和环境变量扩展，并可能创建一个非常长的字列表。

虽然所有通配符扩展示例使用了绝对路径，但也可以使用相对路径，如下所示：

 for x in ../* mystuff/* do     echo $x is a silly file done

在上例中，bash相对于当前工作目录执行通配符扩展，就象在命令行中使用相对路径一样。研究一下通配符扩展。您将注意到，如果在通配符中使用绝对路径，bash将通配符扩展成一个绝对路径列表。否则，bash将在后面的字列表中使用相对路径。如果只引用当前工作目录中的文件（例如，如果输入”for x in*”），则产生的文件列表将没有路径信息的前缀。请记住，可以使用”basename” 可执行程序来除去前面的路径信息，如下所示：

 for x in /var/log/* do     echo `basename $x` is a file living in /var/log done

当然，在脚本的命令行自变量上执行循环通常很方便。这里有一个如何使用本文开始提到的”$@” 变量的例子：

 #!/usr/bin/env bash

 for thing in "$@" do     echo you typed ${thing}. done

 输出：

 $ allargs hello there you silly you typed hello. you typed there. you typed you. you typed silly.

Shell 算术
在学习另一类型的循环结构之前，最好先熟悉如何执行 shell算术。是的，确实如此：可以使用 shell结构来执行简单的整数运算。只需将特定的算术表达式用 “$((” 和 “))”括起，bash 就可以计算表达式。这里有一些例子：

 $ echo $(( 100 / 3 )) 33 $ myvar="56" $ echo $(( $myvar + 12 )) 68 $ echo $(( $myvar - $myvar ))0 $ myvar=$(( $myvar + 1 ))$ echo $myvar 57

您已经熟悉如何执行数学操作，现在该介绍其它两种 bash 循环结构”while” 和 “until” 了。

更多的循环结构：”while” 和”until”
只要特定条件为真，”while” 语句就会执行，其格式如下：

 while [ condition ] do     statements done

通常使用 “While” 语句来循环一定次数，比如，下例将循环 10次：

 myvar=0 while [ $myvar -ne 10 ] do     echo $myvar     myvar=$(( $myvar + 1 )) done

可以看到，上例使用了算术表达式来使条件最终为假，并导致循环终止。

“Until” 语句提供了与 “while”语句相反的功能：只要特定条件为假，它们就重复。下面是一个与前面的”while” 循环具有同等功能的 “until” 循环：

 myvar=0 until [ $myvar -eq 10 ] do     echo $myvar     myvar=$(( $myvar + 1 )) done

Case 语句
Case 语句是另一种便利的条件结构。这里有一个示例片段：

 case "${x##*.}" in      gz)            gzunpack ${SROOT}/${x}            ;;      bz2)            bz2unpack ${SROOT}/${x}            ;;      *)            echo "Archive format not recognized."            exit            ;; esac                                      

在上例中，bash 首先扩展 “${x##*.}”。在代码中，”$x”是文件的名称，”${x##.*}”除去文件中最后句点后文本之外的所有文本。然后，bash 将产生的字符串与”)” 左边列出的值做比较。在本例中，”${x##.*}” 先与 “gz” 比较，然后是”bz2″，最后是 “*”。如果 “${x##.*}”与这些字符串或模式中的任何一个匹配，则执行紧接 “)” 之后的行，直到”;;” 为止，然后 bash 继续执行结束符 “esac”之后的行。如果不匹配任何模式或字符串，则不执行任何代码行，在这个特殊的代码片段中，至少要执行一个代码块，因为任何不与”gz” 或 “bz2″ 匹配的字符串都将与 “*” 模式匹配。

函数与名称空间
在 bash 中，甚至可以定义与其它过程语言（如 Pascal 和C）类似的函数。在 bash中，函数甚至可以使用与脚本接收命令行自变量类似的方式来接收自变量。让我们看一下样本函数定义，然后再从那里继续：

 tarview() {     echo -n "Displaying contents of $1 "     if [ ${1##*.} = tar ]then          echo "(uncompressed tar)"         tar tvf $1     elif [ ${1##*.} = gz ]then          echo "(gzip-compressed tar)"         tar tzvf $1     elif [ ${1##*.} = bz2 ]then          echo "(bzip2-compressed tar)"         cat $1 | bzip2 -d | tar tvf -fi }

我们在上面定义了一个名为 “tarview”的函数，它接收一个自变量，即某种类型的 tar文件。在执行该函数时，它确定自变量是哪种 tar文件类型（未压缩的、gzip 压缩的或 bzip2压缩的），打印一行信息性消息，然后显示 tar文件的内容。应该如下调用上面的函数（在输入、粘贴或找到该函数后，从脚本或命令行调用它）：

 $ tarview shorten.tar.gz Displaying contents of shorten.tar.gz (gzip-compressed tar) drwxr-xr-x ajr/abbot         0 1999-02-27 16:17 shorten-2.3a/ -rw-r--r-- ajr/abbot      1143 1997-09-04 04:06 shorten-2.3a/Makefile -rw-r--r-- ajr/abbot      1199 1996-02-04 12:24 shorten-2.3a/INSTALL -rw-r--r-- ajr/abbot       839 1996-05-29 00:19 shorten-2.3a/LICENSE ....  

如您所见，可以使用与引用命令行自变量同样的机制来在函数定义内部引用自变量。另外，将把”$#” 宏扩展成包含自变量的数目。唯一可能不完全相同的是变量”$0″，它将扩展成字符串 “bash”（如果从 shell交互运行函数）或调用函数的脚本名称。

名称空间
经常需要在函数中创建环境变量。虽然有可能，但是还有一个技术细节应该了解。在大多数编译语言（如C）中，当在函数内部创建变量时，变量被放置在单独的局部名称空间中。因此，如果在C 中定义一个名为 myfunction 的函数，并在该函数中定义一个名为 “x”的自变量，则任何名为 “x”的全局变量（函数之外的变量）将不受它的印象，从而消除了负作用。

在 C 中是这样，但在 bash 中却不是。在 bash中，每当在函数内部创建环境变量，就将其添加到全局名称空间。这意味着，该变量将重写函数之外的全局变量，并在函数退出之后继续存在：

 #!/usr/bin/env bash

 myvar="hello"

 myfunc() {

     myvar="one two three"     for x in $myvar     do         echo $x     done }

 myfunc

 echo $myvar $x

运行此脚本时，它将输出 “one two threethree”，这显示了在函数中定义的 “$myvar” 如何影响全局变量”$myvar”，以及循环控制变量 “$x” 如何在函数退出之后继续存在（如果”$x” 全局变量存在，也将受到影响）。

在这个简单的例子中，很容易找到该错误，并通过使用其它变量名来改正错误。但这不是正确的方法，解决此问题的最好方法是通过使用”local” 命令，在一开始就预防影响全局变量的可能性。当使用 “local”在函数内部创建变量时，将把它们放在局部名称空间中，并且不会影响任何全局变量。这里演示了如何实现上述代码，以便不重写全局变量：

 #!/usr/bin/env bash

 myvar="hello"

 myfunc() {     local x     local myvar="one two three"     for x in $myvar     do         echo $x     done }

 myfunc

 echo $myvar $x

此函数将输出 “hello” — 不重写全局变量 “$myvar”，”$x” 在 myfunc之外不继续存在。在函数的第一行，我们创建了以后要使用的局部变量x，而在第二个例子 (local myvar=”one two three”")中，我们创建了局部变量myvar，同时为其赋值。在将循环控制变量定义为局部变量时，使用第一种形式很方便，因为不允许说：”forlocal x in$myvar”。此函数不影响任何全局变量，鼓励您用这种方式设计所有的函数。只有在明确希望要修改全局变量时，才不