不断攀登的梦想

我依然不放弃成为一名伟大黑客的梦想

Bash Shell编程

来源: http://www.cnblogs.com/stephen-liu74/archive/2011/12/19/2265416.html


    1.  读取用户变量:

    read命令是用于从终端或者文件中读取输入的内建命令,read命令读取整行输入,每行末尾的换行符不被读入。在read命令后面,如果没有指定变量名,读取的数据将被自动赋值给特定的变量REPLY。下面的列表给出了read命令的常用方式:
命令格式 描述
read answer 从标准输入读取输入并赋值给变量answer。
read first last 从标准输入读取输入到第一个空格或者回车,将输入的第一个单词放到变量first中,并将该行其他的输入放在变量last中。
read 从标准输入读取一行并赋值给特定变量REPLY。
read -a arrayname 把单词清单读入arrayname的数组里。
read -p prompt 打印提示,等待输入,并将输入存储在REPLY中。
read -r line 允许输入包含反斜杠。


    见下面的示例(绿色高亮部分的文本为控制台手工输入信息):
    /> read answer        #等待读取输入,直到回车后表示输入完毕,并将输入赋值给变量answer
    Hello                       #控制台输入Hello
    /> echo $answer      #打印变量
    Hello

    #等待一组输入,每个单词之间使用空格隔开,直到回车结束,并分别将单词依次赋值给这三个读入变量。
    /> read one two three
    1 2 3                      #在控制台输入1 2 3,它们之间用空格隔开。
    /> echo "one = $one, two = $two, three = $three"
    one = 1, two = 2, three = 3

    /> read                  #等待控制台输入,并将结果赋值给特定内置变量REPLY。
    This is REPLY          #在控制台输入该行。
    /> echo $REPLY      #打印输出特定内置变量REPLY,以确认是否被正确赋值。
    This is REPLY

    /> read -p "Enter your name: "    #输出"Enter your name: "文本提示,同时等待输入,并将结果赋值给REPLY。
    Enter you name:
stephen            #在提示文本之后输入stephen
    /> echo $REPLY
    stephen

    #等待控制台输入,并将输入信息视为数组,赋值给数组变量friends,输入信息用空格隔开数组的每个元素
    /> read -a friends
    Tim Tom Helen
    /> echo "I have ${#friends} friends"
    I have 3 friends
    /> echo "They are ${friends[0]}, ${friends[1]} and ${friends[2]}."
    They are Tim, Tom and Helen.

   2.  状态判断:
    test是Shell中提供的内置命令,主要用于状态的检验,如果结果为0,表示成功,否则表示失败。见如下示例:
    /> name=stephen
    /> test $name != stephen
    /> echo $?

    1
    需要注意的是test命令不支持Shell中提供的各种通配符,如:
    /> test $name = [Ss]tephen
    /> echo $?

    1
    test命令还可以中括号予以替换,其语义保持不变,如:
    /> [ $name = stephen ]
    /> echo $?
    0   
    在Shell中还提供了另外一种用于状态判断的方式:[[ expr ]],和test不同的是,该方式中的表达式支持通配符,如:
    /> name=stephen
    /> [[ $name == [Ss]tephen ]]
    /> echo $?

    0
    #在[[ expression ]]中,expression可以包含&&(逻辑与)和||(逻辑或)。
    /> [[ $name == [Ss]tephen && $friend == "Jose" ]]
    /> echo $?

    1
    /> shopt -s extglob   #打开Shell的扩展匹配模式。
    /> name=Tommy
    # "[Tt]o+(m)y"的含义为,以T或t开头,后面跟着一个o,再跟着一个或者多个m,最后以一个y结尾。
    /> [[ $name == [Tt]o+(m)y ]]
    /> echo $?

    0
    在Shell中还提供了let命令的判断方式: (( expr )),该方式的expr部分,和C语言提供的表达式规则一致,如:
    /> x=2
    /> y=3
    /> (( x > 2 ))
    /> echo $?

    1
    /> (( x < 2 ))
    /> echo $?

    0  
    /> (( x == 2 && y == 3 ))
    /> echo $?

    0
    /> (( x > 2 || y < 3 ))
    /> echo $?

    1

    下面的表格是test命令支持的操作符:

判断操作符 判断为真的条件
字符串判断
[ stringA=stringB ] stringA等于stringB
[ stringA==stringB ] stringA等于stringB
[ stringA!=stringB ] stringA不等于stringB
[ string ] string不为空
[ -z string ] string长度为0
[ -n string ] string长度不为0
逻辑判断
[ stringA -a stringB ] stringA和stringB都是真
[ stringA -o stringB ] stringA或stringB是真
[ !string ] string不为真
逻辑判断(复合判断)
[[ pattern1 && pattern2 ]] pattern1和pattern2都是真
[[ pattern1 || pattern2 ] pattern1或pattern2是真
[[ !pattern ]] pattern不为真
整数判断
[ intA -eq intB ] intA等于intB
[ intA -ne intB ] intA不等于intB
[ intA -gt intB ] intA大于intB
[ intA -ge intB ] intA大于等于intB
[ intA -lt intB ] intA小于intB
[ intA -le intB ] intA小于等于intB
文件判断中的二进制操作
[ fileA -nt fileB ] fileA比fileB新
[ fileA -ot fileB ] fileA比fileB旧
[ fileA -ef fileB ] fileA和fileB有相同的设备或者inode值
文件检验
[ -d $file ] or [[ -d $file ]] file为目录且存在时为真
[ -e $file ] or [[ -e $file ]] file为文件且存在时为真
[ -f $file ] or [[ -f $file ]] file为非目录普通文件存在时为真
[ -s $file ] or [[ -s $file ]] file文件存在, 且长度不为0时为真
[ -L $file ] or [[ -L $file ]] file为链接符且存在时为真
[ -r $file ] or [[ -r $file ]] file文件存在且可读时为真
[ -w $file ] or [[ -w $file ]] file文件存在且可写时为真
[ -x $file ] or [[ -x $file ]] file文件存在且可执行时为真

    注:在逻辑判断(复合判读中),pattern可以包含元字符,在字符串的判断中,pattern2必须被包含在引号中。

    let命令支持的操作符和C语言中支持的操作符完全相同,如:
    +,-,*,/,%            加,减,乘,除,去模
    >>,<<                右移和左移
    >=,<=,==,!=      大于等于,小于等于,等于,不等于
    &,|,^                  按位与,或,非
    &&,||,!                逻辑与,逻辑或和取反
    还有其含义和C语言等同的快捷操作符,如
=,*=,/=,%=,+=,-=,<<=,>>=,&=,|=,^=。

    3.  流程控制语句:
    if语句格式如下:

    #if语句的后面是Shell命令,如果该命令执行成功返回0,则执行then后面的命令。
    if command        
    then
        command
        command
    fi
    #用test命令测试其后面expression的结果,如果为真,则执行then后面的命令。
    if test expression
    then
        command
    fi
    #下面的格式和test expression等同
    if [ string/numeric expression ]
    then
        command
    fi
    #下面的两种格式也可以用于判断语句的条件表达式,而且它们也是目前比较常用的两种。
    if [[ string expression ]]
    then
        command
    fi

    if (( numeric expression ))           #let表达式
    then
        command
    fi
    见如下示例:
    /> cat > test1.sh                       #从命令行直接编辑test1.sh文件。
    echo -e "Are you OK(y/n)? \c"
    read answer

    #这里的$answer变量必须要用双引号扩住,否则判断将失败。当变量$answer等于y或Y时,支持下面的echo命令。
    if [ "$answer" = y -o "$answer" = Y ]   
    then
        echo "Glad to see it."
    fi
    CTRL+D  
    /> . ./test1.sh
    Are you OK(y/n)?
y
    Glad to see it.
    上面的判断还可以替换为:
    /> cat > test2.sh
    echo -e "Are you OK(y/n or Maybe)? \c"
    read answer

    # [[ ]]复合命令操作符允许其中的表达式包含元字符,这里输入以y或Y开头的任意单词,或Maybe都执行then后面的echo。
    if [[ $answer == [yY]* || $answer = Maybe ]]  
    then
        echo "Glad to hear it.
    fi

    CTRL+D
    /> . ./test2.sh
    Are you OK(y/n or Maybe)?
yes
    Glad to hear it.
    下面的例子将使用Shell中的扩展通配模式。
    /> shopt -s extglob        #打开该扩展模式
    /> answer="not really"
    /> if [[ $answer = [Nn]o?( way |t really) ]]
    > then
    >    echo "I am sorry."
    > fi

    I am sorry.
    对于本示例中的扩展通配符,这里需要给出一个具体的解释。[Nn]o匹配No或no,?( way|t really)则表示0个或1个( way或t really),因此answer变量匹配的字符串为No、no、Not really、not really、No way、no way。
    下面的示例使用了let命令操作符,如:
    /> cat > test3.sh
    if (( $# != 2 ))    
                #等同于 [ $# -ne 2 ]
    then
        echo "Usage: $0 arg1 arg2" 1>&2
        exit 1      
                  #exit退出值为0-255之间,只有0表示成功。
    fi
    if (( $1 < 0 || $1 > 30 )) 
     #等同于 [ $1 -lt 0 -o $1 -gt 30 ]
    then
        echo "arg1 is out of range."
        exit 2
    fi
    if (( $2 <= 20 ))     
             #等同于 [ $2 -le 20 ]
    then
        echo "arg2 is out of range."
    fi

    CTRL+D
    /> sh ./test3.sh
    Usage: ./test3.sh arg1 arg2
    /> echo $?                          #Shell脚本的退出值为exit的参数值。
    1
    /> sh ./test3.sh 40 30
    arg1 is out of range.
    /> echo $?
    2
    下面的示例为如何在if的条件表达式中检验空变量:
    /> cat > test4.sh
    if [ "$name" = "" ]   
             #双引号就表示空字符串。
    then
        echo "name is null."
    fi
    CTRL+D
    /> . ./test4.sh
    name is null.

    if/elif/else语句的使用方式和if语句极为相似,相信有编程经验的人都不会陌生,这里就不在赘述了,其格式如下:
    if command
    then
        command
    elif command
    then
        command
    else
        command
    fi
    见如下示例脚本:
    /> cat > test5.sh
    echo -e "How old are you? \c"
    read age
    if [ $age -lt 0 -o $age -gt 120 ]  
              #等同于 (( age < 0 || age > 120 ))
    then
        echo "You are so old."
    elif [ $age -ge 0 -a $age -le 12 ]    
           #等同于 (( age >= 0 && age <= 12 ))
    then
        echo "You are child."
    elif [ $age -ge 13 -a $age -le 19 ]
             #等同于 (( age >= 13 && age <= 19 ))
    then
        echo "You are 13--19 years old."
    elif [ $age -ge 20 -a $age -le 29 ]  
          #等同于 (( age >= 20 && age <= 29 ))
    then
        echo "You are 20--29 years old."
    elif [ $age -ge 30 -a $age -le 39 ]             #等同于 (( age >= 30 && age <= 39 ))
    then
        echo "You are 30--39 years old."
    else
        echo "You are above 40."
    fi

    CTRL+D
    /> . ./test5.sh
    How old are you?
50
    You are above 40.

    case语句格式如下:
    case variable in
    value1)
        command
        ;;            #相同于C语言中case语句内的break。
    value2)
        command
        ;;
    *)                #相同于C语言中switch语句内的default
       command
        ;;
    esac
    见如下示例脚本:
    /> cat > test6.sh
    #!/bin/sh
    echo -n "Choose a color: "
    read color
    case "$color" in
    [Bb]l??)
        echo "you select blue color."
        ;;
    [Gg]ree*)
        echo "you select green color."
        ;;
    red|orange)
        echo "you select red or orange."
        ;;
    *)
        echo "you select other color."
        ;;
    esac
    echo "Out of case command."
    /> . ./test6.sh

    Choose a color:
green
    you select green color.
    Out of case command.

   4.  循环语句:
    Bash Shell中主要提供了三种循环方式:
for、while和until
    for循环声明格式:
    for variable in word_list
    do
        command
    done
    见如下示例脚本:
    /> cat > test7.sh
    for score in math english physics chemist   #for将循环读取in后面的单词列表,类似于Java的for-each。
    do
        echo "score = $score"
    done
    echo "out of for loop"

    CTRL+D
    /> . ./test7.sh
    score = math
    score = english
    score = physics
    score = chemist
    out of for loop

    /> cat > mylist   #构造数据文件
    tom
    patty
    ann
    jake

    CTRL+D
    /> cat > test8.sh
    #!/bin/sh
    for person in $(cat mylist)   
              #for将循环读取cat mylist命令的执行结果。
    do
        echo "person = $person"
    done
    echo "out of for loop."
    CTRL+D
    /> . ./test8.sh

    person = tom
    person = patty
    person = ann
    person = jake
    out of for loop.

    /> cat > test9.sh
    for file in test[1-8].sh 
                       #for将读取test1-test8,后缀为.sh的文件
    do
        if [ -f $file ]     
                         #判断文件在当前目录是否存在。
        then
            echo "$file exists."
        fi
    done

    CTRL+D
    /> . ./test9.sh
    test2.sh exists.
    test3.sh exists.
    test4.sh exists.
    test5.sh exists.
    test6.sh exists.
    test7.sh exists.
    test8.sh exists.

    /> cat > test10.sh
    for name in $*                                  #读取脚本的命令行参数数组,还可以写成for name的简化形式。
    do
        echo "Hi, $name"
    done

    CTRL+D
    /> . ./test10.sh stephen ann
    Hi, stephen
    Hi, ann

    while循环声明格式:
    while command  #如果command命令的执行结果为0,或条件判断为真时,执行循环体内的命令。
    do
        command
    done
    见如下示例脚本:
    /> cat > test1.sh  
    num=0
    while (( num < 10 ))
               #等同于 [ $num -lt 10 ]
    do
        echo -n "$num "
        let num+=1
    done
    echo -e "\nHere's out of loop."

    CTRL+D
    /> . ./test1.sh
    0 1 2 3 4 5 6 7 8 9
    Here's out of loop.

    /> cat > test2.sh
    go=start
    echo Type q to quit.
    while [[ -n $go ]] 
                    #等同于[ -n "$go" ],如使用该风格,$go需要被双引号括起。
    do
        echo -n How are you.
        read word
        if [[ $word == [Qq] ]] 
     #等同于[ "$word" = Q -o "$word" = q ]
        then
            echo Bye.
            go=      
                 #将go变量的值置空。
        fi
    done

    CTRL+D
    /> . ./test2.sh
    How are you. Hi
    How are you. q
    Bye.

    until循环声明格式:
    until command                         #其判断条件和while正好相反,即command返回非0,或条件为假时执行循环体内的命令。
    do
        command
    done
    见如下示例脚本:
    /> cat > test3.sh
    until who | grep stephen 
          #循环体内的命令将被执行,直到stephen登录,即grep命令的返回值为0时才退出循环。
    do
        sleep 1
        echo "Stephen still doesn't login."
    done

    CTRL+D

    shift命令声明格式:
shift [n]
    shift命令用来把脚本的位置参数列表向左移动指定的位数(n),如果shift没有参数,则将参数列表向左移动一位。一旦移位发生,被移出列表的参数就被永远删除了。通常在while循环中,shift用来读取列表中的参数变量。
    见如下示例脚本:
    /> set stephen ann sheryl mark #设置4个参数变量。
    /> shift                                    #向左移动参数列表一次,将stephen移出参数列表。
    /> echo $*
    ann sheryl mark
    /> shift 2                                 #继续向左移动两位,将sheryl和ann移出参数列表
    /> echo $*
    mark
    /> shift 2                                 #继续向左移动两位,由于参数列表中只有mark了,因此本次移动失败。
    /> echo $*
    mark

    /> cat > test4.sh
    while (( $# > 0 ))  
                 #等同于 [ $# -gt 0 ]
    do
        echo $*
        shift
    done

    CTRL+D
    /> . ./test4.sh a b c d e
    a b c d e
    b c d e
    c d e
    d e
    e        

    break命令声明格式:
break [n]
    和C语言不同的是,Shell中break命令携带一个参数,即可以指定退出循环的层数。如果没有指定,其行为和C语言一样,即退出最内层循环。如果指定循环的层数,则退出指定层数的循环体。如果有3层嵌套循环,其中最外层的为1,中间的为2,最里面的是3。
    见如下示例脚本:
    /> cat > test5.sh
    while true
    do
        echo -n "Are you ready to move on?"
        read answer
        if [[ $answer == [Yy] ]]
        then
            break
        else
            echo "Come on."
        fi
    done
    echo "Here we are."

    CTRL+D
    /> . ./test5.sh
    Are you ready to move on? y
    Here we are

    continue命令声明格式:
continue [n]
    和C语言不同的是,Shell中continue命令携带一个参数,即可以跳转到指定层级的循环顶部。如果没有指定,其行为和C语言一样,即跳转到最内层循环的顶部。如果指定循环的层数,则跳转到指定层级循环的顶部。如果有3层嵌套循环,其中最外层的为3,中间的为2,最里面的是1。
    /> cat  maillist                       #测试数据文件maillist的内容为以下信息。
    stephen
    ann
    sheryl
    mark

    /> cat > test6.sh
    for name in $(cat maillist)
    do
        if [[ $name == stephen ]]; then
            continue
        else
            echo "Hello, $name."
        fi
    done

    CTRL+D
    /> . ./test6.sh
    Hello, ann.
    Hello, sheryl.
    Hello, mark.

    I/O重新定向和子Shell:
    文件中的输入可以通过管道重新定向给一个循环,输出也可以通过管道重新定向给一个文件。Shell启动一个子Shell来处理I/O重新定向和管道。在循环终止时,循环内部定义的任何变量对于脚本的其他部分来说都是不看见的。
    /> cat > demodata                        #为下面的脚本构造册数数据
    abc
    def
    ghi
    CRTL+D
    /> cat > test7.sh
    if (( $# < 1 ))     
                           #如果脚本参数的数量小于1,则给出错误提示后退出。
    then
        echo "Usage: $0 filename " >&2
        exit 1
    fi
    count=1
    cat $1 | while read line
                   #参数一中的文件被cat命令输出后,通过管道逐行输出给while read line。
    do
        let $((count == 1)) && echo "Processing file $1..." > /dev/tty
  #该行的echo将输出到当前终端窗口。
        echo -e "$count\t$line"              #将输出行号和文件中该行的内容,中间用制表符隔开。
        let count+=1
    done > outfile                               #将while循环中所有的输出,除了>/dev/tty之外,其它的全部输出到outfile文件。
    CTRL+D
    /> . ./test7.sh demodata                #只有一行输出,其余的都输出到outfile中了。
    Processing file demodata...
    /> cat outfile
    1       abc
    2       def
    3       ghi

    /> cat > test8.sh
    for i in 9 7 2 3 5 4
    do
        echo $i
    done | sort -n  
                             #直接将echo的输出通过管道重定向sort命令。
    CTRL+D
    /> . ./test8.sh
    2
    3
    4
    5
    7
    9

    5.  IFS和循环:
    Shell的内部域分隔符可以是空格、制表符和换行符。它可以作为命令的分隔符用在例如read、set和for等命令中。如果在列表中使用不同的分隔符,用户可以自己定义这个符号。在修改之前将IFS原始符号的值保存在另外一个变量中,这样在需要的时候还可以还原。
    见如下示例脚本:
    /> cat > test9.sh
    names=Stephen:Ann:Sheryl:John
   #names变量包含的值用冒号分隔。
    oldifs=$IFS                                   #保留原有IFS到oldifs变量,便于后面的还原。
    IFS=":"                            
    for friends in $names  
                  #这是遍历以冒号分隔的names变量值。    
    do
        echo Hi $friends
    done
    IFS=$oldifs      
                            #将IFS还原为原有的值。
    set Jerry Tom Angela
    for classmates in $*    
                  #再以原有IFS的值变量参数列表。
    do
        echo Hello $classmates
    done

    CTRL+D
    /> . ./test9.sh
    Hi Stephen
    Hi Ann
    Hi Sheryl
    Hi John
    Hello Jerry
    Hello Tom
    Hello Angela

    6.  函数:
    Shell中函数的职能以及优势和C语言或其它开发语言基本相同,只是语法格式上的一些差异。下面是Shell中使用函数的一些基本规则:
    1) 函数在使用前必须定义。
    2) 函数在当前环境下运行,它和调用它的脚本共享变量,并通过位置参量传递参数。而该位置参量将仅限于该函数,不会影响到脚本的其它地方。
    3) 通过local函数可以在函数内建立本地变量,该变量在出了函数的作用域之后将不在有效。
    4) 函数中调用exit,也将退出整个脚本。
    5) 函数中的return命令返回函数中最后一个命令的退出状态或给定的参数值,该参数值的范围是0-256之间。如果没有return命令,函数将返回最后一个Shell的退出值。
    6) 如果函数保存在其它文件中,就必须通过source或dot命令把它们装入当前脚本。
    7) 函数可以递归。
    8) 将函数从Shell中清空需要执行:unset -f function_name。
    9) 将函数输出到子Shell需要执行:export -f function_name。
    10) 可以像捕捉Shell命令的返回值一样获取函数的返回值,如$(function_name)。
    Shell中函数的声明格式如下:
    function function_name { command; command; }
    见如下示例脚本:
    /> cat > test1.sh
    function increment() {      
     #定义函数increment。
        local sum                           #定义本地变量sum。
        let "sum=$1+1"    
        return $sum    
                  #返回值是sum的值。
    }
    echo -n "The num is "
    increment 5  
                       #increment函数调用。
    echo $?                                #输出increment函数的返回值。
    CTRL+D
    /> . ./test1.sh
    The num is 6

    7.  陷阱信号(trap):
    在Shell程序运行的时候,可能收到各种信号,有的来自于操作系统,有的来自于键盘,而该Shell在收到信号后就立刻终止运行。但是在有些时候,你可能并不希望在信号到达时,程序就立刻停止运行并退出。而是他能希望忽略这个信号而一直在运行,或者在退出前作一些清除操作。trap命令就允许你控制你的程序在收到信号以后的行为。
    其格式如下:
    trap 'command; command' signal-number
    trap 'command; command' signal-name
    trap signal-number  
    trap signal-name
    后面的两种形式主要用于信号复位,即恢复处理该信号的缺省行为。还需要说明的是,如果trap后面的命令是使用单引号括起来的,那么该命令只有在捕获到指定信号时才被执行。如果是双引号,则是在trap设置时就可以执行变量和命令替换了。
    下面是系统给出的信号数字和信号名称的对照表:
    1)SIGHUP 2)SIGINT 3)SIGQUIT 4)SIGILL 5)SIGTRAP 6)SIGABRT 7)SIGBUS 8)SIGFPE
    9)SIGKILL 10) SIGUSR1 11)SIGEGV 12)SIGUSR2 13)SIGPIPE 14)SIGALRM 15)SIGTERM 17)SIGCHLD
    18)SIGCONT 19)SIGSTOP ... ...
    见如下示例脚本:
    /> trap 'rm tmp*;exit 1' 1 2 15      #该命令表示在收到信号1、2和15时,该脚本将先执行rm tmp*,然后exit 1退出脚本。
    /> trap 2                                      #当收到信号2时,将恢复为以前的动作,即退出。
    /> trap " " 1 2                              #当收到信号1和2时,将忽略这两个信号。
    /> trap -                                      #表示恢复所有信号处理的原始值。
    /> trap 'trap 2' 2                           #在第一次收到信号2时,执行trap 2,这时将信号2的处理恢复为缺省模式。在收到信号2时,Shell程序退出。
    /> cat > test2.sh
    trap 'echo "Control+C will not terminate $0."' 2  
#捕获信号2,即在键盘上按CTRL+C。
    trap 'echo "Control+\ will not terminate $0."' 3   #捕获信号3,即在键盘上按CTRL+\。
    echo "Enter stop to quit shell."
    while true                 
                                       #无限循环。
    do
        echo -n "Go Go...."
        read
        if [[ $REPLY == [Ss]top ]]          
                 #直到输入stop或Stop才退出循环和脚本。
       then
            break
        fi
    done

    CTRL+D
    /> . ./test2.sh
    Enter stop to quit shell.
    Go Go....^CControl+C will not terminate -bash.
    ^\Control+\ will not terminate -bash.
    stop

    8.  用getopts处理命令行选项:

    这里的getopts命令和C语言中的getopt几乎是一致的,因为脚本的位置参量在有些时候是失效的,如ls -lrt等。这时候-ltr都会被保存在$1中,而我们实际需要的则是三个展开的选项,即-l、-r和-t。见如下带有getopts的示例脚本:
    /> cat > test3.sh
    #!/bin/sh
    while getopts xy options 
                          #x和y是合法的选项,并且将-x读入到变量options中,读入时会将x前面的横线去掉。
    do
        case $options in
        x) echo "you entered -x as an option" ;;       
        y) echo "you entered -y as an option" ;;
        esac
    done
    /> ./test3.sh -xy

    you entered -x as an option
    you entered -y as an option
    /> ./test3.sh -x
    you entered -x as an option
    /> ./test3.sh -b                                       #如果输入非法选项,getopts会把错误信息输出到标准错误。
    ./test3.sh: illegal option -- b
    /> ./test3.sh b                                        #该命令不会有执行结果,因为b的前面有没横线,因此是非法选项,将会导致getopts停止处理并退出。

    /> cat > test4.sh
    #!/bin/sh
    while getopts xy options 2>/dev/null 
        #如果再出现选项错误的情况,该重定向会将错误输出到/dev/null。
    do
        case $options in
        x) echo "you entered -x as an option" ;;
        y) echo "you entered -y as an option" ;;
        \?) echo "Only -x and -y are valid options" 1>&2
# ?表示所有错误的选项,即非-x和-y的选项。
    esac
    done
    /> . ./test4.sh -g   
                                 #遇到错误的选项将直接执行\?)内的代码。
    Only -x and -y are valid options
    /> . ./test4.sh -xg
    you entered -x as an option
    Only -x and -y are valid options

    /> cat > test5.sh
    #!/bin/sh
    while getopts xyz: arguments 2>/dev/null 
#z选项后面的冒号用于提示getopts,z选项后面必须有一个参数。
    do
        case $arguments in
        x) echo "you entered -x as an option." ;;
        y) echo "you entered -y as an option." ;;
        z) echo "you entered -z as an option." 
#z的后面会紧跟一个参数,该参数保存在内置变量OPTARG中。
            echo "\$OPTARG is $OPTARG.";
           ;;
        \?) echo "Usage opts4 [-xy] [-z argument]"
            exit 1 ;;
        esac
    done
    echo "The number of arguments passed was $(( $OPTIND - 1 ))"
#OPTIND保存一下将被处理的选项的位置,他是永远比实际命令行参数多1的数。
    /> ./test5.sh -xyz foo
    you entered -x as an option.
    you entered -y as an option.
    you entered -z as an option.
    $OPTARG is foo.
    The number of arguments passed was 2
    /> ./test5.sh -x -y -z boo
    you entered -x as an option.
    you entered -y as an option.
    you entered -z as an option.
    $OPTARG is boo.
    The number of arguments passed was 4

    9.  eval命令与命令行解析:
    eval命令可以对命令行求值,做Shell替换,并执行命令行,通常在普通命令行解析不能满足要求时使用。
    /> set a b c d
    /> echo The last argument is \$$#

    The last argument is $4
    /> eval echo The last argument is \$$#    #eval命令先进行了变量替换,之后再执行echo命令。
    The last argument is d


阅读更多
个人分类: linux shell 学习
想对作者说点什么? 我来说一句

shell编程 bash新手入门

2008年11月06日 1.64MB 下载

Bash Guide for Beginners.pdf

2007年12月29日 1.16MB 下载

Shell高级编程(中文版)

2017年10月14日 1.47MB 下载

Bash shell编程参考手册

2009年02月03日 528KB 下载

没有更多推荐了,返回首页

不良信息举报

Bash Shell编程

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭