zoukankan      html  css  js  c++  java

  • shell脚本学习之case例子

    case和select结构在技术上说并不是循环, 因为它们并不对可执行代码块进行迭代. 但是和循环相似的是, 它们也依靠在代码块顶部或底部的条件判断来决定程序的分支. 

    在代码块中控制程序分支 

    case (in) / esac 

        在shell中的case结构与C/C++中的switch结构是相同的. 它允许通过判断来选择代码块中多条路径中的一条. 它的作用和多个if/then/else语句的作用相同, 是它们的简化结构, 特别适用于创建菜单. 

    Ruby代码  收藏代码
    1. case  "$variable"  in   
    2.   
    3.  "$condition1"  )  
    4.  command...  
    5.  ;;  
    6.   
    7.  "$condition2"  )  
    8.  command...  
    9.  ;;  
    10.   
    11. esac  
    12. Note     

        

         

            * 

              对变量使用""并不是强制的, 因为不会发生单词分割. 
            * 

              每句测试行, 都以右小括号)来结尾. 
            * 

              每个条件判断语句块都以一对分号结尾 ;;. 
            * 

              case块以esac (case的反向拼写)结尾. 

        例子 10-24. 使用case 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2. # 测试字符串范围.   
    3.   
    4. echo; echo "Hit a key, then hit return."   
    5. read Keypress  
    6.   
    7. case  "$Keypress"  in   
    8.   [[:lower :]]   ) echo "Lowercase letter" ;;  
    9.   [[:upper :]]   ) echo "Uppercase letter" ;;  
    10.   [0-9]         ) echo "Digit" ;;  
    11.   *             ) echo "Punctuation, whitespace, or other" ;;  
    12. esac      #  允许字符串的范围出现在[中括号]中,   
    13.           #+ 或者出现在POSIX风格的[[双中括号中.   
    14.   
    15. #  在这个例子的第一个版本中,   
    16. #+ 测试大写和小写字符串的工作使用的是   
    17. #+ [a-z] 和 [A-Z].   
    18. #  这种用法在某些特定场合的或某些Linux发行版中不能够正常工作.   
    19. #  POSIX 的风格更具可移植性.   
    20. #  感谢Frank Wang指出了这点.   
    21.   
    22. #  练习:   
    23. #  -----   
    24. #  就像这个脚本所表现出来的, 它只允许单次的按键, 然后就结束了.   
    25. #  修改这个脚本, 让它能够接受重复输入,   
    26. #+ 报告每次按键, 并且只有在"X"被键入时才结束.   
    27. #  暗示: 将这些代码都用"while"循环圈起来.   
    28.   
    29. exit 0  



        例子 10-25. 使用case来创建菜单 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2.   
    3. # 未经处理的地址资料   
    4.   
    5. clear # 清屏.   
    6.   
    7. echo "          Contact List"   
    8. echo "          ------- ----"   
    9. echo "Choose one of the following persons:"   
    10. echo  
    11. echo "[E]vans, Roland"   
    12. echo "[J]ones, Mildred"   
    13. echo "[S]mith, Julie"   
    14. echo "[Z]ane, Morris"   
    15. echo  
    16.   
    17. read person  
    18.   
    19. case  "$person"  in   
    20. # 注意, 变量是被""引用的.   
    21.   
    22.   "E"  | "e"  )  
    23.   # 接受大写或者小写输入.   
    24.   echo  
    25.   echo "Roland Evans"   
    26.   echo "4321 Floppy Dr."   
    27.   echo "Hardscrabble, CO 80753"   
    28.   echo "(303) 734-9874"   
    29.   echo "(303) 734-9892 fax"   
    30.   echo "revans@zzy.net"   
    31.   echo "Business partner & old friend"   
    32.   ;;  
    33. # 注意, 每个选项后边都要以双分号;;结尾.   
    34.   
    35.   "J"  | "j"  )  
    36.   echo  
    37.   echo "Mildred Jones"   
    38.   echo "249 E. 7th St., Apt. 19"   
    39.   echo "New York, NY 10009"   
    40.   echo "(212) 533-2814"   
    41.   echo "(212) 533-9972 fax"   
    42.   echo "milliej@loisaida.com"   
    43.   echo "Ex-girlfriend"   
    44.   echo "Birthday: Feb. 11"   
    45.   ;;  
    46.   
    47. # 后边的 Smith 和 Zane 的信息在这里就省略了.   
    48.   
    49.           * )  
    50.    # 默认选项.   
    51.    # 空输入(敲回车RETURN), 也适用于这里.   
    52.    echo  
    53.    echo "Not yet in database."   
    54.   ;;  
    55.   
    56. esac  
    57.   
    58. echo  
    59.   
    60. #  练习:   
    61. #  -----   
    62. #  修改这个脚本, 让它能够接受多个输入,   
    63. #+ 并且能够显示多个地址.   
    64.   
    65. exit 0  



        一个case的非常聪明的用法, 用来测试命令行参数. 

    Ruby代码  收藏代码
    1. #! /bin/bash   
    2.   
    3. case  "$1"  in   
    4. "" ) echo "Usage: ${0##*/} <filename>" ; exit $E_PARAM ;;  # 没有命令行参数,  
    5.                                                         # 或者第一个参数为空.   
    6. # 注意: ${0##*/} 是 ${var##pattern} 的一种替换形式. 得到的结果为$0.   
    7.   
    8. -*) FILENAME=./$1 ;;   #  如果传递进来的文件名参数($1)以一个破折号开头,   
    9.                       #+ 那么用./$1来代替.   
    10.                       #+ 这样后边的命令将不会把它作为一个选项来解释.   
    11.   
    12. * ) FILENAME=$1 ;;     # 否则, $1.   
    13. esac  



        这是一个命令行参数处理的更容易理解的例子: 

    Ruby代码  收藏代码
    1. #! /bin/bash   
    2.   
    3.   
    4. while  [ $# -gt 0 ]; do    # 直到你用完所有的参数 . . .   
    5.   case  "$1"  in   
    6.     -d|--debug)  
    7.               # 是 "-d" 或 "--debug" 参数?   
    8.               DEBUG=1  
    9.               ;;  
    10.     -c|--conf)  
    11.               CONFFILE="$2"   
    12.               shift  
    13.               if  [ ! -f $CONFFILE  ]; then   
    14.                 echo "Error: Supplied file doesn't exist!"   
    15.                 exit $E_CONFFILE      # 错误: 文件未发现.   
    16.               fi  
    17.               ;;  
    18.   esac  
    19.   shift       # 检查剩余的参数.   
    20. done  
    21.   
    22. #  来自Stefano Falsetto的 "Log2Rot" 脚本,   
    23. #+ 并且是他的"rottlog"包的一部分.   
    24. #  已得到使用许可.   



        例子 10-26. 使用命令替换来产生case变量 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2. # case-cmd.sh: 使用命令替换来产生"case"变量.   
    3.   
    4. case  $( arch ) in    # "arch" 返回机器体系的类型.   
    5.                     # 等价于 'uname -m' ...   
    6. i386 ) echo "80386-based machine" ;;  
    7. i486 ) echo "80486-based machine" ;;  
    8. i586 ) echo "Pentium-based machine" ;;  
    9. i686 ) echo "Pentium2+-based machine" ;;  
    10. *    ) echo "Other type of machine" ;;  
    11. esac  
    12.   
    13. exit 0  



        case结构也可以过滤通配(globbing)模式的字符串. 

        例子 10-27. 简单的字符串匹配 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2. # match-string.sh: 简单的字符串匹配   
    3.   
    4. match_string ()  
    5. {  
    6.   MATCH=0  
    7.   NOMATCH=90  
    8.   PARAMS=2     # 此函数需要2个参数.   
    9.   BAD_PARAMS=91  
    10.   
    11.   [ $# -eq $PARAMS ] || return $BAD_PARAMS   
    12.   
    13.   case  "$1"  in   
    14.   "$2" ) return  $MATCH ;;  
    15.   *   ) return  $NOMATCH ;;  
    16.   esac  
    17.   
    18. }    
    19.   
    20.   
    21. a=one  
    22. b=two  
    23. c=three  
    24. d=two  
    25.   
    26.   
    27. match_string $a      # 参数个数错误.   
    28. echo $?             # 91   
    29.   
    30. match_string $a  $b   # 不匹配   
    31. echo $?             # 90   
    32.   
    33. match_string $b  $d   # 匹配   
    34. echo $?             # 0   
    35.   
    36.   
    37. exit 0    

                      

        例子 10-28. 检查输入字符是否为字母 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2. # isalpha.sh: 使用"case"结构来过滤字符串.   
    3.   
    4. SUCCESS=0  
    5. FAILURE=-1  
    6.   
    7. isalpha ()  # 检查输入的 *第一个字符* 是不是字母表上的字符.   
    8. {  
    9. if  [ -z "$1"  ]                # 没有参数传进来?   
    10. then   
    11.   return  $FAILURE   
    12. fi  
    13.   
    14. case  "$1"  in   
    15. [a-zA-Z]*) return  $SUCCESS ;;  # 以一个字母开头?   
    16. *        ) return  $FAILURE ;;  
    17. esac  
    18. }             # 同C语言的"isalpha ()"函数比较一下.   
    19.   
    20.   
    21. isalpha2 ()   # 测试 *整个字符串* 是否都是字母表上的字符.   
    22. {  
    23.   [ $# -eq 1 ] || return $FAILURE   
    24.   
    25.   case  $1  in   
    26.   *[!a-zA-Z]*|"" ) return  $FAILURE ;;  
    27.                *) return  $SUCCESS ;;  
    28.   esac  
    29. }  
    30.   
    31. isdigit ()    # 测试 *整个字符串* 是否都是数字.   
    32. {             # 换句话说, 就是测试一下是否是整数变量.   
    33.   [ $# -eq 1 ] || return $FAILURE   
    34.   
    35.   case  $1  in   
    36.   *[!0-9]*|"" ) return  $FAILURE ;;  
    37.             *) return  $SUCCESS ;;  
    38.   esac  
    39. }  
    40.   
    41.   
    42.   
    43. check_var ()  # 测试isalpha().   
    44. {  
    45. if  isalpha "$@"   
    46. then   
    47.   echo "/"$*/" begins with an alpha character."   
    48.   if  isalpha2 "$@"   
    49.   then         # 不需要测试第一个字符是否是non-alpha.   
    50.     echo "/"$*/" contains only alpha characters."   
    51.   else   
    52.     echo "/"$*/" contains at least one non-alpha character."   
    53.   fi    
    54. else   
    55.   echo "/"$*/" begins with a non-alpha character."   
    56.               # 如果没有参数传递进来, 也是"non-alpha".   
    57. fi  
    58.   
    59. echo  
    60.   
    61. }  
    62.   
    63. digit_check ()  # 测试isdigit().   
    64. {  
    65. if  isdigit "$@"   
    66. then   
    67.   echo "/"$*/" contains only digits [0 - 9]."   
    68. else   
    69.   echo "/"$*/" has at least one non-digit character."   
    70. fi  
    71.   
    72. echo  
    73.   
    74. }  
    75.   
    76. a=23skidoo  
    77. b=H3llo  
    78. c=-What?  
    79. d=What?  
    80. e=`echo $b `   # 命令替换.   
    81. f=AbcDef  
    82. g=27234  
    83. h=27a34  
    84. i=27.34  
    85.   
    86. check_var $a   
    87. check_var $b   
    88. check_var $c   
    89. check_var $d   
    90. check_var $e   
    91. check_var $f   
    92. check_var     # 没有参数传递进来, 将会发生什么?   
    93. #   
    94. digit_check $g   
    95. digit_check $h   
    96. digit_check $i   
    97.   
    98.   
    99. exit 0        # S.C改进了这个脚本.   


        
         # 练习: 
         # ----- 
         #  编写一个'isfloat ()'函数来测试浮点数. 
         #  暗示: 这个函数基本上与'isdigit ()'相同, 
         #+ 但是要添加一些小数点部分的处理. 

    select 

        select结构是建立菜单的另一种工具, 这种结构是从ksh中引入的. 

        select variable [in list] 
        do 
         command... 
        燽reak 
        done 

        提示用户输入选择的内容(比如放在变量列表中). 注意: select命令使用PS3提示符, 默认为(#?), 当然, 这可以修改. 

        例子 10-29. 使用select来创建菜单 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2.   
    3. PS3='Choose your favorite vegetable: '  # 设置提示符字串.   
    4.   
    5. echo  
    6.   
    7. select vegetable in  "beans"  "carrots"  "potatoes"  "onions" "rutabagas"   
    8. do   
    9.   echo  
    10.   echo "Your favorite veggie is $vegetable."   
    11.   echo "Yuck!"   
    12.   echo  
    13.   break   # 如果这里没有 'break' 会发生什么?   
    14. done  
    15.   
    16. exit 0  



        如果忽略了in list列表, 那么select命令将会使用传递到脚本的命令行参数($@), 或者是函数参数(当select是在函数中时). 

        与忽略in list的 

        for variable [in list] 
        结构比较一下. 

        例子 10-30. 使用函数中的select结构来创建菜单 

    Ruby代码  收藏代码
    1. #!/bin/bash   
    2.   
    3. PS3='Choose your favorite vegetable: '   
    4.   
    5. echo  
    6.   
    7. choice_of()  
    8. {  
    9. select vegetable  
    10. # [in list]被忽略, 所以'select'使用传递给函数的参数.   
    11. do   
    12.   echo  
    13.   echo "Your favorite veggie is $vegetable."   
    14.   echo "Yuck!"   
    15.   echo  
    16.   break   
    17. done  
    18. }  
    19.   
    20. choice_of beans rice carrots radishes tomatoes spinach  
    21. #         $1    $2   $3      $4       $5       $6   
    22. #         传递给choice_of()的参数   
    23.   
    24. exit 0  
  • 相关阅读:
    rest_framework学习之路
    jQuery操作cookie
    Cookie和Session
    HTTP之Content-Type
    HTTP协议
    Python之random模块
    HTML5(FileRdeader)
    Python之re模块
    LINQ基础 之 LINQ TO SQL （二）
    LINQ基础(一）
  • 原文地址：https://www.cnblogs.com/wangshuai6707/p/4430567.html
Copyright © 2011-2022 走看看