7.1 测试结构
- Else if 与 elif

7.1 测试结构

if/then 结构是用来检测一系列命令的退出状态是否为0（按 UNIX 惯例,退出码 0 表示命令执行成功），如果为0，则执行接下来的一个或多个命令。
测试结构会使用一个特殊的命令 [（参看特殊字符章节左方括号）。等同于 test 命令，它是一个内建命令，写法更加简洁高效。该命令将其参数视为比较表达式或文件测试，以比较结果作为其退出状态码返回（0 为真，1 为假）。
Bash 在 2.02 版本中引入了扩展测试命令 [[...]]，它提供了一种与其他语言语法更为相似的方式进行比较操作。注意， [[ 是一个关键字而非一个命令。

Bash 将 [[ $a -lt $b ]] 视为一整条语句，执行并返回退出状态。 - 结构 (( ... )) 和 let ... 根据其执行的算术表达式的结果决定退出状态码。这样的算术扩展结构可以用来进行数值比较。

1. (( 0 && 1 ))                 # 逻辑与
2. echo $?     # 1     ***
3. # 然后 ...
4. let "num = (( 0 && 1 ))"
5. echo $num   # 0
6. # 然而 ...
7. let "num = (( 0 && 1 ))"
8. echo $?     # 1     ***

11. (( 200 || 11 ))              # 逻辑或
12. echo $?     # 0     ***
13. # ...
14. let "num = (( 200 || 11 ))"
15. echo $num   # 1
16. let "num = (( 200 || 11 ))"
17. echo $?     # 0     ***

20. (( 200 | 11 ))               # 按位或
21. echo $?                      # 0     ***
22. # ...
23. let "num = (( 200 | 11 ))"
24. echo $num                    # 203
25. let "num = (( 200 | 11 ))"
26. echo $?                      # 0     ***

28. # "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."
54. fi            # 随机字符串为真。

56. echo

58. echo "Testing \"$xyz\""
59. if [ $xyz ]   # 原意是测试 $xyz 是否为空，但是
60. # 现在 $xyz 只是一个没有初始化的变量。
61. then
62. echo "Uninitialized variable is true."
63. else
64. echo "Uninitialized variable is flase."
65. fi            # 未初始化变量含有null空值，为假。

67. echo

69. echo "Testing \"-n \$xyz\""
70. if [ -n "$xyz" ]            # 更加准确的写法。
71. then
72. echo "Uninitialized variable is true."
73. else
74. echo "Uninitialized variable is false."
75. fi            # 未初始化变量为假。

77. echo

80. xyz=          # 初始化为空。

82. echo "Testing \"-n \$xyz\""
83. if [ -n "$xyz" ]
84. then
85. echo "Null variable is true."
86. else
87. echo "Null variable is false."
88. fi            # 空变量为假。

90. echo

92. # 什么时候 "false" 为真？

94. echo "Testing \"false\""
95. if [ "false" ]              #  看起来 "false" 只是一个字符串
96. then
97. echo "\"false\" is true." #+ 测试结果为真。
98. else
99. echo "\"false\" is false."
100. fi            # "false" 为真。

102. echo

104. echo "Testing \"\$false\""  # 未初始化的变量。
105. if [ "$false" ]
106. then
107. echo "\"\$false\" is true."
108. else
109. echo "\"\$false\" is false."
110. fi            # "$false" 为假。
111. # 得到了我们想要的结果。

113. # 如果测试空变量 "$true" 会有什么样的结果？

115. echo

117. exit 0

练习：理解样例 7-1

1. if [ condition-true ]
2. then
3. command 1
4. command 2
5. ...
6. else  # 如果测试条件为假，则执行 else 后面的代码段
7. command 3
8. command 4
9. ...
10. fi

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

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

Else if 与 elif

elif

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/[ 的等价性

1. #!/bin/bash

3. echo

5. if test -z "$1"
6. then
7. echo "No command-line arguments."
8. else
9. echo "First command-line argument is $1."
10. fi

12. echo

14. if /usr/bin/test -z "$1"      # 等价于内建命令 "test"
15. #  ^^^^^^^^^^^^^              # 指定全路径
16. then
17. echo "No command-line arguments."
18. else
19. echo "First command-line argument is $1."
20. fi

22. echo

24. if [ -z "$1" ]                # 功能和上面的代码相同。
25. #   if [ -z "$1"                理论上可行，但是 Bash 会提示缺失右括号
26. then
27. echo "No command-line arguments."
28. else
29. echo "First command-line argument is $1."
30. fi

32. echo

35. if /usr/bin/[ -z "$1" ]       # 功能和上面的代码相同。
36. # if /usr/bin/[ -z "$1"       # 理论上可行，但是会报错
37. #                             # 已经在 Bash 3.x 版本被修复了
38. then
39. echo "No command-line arguments."
40. else
41. echo "First command-line argument is $1."
42. fi

44. echo

46. exit 0

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

在 [[ 和 ]] 中不会进行文件名扩展或字符串分割，但是可以进行参数扩展和命令替换。

1. file=/etc/passwd

3. if [[ -e $file ]]
4. then
5. echo "Password file exists."
6. 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      # 十六进制也可以进行转换。

语法上并不严格要求在 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。

1. var1=20
2. var2=22
3. [ "$var1" -ne "$var2" ] && echo "$var1 is not equal to $var2"

5. home=/home/bozo
6. [ -d "$home" ] || echo "$home directory does not exist."

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

样例 7-3. 使用 (( )) 进行算术测试

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 里像 [ 和 .（点命令） 这样的标记可以扩展成关键字和命令。