7.1 测试结构

    • 结构是用来检测一系列命令的 退出状态 是否为0（按 UNIX 惯例,退出码 0 表示命令执行成功），如果为0，则执行接下来的一个或多个命令。
    • 测试结构会使用一个特殊的命令 [（参看特殊字符章节 ）。等同于 test 命令，它是一个内建命令，写法更加简洁高效。该命令将其参数视为比较表达式或文件测试，以比较结果作为其退出状态码返回（0 为真，1 为假）。

    • Bash 将 [[ $a -lt $b ]] 视为一整条语句，执行并返回退出状态。

    • 结构 和 let ... 根据其执行的算术表达式的结果决定退出状态码。这样的 结构可以用来进行 数值比较。

    注意，双括号算术扩展表达式的退出状态码不是一个错误的值。算术表达式为0，返回1；算术表达式不为0，返回0。

    1. var=-2 && (( var+=2 ))
    2. echo $?                   # 1
    4. var=-2 && (( var+=2 )) && echo $var
    5.                           # 并不会输出 $var, 因为((var+=2))的状态码为1
    • if 不仅可以用来测试括号内的条件表达式，还可以用来测试其他任何命令。
    1. if cmp a b &> /dev/null  # 消去输出结果
    2. then echo "Files a and b are identical."
    3. else echo "Files a and b differ."
    4. fi
    6. # 下面介绍一个非常实用的 “if-grep" 结构：
    7. # -----------------------------------
    8. if grep -q Bash file
    9.   then echo "File contains at least one occurrence of Bash."
    10. fi
    12. word=Linux
    13. letter_sequence=inu
    14. if echo "$word" | grep -q "$letter_sequence"
    15. # 使用 -q 选项消去 grep 的输出结果
    16. then
    17.   echo "$letter_sequence found in "$word"
    18. else
    19.   echo "$letter_sequence not found in $word"
    20. fi
    23. if COMMAND_WHOSE_EXIT_STATUS_IS_0_UNLESS_ERROR_OCCURRED
    24.   then echo "Command succeed."
    25.   else echo "Command failed."
    26. fi
    • 感谢 Stéphane Chazelas 提供了后两个例子。

    样例 7-1. 什么才是真？

    1. #!/bin/bash
    3. # 提示：
    4. # 如果你不确定某个表达式的布尔值，可以用 if 结构进行测试。
    6. echo
    8. echo "Testing \"0\""
    9. if [ 0 ]
    10. then
    11.   echo "0 is true."
    12. else
    13.   echo "0 is false."
    14. fi            # 0 为真。
    16. echo
    18. echo "Testing \"1\""
    19. if [ 1 ]
    20. then
    21.   echo "1 is true."
    22. else
    23.   echo "1 is false."
    24. fi            # 1 为真。
    26. echo
    28. echo "Testing \"-1\""
    29. if [ -1 ]
    30. then
    31.   echo "-1 is true."
    32. else
    33.   echo "-1 is false."
    34. fi            # -1 为真。
    36. echo
    38. echo "Testing \"NULL\""
    39. if [ ]        # NULL, 空
    40. then
    41.   echo "NULL is true."
    42. else
    43.   echo "NULL is false."
    44. fi            # NULL 为假。
    46. echo
    48. echo "Testing \"xyz\""
    49. if [ xyz ]    # 字符串
    50. then
    51.   echo "Random string is true."
    52. else
    53.   echo "Random string is false."
    55. echo
    57. echo "Testing \"$xyz\""
    58. if [ $xyz ]   # 原意是测试 $xyz 是否为空，但是
    59.               # 现在 $xyz 只是一个没有初始化的变量。
    60. then
    61.   echo "Uninitialized variable is true."
    62. else
    63.   echo "Uninitialized variable is flase."
    64. fi            # 未初始化变量含有null空值，为假。
    66. echo
    68. echo "Testing \"-n \$xyz\""
    70. then
    71.   echo "Uninitialized variable is true."
    72. else
    73.   echo "Uninitialized variable is false."
    74. fi            # 未初始化变量为假。
    76. echo
    79. xyz=          # 初始化为空。
    81. echo "Testing \"-n \$xyz\""
    82. if [ -n "$xyz" ]
    83. then
    84.   echo "Null variable is true."
    85. else
    86.   echo "Null variable is false."
    87. fi            # 空变量为假。
    89. echo
    91. # 什么时候 "false" 为真？
    93. echo "Testing \"false\""
    94. if [ "false" ]              #  看起来 "false" 只是一个字符串
    95. then
    96.   echo "\"false\" is true." #+ 测试结果为真。
    97. else
    98.   echo "\"false\" is false."
    99. fi            # "false" 为真。
    101. echo
    103. echo "Testing \"\$false\""  # 未初始化的变量。
    104. if [ "$false" ]
    105. then
    106.   echo "\"\$false\" is true."
    107. else
    108.   echo "\"\$false\" is false."
    109. fi            # "$false" 为假。
    110.               # 得到了我们想要的结果。
    112. # 如果测试空变量 "$true" 会有什么样的结果？
    114. echo
    116. exit 0

    练习：理解

    note 如果把 if 和 then 写在同一行时，则必须在 if 语句后加上一个分号来结束语句。因为 if 和 then 都是 关键字。以关键字（或者命令）开头的语句，必须先结束该语句(分号;)，才能执行下一条语句。

    1. if [ -x "$filename" ]; then

    elif 是 else if 的缩写。可以把多个 if/then 语句连到外边去，更加简洁明了。

    1. if [ condition1 ]
    2. then
    3.    command1
    4.    command2
    5.    command3
    6. elif [condition2 ]
    7. # 等价于 else if
    8. then
    9.    command4
    10.    command5
    11. else
    12.    default-command
    13. fi

    if test condition-true 完全等价于 if [ condition-true ]。当语句开始执行时，左括号 [ 是作为调用 test 命令的标记[^1]，而右括号则不严格要求，但在新版本的 Bash 里，右括号必须补上。

    test 命令是 Bash 的 ，可以用来检测文件类型和比较字符串。在 Bash 脚本中，test 不调用 sh-utils 包下的文件 /usr/bin/test。同样，[ 也不会调用链接到 /usr/bin/test 的 /usr/bin/[ 文件。

    1. bash$ type test
    2. test is a shell builtin
    3. bash$ type '['
    4. [ is a shell builtin
    5. bash$ type '[['
    6. [[ is a shell keyword
    7. bash$ type ']]'
    8. ]] is a shell keyword
    9. bash$ type ']'
    10. bash: type: ]: not found

    如果你想在 Bash 脚本中使用 /usr/bin/test，那你必须把路径写全。

    样例 7-2. test，/usr/bin/test，[] 和 /usr/bin/[ 的等价性

    在 Bash 里，[[ ]] 是比 [ ] 更加通用的写法。其作为扩展test 命令从 ksh88 中被继承了过来。

    1. file=/etc/passwd
    3. if [[ -e $file ]]
    4. then
    5. fi

    使用 [[...]] 代替 [...]可以避免很多逻辑错误。比如可以在 中使用 &&，||，< 和 > 操作符，而在 [] 中使用则会报错。

    在 [[]] 中会自动执行八进制和十六进制的进制转换操作。

    1. # [[ 八进制和十六进制进制转换 ]]
    2. # 感谢 Moritz Gronbach 提出。
    5. decimal=15
    6. octal=017   # = 15 (十进制)
    7. hex=0x0f    # = 15 (十进制)
    9. if [ "$decimal" -eq "$octal" ]
    10. then
    11.   echo "$decimal equals $octal"
    12. else
    13.   echo "$decimal is not equal to $octal"       # 15 不等于 017
    14. fi      # 在单括号 [ ] 之间不会进行进制转换。
    17. if [[ "$decimal" -eq "$octal" ]]
    18. then
    19.   echo "$decimal equals $octal"                # 15 等于 017
    20. else
    21.   echo "$decimal is not equal to $octal"
    22. fi      # 在双括号 [[ ]] 之间会进行进制转换。
    24. if [[ "$decimal" -eq "$hex" ]]
    25. then
    26.   echo "$decimal equals $hex"                  # 15 等于 0x0f
    27. else
    28.   echo "$decimal is not equal to $hex"
    29. fi      # 十六进制也可以进行转换。

    note 语法上并不严格要求在 if 之后一定要写 test 命令或者测试结构（[] 或 [[]]）。

    1. dir=/home/bozo
    3. if cd "$dir" 2>/dev/null; then   # "2>/dev/null" 重定向消去错误输出。
    4.   echo "Now in $dir."
    5. else
    6.   echo "Can't change to $dir."
    7. fi

    if COMMAND 的退出状态就是COMMAND 的退出状态。

    同样的，测试括号也不一定需要与 if 一起使用。其可以同 列表结构 结合而不需要 if。

    扩展和执行算术表达式。如果执行结果为0，其返回的 退出状态码 为1（假）。非0表达式返回的退出状态为0（真）。这与上述所使用的 test 和 [ ] 结构形成鲜明的对比。

    1. #!/bin/bash
    2. # arith-tests.sh
    3. # 算术测试。
    5. # (( ... )) 结构执行并测试算术表达式。
    6. # 与 [ ... ] 结构的退出状态正好相反。
    8. (( 0 ))
    9. echo "Exit status of \"(( 0 ))\" is $?."         # 1
    11. (( 1 ))
    12. echo "Exit status of \"(( 1 ))\" is $?."         # 0
    14. (( 5 > 4 ))                                      # 真
    15. echo "Exit status of \"(( 5 > 4 ))\" is $?."     # 0
    17. (( 5 > 9 ))                                      # 假
    18. echo "Exit status of \"(( 5 > 9 ))\" is $?."     # 1
    20. (( 5 == 5 ))                                     # 真
    21. echo "Exit status of \"(( 5 == 5 ))\" is $?."    # 0
    22. # (( 5 = 5 )) 会报错。
    24. (( 5 - 5 ))                                      # 0
    25. echo "Exit status of \"(( 5 - 5 ))\" is $?."     # 1
    27. (( 5 / 4 ))                                      # 合法
    28. echo "Exit status of \"(( 5 / 4 ))\" is $?."     # 0 
    30. (( 1 / 2 ))                                      # 结果小于1
    31. echo "Exit status of \"(( 1 / 2 ))\" is $?."     # 舍入至0。
    32.                                                  # 1
    34. (( 1 / 0 )) 2>/dev/null                          # 除0，非法
    35. #           ^^^^^^^^^^^
    36. echo "Exit status of \"(( 1 / 0 ))\" is $?."     # 1
    38. # "2>/dev/null" 的作用是什么？
    39. # 如果将其移除会发生什么？
    40. # 尝试移除这条语句并重新执行脚本。
    42. # ======================================= #
    44. # (( ... )) 在 if-then 中也非常有用
    46. var1=5
    47. var2=4
    49. if (( var1 > var2 ))
    50. then #^      ^      注意不是 $var1 和 $var2，为什么？
    51.   echo "$var1 is greater then $var2"
    52. fi     # 5 大于 4
    54. exit 0

    [^1]: 标记是一个具有特殊意义（）的符号或者短字符串。在 Bash 里像 和 .（点命令） 这样的标记可以扩展成关键字和命令。