第二部分：Shell编程（四）
三十一、Shell test命令（Shell []）详解，附带所有选项及说明
test 是 Shell 内置命令，用来检测某个条件是否成立。test 通常和 if 语句一起使用，并且大部分 if 语句都依赖 test。
test 命令有很多选项，可以进行数值、字符串和文件三个方面的检测。
Shell test 命令的用法为：
test expression
当 test 判断 expression 成立时，退出状态为 0，否则为非 0 值。
test 命令也可以简写为[]，它的用法为：
[ expression ]
注意[]和expression之间的空格，这两个空格是必须的，否则会导致语法错误。[]的写法更加简洁，比 test 使用频率高。
test 和 [] 是等价的，后续我们会交替使用 test 和 []，以让读者尽快熟悉。
在《二十九、Shell if else》一节中，我们使用 (()) 进行数值比较，这节我们就来看一下如何使用 test 命令进行数值比较。
#!/bin/bash
read age
if test $age -le 2; then
echo "婴儿"
elif test $age -ge 3 && test $age -le 8; then
echo "幼儿"
elif [ $age -ge 9 ] && [ $age -le 17 ]; then
echo "少年"
elif [ $age -ge 18 ] && [ $age -le 25 ]; then
echo "成年"
elif test $age -ge 26 && test $age -le 40; then
echo "青年"
elif test $age -ge 41 && [ $age -le 60 ]; then
echo "中年"
else
echo "老年"
fi
其中，-le选项表示小于等于，-ge选项表示大于等于，&&是逻辑与运算符。
学习 test 命令，重点是学习它的各种选项，下面我们就逐一讲解。
1、与文件检测相关的 test 选项
| 文件类型判断 | |
|---|---|
| 选 项 | 作 用 |
| -b filename | 判断文件是否存在，并且是否为块设备文件。 |
| -c filename | 判断文件是否存在，并且是否为字符设备文件。 |
| -d filename | 判断文件是否存在，并且是否为目录文件。 |
| -e filename | 判断文件是否存在。 |
| -f filename | 判断文件是否存在，井且是否为普通文件。 |
| -L filename | 判断文件是否存在，并且是否为符号链接文件。 |
| -p filename | 判断文件是否存在，并且是否为管道文件。 |
| -s filename | 判断文件是否存在，并且是否为非空。 |
| -S filename | 判断该文件是否存在，并且是否为套接字文件。 |
| 文件权限判断 | |
| 选 项 | 作 用 |
| -r filename | 判断文件是否存在，并且是否拥有读权限。 |
| -w filename | 判断文件是否存在，并且是否拥有写权限。 |
| -x filename | 判断文件是否存在，并且是否拥有执行权限。 |
| -u filename | 判断文件是否存在，并且是否拥有 SUID 权限。 |
| -g filename | 判断文件是否存在，并且是否拥有 SGID 权限。 |
| -k filename | 判断该文件是否存在，并且是否拥有 SBIT 权限。 |
| 文件比较 | |
| 选 项 | 作 用 |
| filename1 -nt filename2 | 判断 filename1 的修改时间是否比 filename2 的新。 |
| filename -ot filename2 | 判断 filename1 的修改时间是否比 filename2 的旧。 |
| filename1 -ef filename2 | 判断 filename1 是否和 filename2 的 inode 号一致，可以理解为两个文件是否为同一个文件。这个判断用于判断硬链接是很好的方法 |
Shell test 文件检测举例：
#!/bin/bash
read filename
read url
if test -w $filename && test -n $url
then
echo $url > $filename
echo "写入成功"
else
echo "写入失败"
fi
在 Shell 脚本文件所在的目录新建一个文本文件并命名为 urls.txt，然后运行 Shell 脚本，运行结果为：
urls.txt↙
http://c.biancheng.net/shell/↙
写入成功
2、与数值比较相关的 test 选项
| 选 项 | 作 用 |
|---|---|
| num1 -eq num2 | 判断 num1 是否和 num2 相等。 |
| num1 -ne num2 | 判断 num1 是否和 num2 不相等。 |
| num1 -gt num2 | 判断 num1 是否大于 num2 。 |
| num1 -lt num2 | 判断 num1 是否小于 num2。 |
| num1 -ge num2 | 判断 num1 是否大于等于 num2。 |
| num1 -le num2 | 判断 num1 是否小于等于 num2。 |
注意，test 只能用来比较整数，小数相关的比较还得依赖 《二十七、Linux bc命令》。
Shell test 数值比较举例：
#!/bin/bash
read a b
if test $a -eq $b
then
echo "两个数相等"
else
echo "两个数不相等"
fi
运行结果1：
10 10
两个数相等
运行结果2：
10 20
两个数不相等
3、与字符串判断相关的 test 选项
| 选 项 | 作 用 |
|---|---|
| -z str | 判断字符串 str 是否为空。 |
| -n str | 判断宇符串 str 是否为非空。 |
| str1 = str2 str1 == str2 | =和==是等价的，都用来判断 str1 是否和 str2 相等。 |
| str1 != str2 | 判断 str1 是否和 str2 不相等。 |
| str1 \> str2 | 判断 str1 是否大于 str2。\>是>的转义字符，这样写是为了防止>被误认为成重定向运算符。 |
| str1 \< str2 | 判断 str1 是否小于 str2。同样，\<也是转义字符。 |
有C语言、C++、Python、Java等编程经验的读者请注意，==、>、< 在大部分编程语言中都用来比较数字，而在 Shell 中，它们只能用来比较字符串，不能比较数字，这是非常奇葩的，大家要习惯。
其次，不管是比较数字还是字符串，Shell 都不支持 >= 和 <= 运算符，切记。
Shell test 字符串比较举例：
#!/bin/bash
read str1
read str2
#检测字符串是否为空
if [ -z "$str1" ] || [ -z "$str2" ]
then
echo "字符串不能为空"
exit 0
fi
#比较字符串
if [ $str1 = $str2 ]
then
echo "两个字符串相等"
else
echo "两个字符串不相等"
fi
运行结果：
http://c.biancheng.net/
http://c.biancheng.net/shell/
两个字符串不相等
细心的读者可能已经注意到，变量 $str1 和 $str2 都被双引号包围起来，这样做是为了防止 $str1 或者 $str2 是空字符串时出现错误，本文的后续部分将为你分析具体原因。
4、与逻辑运算相关的 test 选项
| 选 项 | 作 用 |
|---|---|
| expression1 -a expression | 逻辑与，表达式 expression1 和 expression2 都成立，最终的结果才是成立的。 |
| expression1 -o expression2 | 逻辑或，表达式 expression1 和 expression2 有一个成立，最终的结果就成立。 |
| !expression | 逻辑非，对 expression 进行取反。 |
改写上面的代码，使用逻辑运算选项：
#!/bin/bash
read str1
read str2
#检测字符串是否为空
if [ -z "$str1" -o -z "$str2" ] #使用 -o 选项取代之前的 ||
then
echo "字符串不能为空"
exit 0
fi
#比较字符串
if [ $str1 = $str2 ]
then
echo "两个字符串相等"
else
echo "两个字符串不相等"
fi
前面的代码我们使用两个[]命令，并使用||运算符将它们连接起来，这里我们改成-o选项，只使用一个[]命令就可以了。
5、在 test 中使用变量建议用双引号包围起来
test 和 [] 都是命令，一个命令本质上对应一个程序或者一个函数。即使是一个程序，它也有入口函数，例如C语言程序的入口函数是 main()，运行C语言程序就从 main() 函数开始，所以也可以将一个程序等效为一个函数，这样我们就不用再区分函数和程序了，直接将一个命令和一个函数对应起来即可。
有了以上认知，就很容易看透命令的本质了：使用一个命令其实就是调用一个函数，命令后面附带的选项和参数最终都会作为实参传递给函数。
假设 test 命令对应的函数是 func()，使用test -z $str1命令时，会先将变量 $str1 替换成字符串：
- 如果 $str1 是一个正常的字符串，比如 abc123，那么替换后的效果就是
test -z abc123，调用 func() 函数的形式就是func("-z abc123")。test 命令后面附带的所有选项和参数会被看成一个整体，并作为实参传递进函数。 - 如果 $str1 是一个空字符串，那么替换后的效果就是
test -z，调用 func() 函数的形式就是func("-z ")，这就比较奇怪了，因为-z选项没有和参数成对出现，func() 在分析时就会出错。
如果我们给 $str1 变量加上双引号，当 $str1 是空字符串时，test -z "$str1"就会被替换为test -z ""，调用 func() 函数的形式就是func("-z \"\"")，很显然，-z选项后面跟的是一个空字符串（\"表示转义字符），这样 func() 在分析时就不会出错了。
所以，当你在 test 命令中使用变量时，我强烈建议将变量用双引号""包围起来，这样能避免变量为空值时导致的很多奇葩问题。
6、总结
test 命令比较奇葩，>、<、== 只能用来比较字符串，不能用来比较数字，比较数字需要使用 -eq、-gt 等选项；不管是比较字符串还是数字，test 都不支持 >= 和 <=。有经验的程序员需要慢慢习惯 test 命令的这些奇葩用法。
对于整型数字的比较，我建议大家使用 (())，这在《二十九、Shell if else》一节中已经进行了演示。(()) 支持各种运算符，写法也符合数学规则，用起来更加方便，何乐而不为呢？
几乎完全兼容 test ，并且比 test 更加强大，比 test 更加灵活的是[[ ]]；[[ ]]不是命令，而是 Shell 关键字，下节将会讲解。
三十二、Shell [[]]详解：检测某个条件是否成立
[[ ]]是 Shell 内置关键字，它和test类似，也用来检测某个条件是否成立。
test 能做到的，[[ ]] 也能做到，而且 [[ ]] 做的更好；test 做不到的，[[ ]] 还能做到。可以认为 [[ ]] 是 test 的升级版，对细节进行了优化，并且扩展了一些功能。
[[ ]] 的用法为：
[[ expression ]]
当 [[ ]] 判断 expression 成立时，退出状态为 0，否则为非 0 值。注意[[ ]]和expression之间的空格，这两个空格是必须的，否则会导致语法错误。
1、[[ ]] 不需要注意某些细枝末节
[[ ]] 是 Shell 内置关键字，不是命令，在使用时没有给函数传递参数的过程，所以 test 命令的某些注意事项在 [[ ]] 中就不存在了，具体包括：
- 不需要把变量名用双引号
""包围起来，即使变量是空值，也不会出错。 - 不需要、也不能对 >、< 进行转义，转义后会出错。
请看下面的演示代码：
#!/bin/bash
read str1
read str2
if [[ -z $str1 ]] || [[ -z $str2 ]] #不需要对变量名加双引号
then
echo "字符串不能为空"
elif [[ $str1 < $str2 ]] #不需要也不能对 < 进行转义
then
echo "str1 < str2"
else
echo "str1 >= str2"
fi
运行结果：
http://c.biancheng.net/shell/
http://data.biancheng.net/
str1 < str2
2、[[ ]] 支持逻辑运算符
对多个表达式进行逻辑运算时，可以使用逻辑运算符将多个 test 命令连接起来，例如：
[ -z "$str1" ] || [ -z "$str2" ]
你也可以借助选项把多个表达式写在一个 test 命令中，例如：
[ -z "$str1" -o -z "$str2" ]
但是，这两种写法都有点“别扭”，完美的写法是在一个命令中使用逻辑运算符将多个表达式连接起来。我们的这个愿望在 [[ ]] 中实现了，[[ ]] 支持 &&、|| 和 ! 三种逻辑运算符。
使用 [[ ]] 对上面的语句进行改进：
[[ -z $str1 || -z $str2 ]]
这种写法就比较简洁漂亮了。
注意，[[ ]] 剔除了 test 命令的-o和-a选项，你只能使用 || 和 &&。这意味着，你不能写成下面的形式：
[[ -z $str1 -o -z $str2 ]]
当然，使用逻辑运算符将多个 [[ ]] 连接起来依然是可以的，因为这是 Shell 本身提供的功能，跟 [[ ]] 或者 test 没有关系，如下所示：
[[ -z $str1 ]] || [[ -z $str2 ]]
| test 或 [] | [[ ]] | ||
|---|---|---|---|
| [ -z "$str1" ] || [ -z "$str2" ] | √ | [[ -z $str1 ]] || [[ -z $str2 ]] | √ |
| [ -z "$str1" -o -z "$str2" ] | √ | [[ -z $str1 -o -z $str2 ]] | × |
| [ -z $str1 || -z $str2 ] | × | [[ -z $str1 || -z $str2 ]] | √ |
3、[[ ]] 支持正则表达式
在 Shell [[ ]] 中，可以使用=~来检测字符串是否符合某个正则表达式，它的用法为：
[[ str =~ regex ]]
str 表示字符串，regex 表示正则表达式。
下面的代码检测一个字符串是否是手机号：
#!/bin/bash
read tel
if [[ $tel =~ ^1[0-9]{10}$ ]]
then
echo "你输入的是手机号码"
else
echo "你输入的不是手机号码"
fi
运行结果1：
13203451100
你输入的是手机号码
运行结果2：
132034511009
你输入的不是手机号码
对^1[0-9]{10}$的说明：
^匹配字符串的开头（一个位置）；[0-9]{10}匹配连续的十个数字；$匹配字符串的末尾（一个位置）。
本文并不打算讲解正则表达式的语法，不了解的读者请猛击正则表达式入门教程-CSDN博客。
4、总结
有了 [[ ]]，你还有什么理由使用 test 或者 [ ]，[[ ]] 完全可以替代之，而且更加方便，更加强大。
但是 [[ ]] 对数字的比较仍然不友好，所以我建议，以后大家使用 if 判断条件时，用 (()) 来处理整型数字，用 [[ ]] 来处理字符串或者文件。
三十三、Shell case in语句详解
和其它编程语言类似，Shell 也支持两种分支结构（选择结构），分别是 if else 语句和 case in 语句。在《二十九、Shell if else》一节中我们讲解了 if else 语句的用法，这节我们就来讲解 case in 语句。
当分支较多，并且判断条件比较简单时，使用 case in 语句就比较方便了。
《二十九、Shell if else》一节的最后给出了一个例子，就是输入一个整数，输出该整数对应的星期几的英文表示，这节我们就用 case in 语句来重写代码，如下所示。
#!/bin/bash
printf "Input integer number: "
read num
case $num in
1)
echo "Monday"
;;
2)
echo "Tuesday"
;;
3)
echo "Wednesday"
;;
4)
echo "Thursday"
;;
5)
echo "Friday"
;;
6)
echo "Saturday"
;;
7)
echo "Sunday"
;;
*)
echo "error"
esac
运行结果：
Input integer number:3↙
Wednesday
看了这个例子，相信大家对 case in 语句有了一个大体上的认识，那么，接下来我们就正式开始讲解 case in 的用法，它的基本格式如下：
case expression in
pattern1)
statement1
;;
pattern2)
statement2
;;
pattern3)
statement3
;;
……
*)
statementn
esac
case、in 和 esac 都是 Shell 关键字，expression 表示表达式，pattern 表示匹配模式。
- expression 既可以是一个变量、一个数字、一个字符串，还可以是一个数学计算表达式，或者是命令的执行结果，只要能够得到 expression 的值就可以。
- pattern 可以是一个数字、一个字符串，甚至是一个简单的正则表达式。
case 会将 expression 的值与 pattern1、pattern2、pattern3 逐个进行匹配：
- 如果 expression 和某个模式（比如 pattern2）匹配成功，就会执行这模式（比如 pattern2）后面对应的所有语句（该语句可以有一条，也可以有多条），直到遇见双分号
;;才停止；然后整个 case 语句就执行完了，程序会跳出整个 case 语句，执行 esac 后面的其它语句。 - 如果 expression 没有匹配到任何一个模式，那么就执行
*)后面的语句（*表示其它所有值），直到遇见双分号;;或者esac才结束。*)相当于多个 if 分支语句中最后的 else 部分。
如果你有C语言、C++\Java等编程经验，这里的;;和*)就相当于其它编程语言中的 break 和 default。
对*)的几点说明：
- Shell case in 语句中的
*)用来“托底”，万一 expression 没有匹配到任何一个模式，*)部分可以做一些“善后”工作，或者给用户一些提示。 - 可以没有
*)部分。如果 expression 没有匹配到任何一个模式，那么就不执行任何操作。
除最后一个分支外（这个分支可以是普通分支，也可以是*)分支），其它的每个分支都必须以;;结尾，;;代表一个分支的结束，不写的话会有语法错误。最后一个分支可以写;;，也可以不写，因为无论如何，执行到 esac 都会结束整个 case in 语句。
上面的代码是 case in 最常见的用法，即 expression 部分是一个变量，pattern 部分是一个数字或者表达式。
case in 和正则表达式
case in 的 pattern 部分支持简单的正则表达式，具体来说，可以使用以下几种格式：
| 格式 | 说明 |
|---|---|
| * | 表示任意字符串。 |
| [abc] | 表示 a、b、c 三个字符中的任意一个。比如，[15ZH] 表示 1、5、Z、H 四个字符中的任意一个。 |
| [m-n] | 表示从 m 到 n 的任意一个字符。比如，[0-9] 表示任意一个数字，[0-9a-zA-Z] 表示字母或数字。 |
| | | 表示多重选择，类似逻辑运算中的或运算。比如，abc | xyz 表示匹配字符串 "abc" 或者 "xyz"。 |
如果不加以说明，Shell 的值都是字符串，expression 和 pattern 也是按照字符串的方式来匹配的；本节第一段代码看起来是判断数字是否相等，其实是判断字符串是否相等。
最后一个分支*)并不是什么语法规定，它只是一个正则表达式，*表示任意字符串，所以不管 expression 的值是什么，*)总能匹配成功。
下面的例子演示了如何在 case in 中使用正则表达式：
#!/bin/bash
printf "Input a character: "
read -n 1 char
case $char in
[a-zA-Z])
printf "\nletter\n"
;;
[0-9])
printf "\nDigit\n"
;;
[0-9])
printf "\nDigit\n"
;;
[,.?!])
printf "\nPunctuation\n"
;;
*)
printf "\nerror\n"
esac
运行结果1：
Input integer number: S
letter
运行结果2：
Input integer number: ,
Punctuation
三十四、Shell while循环详解
while 循环是 Shell 脚本中最简单的一种循环，当条件满足时，while 重复地执行一组语句，当条件不满足时，就退出 while 循环。
Shell while 循环的用法如下：
while condition
do
statements
done
condition表示判断条件，statements表示要执行的语句（可以只有一条，也可以有多条），do和done都是 Shell 中的关键字。
while 循环的执行流程为：
- 先对 condition 进行判断，如果该条件成立，就进入循环，执行 while 循环体中的语句，也就是 do 和 done 之间的语句。这样就完成了一次循环。
- 每一次执行到 done 的时候都会重新判断 condition 是否成立，如果成立，就进入下一次循环，继续执行 do 和 done 之间的语句，如果不成立，就结束整个 while 循环，执行 done 后面的其它 Shell 代码。
- 如果一开始 condition 就不成立，那么程序就不会进入循环体，do 和 done 之间的语句就没有执行的机会。
注意，在 while 循环体中必须有相应的语句使得 condition 越来越趋近于“不成立”，只有这样才能最终退出循环，否则 while 就成了死循环，会一直执行下去，永无休止。
while 语句和 if else 语句中的 condition 用法都是一样的，你可以使用 test 或 [] 命令，也可以使用 (()) 或 [[]]，遗忘的读者请对应进行回顾：
- 《二十九、Shell if else》
- 《三十、Shell退出状态》
- 《三十一、Shell test命令》
- 《三十二、Shell [[]]》
while 循环举例
【实例1】计算从 1 加到 100 的和。
#!/bin/bash
i=1
sum=0
while ((i <= 100))
do
((sum += i))
((i++))
done
echo "The sum is: $sum"
运行结果：
The sum is: 5050
在 while 循环中，只要判断条件成立，循环就会执行。对于这段代码，只要变量 i 的值小于等于 100，循环就会继续。每次循环给变量 sum 加上变量 i 的值，然后再给变量 i 加 1，直到变量 i 的值大于 100，循环才会停止。i++语句使得 i 的值逐步增大，让判断条件越来越趋近于“不成立”，最终退出循环。
对上面的例子进行改进，计算从 m 加到 n 的值。
#!/bin/bash
read m
read n
sum=0
while ((m <= n))
do
((sum += m))
((m++))
done
echo "The sum is: $sum"
运行结果：
1↙
100↙
The sum is: 5050
【实例2】实现一个简单的加法计算器，用户每行输入一个数字，计算所有数字的和。
#!/bin/bash
sum=0
echo "请输入您要计算的数字，按 Ctrl+D 组合键结束读取"
while read n
do
((sum += n))
done
echo "The sum is: $sum"
运行结果：
12↙
33↙
454↙
6767↙
1↙
2↙
The sum is: 7269
在终端中读取数据，可以等价为在文件中读取数据，按下 Ctrl+D 组合键表示读取到文件流的末尾，此时 read 就会读取失败，得到一个非 0 值的退出状态，从而导致判断条件不成立，结束循环。
三十五、Shell until循环用法详解
unti 循环和 while 循环恰好相反，当判断条件不成立时才进行循环，一旦判断条件成立，就终止循环。
until 的使用场景很少，一般使用 while 即可。
Shell until 循环的用法如下：
until condition
do
statements
done
condition表示判断条件，statements表示要执行的语句（可以只有一条，也可以有多条），do和done都是 Shell 中的关键字。
until 循环的执行流程为：
- 先对 condition 进行判断，如果该条件不成立，就进入循环，执行 until 循环体中的语句（do 和 done 之间的语句），这样就完成了一次循环。
- 每一次执行到 done 的时候都会重新判断 condition 是否成立，如果不成立，就进入下一次循环，继续执行循环体中的语句，如果成立，就结束整个 until 循环，执行 done 后面的其它 Shell 代码。
- 如果一开始 condition 就成立，那么程序就不会进入循环体，do 和 done 之间的语句就没有执行的机会。
注意，在 until 循环体中必须有相应的语句使得 condition 越来越趋近于“成立”，只有这样才能最终退出循环，否则 until 就成了死循环，会一直执行下去，永无休止。
上节《三十四、Shell while循环详解》演示了如何求从 1 加到 100 的值，这节我们改用 until 循环，请看下面的代码：
#!/bin/bash
i=1
sum=0
until ((i > 100))
do
((sum += i))
((i++))
done
echo "The sum is: $sum"
运行结果：
The sum is: 5050
在 while 循环中，判断条件为((i<=100))，这里将判断条件改为((i>100))，两者恰好相反，请读者注意区分。
三十六、Shell for循环和for int循环详解
除了 while 循环和 until 循环，Shell 脚本还提供了 for 循环，它更加灵活易用，更加简洁明了。Shell for 循环有两种使用形式，下面我们逐一讲解。
1、C语言风格的 for 循环
C语言风格的 for 循环的用法如下：
for((exp1; exp2; exp3))
do
statements
done
几点说明：
- exp1、exp2、exp3 是三个表达式，其中 exp2 是判断条件，for 循环根据 exp2 的结果来决定是否继续下一次循环；
- statements 是循环体语句，可以有一条，也可以有多条；
- do 和 done 是 Shell 中的关键字。
它的运行过程为：
1) 先执行 exp1。
2) 再执行 exp2，如果它的判断结果是成立的，则执行循环体中的语句，否则结束整个 for 循环。
3) 执行完循环体后再执行 exp3。
4) 重复执行步骤 2) 和 3)，直到 exp2 的判断结果不成立，就结束循环。
上面的步骤中，2) 和 3) 合并在一起算作一次循环，会重复执行，for 语句的主要作用就是不断执行步骤 2) 和 3)。
exp1 仅在第一次循环时执行，以后都不会再执行，可以认为这是一个初始化语句。exp2 一般是一个关系表达式，决定了是否还要继续下次循环，称为“循环条件”。exp3 很多情况下是一个带有自增或自减运算的表达式，以使循环条件逐渐变得“不成立”。
for 循环的执行过程可用下图表示：
下面我们给出一个实际的例子，计算从 1 加到 100 的和。
#!/bin/bash
sum=0
for ((i=1; i<=100; i++))
do
((sum += i))
done
echo "The sum is: $sum"
运行结果：
The sum is: 5050
代码分析：
1) 执行到 for 语句时，先给变量 i 赋值为 1，然后判断 i<=100 是否成立；因为此时 i=1，所以 i<=100 成立。接下来会执行循环体中的语句，等循环体执行结束后（sum 的值为1），再计算 i++。
2) 第二次循环时，i 的值为2，i<=100 成立，继续执行循环体。循环体执行结束后（sum的值为3），再计算 i++。
3) 重复执行步骤 2)，直到第 101 次循环，此时 i 的值为 101，i<=100 不再成立，所以结束循环。
由此我们可以总结出 for 循环的一般形式为：
for(( 初始化语句; 判断条件; 自增或自减 ))
do
statements
done
for 循环中的三个表达式
for 循环中的 exp1（初始化语句）、exp2（判断条件）和 exp3（自增或自减）都是可选项，都可以省略（但分号;必须保留）。
1) 修改“从 1 加到 100 的和”的代码，省略 exp1：
#!/bin/bash
sum=0
i=1
for ((; i<=100; i++))
do
((sum += i))
done
echo "The sum is: $sum"
可以看到，将i=1移到了 for 循环的外面。
2) 省略 exp2，就没有了判断条件，如果不作其他处理就会成为死循环，我们可以在循环体内部使用 break 关键字强制结束循环：
#!/bin/bash
sum=0
for ((i=1; ; i++))
do
if(( i>100 )); then
break
fi
((sum += i))
done
echo "The sum is: $sum"
break 是 Shell 中的关键字，专门用来结束循环，后续章节还会深入讲解。
3) 省略了 exp3，就不会修改 exp2 中的变量，这时可在循环体中加入修改变量的语句。例如：
#!/bin/bash
sum=0
for ((i=1; i<=100; ))
do
((sum += i))
((i++))
done
echo "The sum is: $sum"
4) 最后给大家看一个更加极端的例子，同时省略三个表达式：
#!/bin/bash
sum=0
i=0
for (( ; ; ))
do
if(( i>100 )); then
break
fi
((sum += i))
((i++))
done
echo "The sum is: $sum"
这种写法并没有什么实际意义，仅仅是为了给大家做演示。
2、Python风格的 for in 循环
Python 风格的 for in 循环的用法如下：
for variable in value_list
do
statements
done
variable 表示变量，value_list 表示取值列表，in 是 Shell 中的关键字。
in value_list 部分可以省略，省略后的效果相当于 in $@，本小节第三部分将会详细讲解。
每次循环都会从 value_list 中取出一个值赋给变量 variable，然后进入循环体（do 和 done 之间的部分），执行循环体中的 statements。直到取完 value_list 中的所有值，循环就结束了。
Shell for in 循环举例：
#!/bin/bash
sum=0
for n in 1 2 3 4 5 6
do
echo $n
((sum+=n))
done
echo "The sum is "$sum
运行结果：
1
2
3
4
5
6
The sum is 21
3、对 value_list 的说明
取值列表 value_list 的形式有多种，你可以直接给出具体的值，也可以给出一个范围，还可以使用命令产生的结果，甚至使用通配符，下面我们一一讲解。
（1）直接给出具体的值
可以在 in 关键字后面直接给出具体的值，多个值之间以空格分隔，比如1 2 3 4 5、"abc" "390" "tom"等。
上面的代码中用一组数字作为取值列表，下面我们再演示一下用一组字符串作为取值列表：
#!/bin/bash
for str in "C语言中文网" "http://c.biancheng.net/" "成立7年了" "日IP数万"
do
echo $str
done
运行结果：
C语言中文网
http://c.biancheng.net/
成立7年了
日IP数万
（2） 给出一个取值范围
给出一个取值范围的具体格式为：
{start..end}
start 表示起始值，end 表示终止值；注意中间用两个点号相连，而不是三个点号。根据笔者的实测，这种形式只支持数字和字母。
例如，计算从 1 加到 100 的和：
#!/bin/bash
sum=0
for n in {1..100}
do
((sum+=n))
done
echo $sum
运行结果：
5050
再如，输出从 A 到 z 之间的所有字符：
#!/bin/bash
for c in {A..z}
do
printf "%c" $c
done
输出结果：
ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz
可以发现，Shell 是根据 ASCII 码表来输出的。
（3） 使用命令的执行结果
使用反引号``或者$()都可以取得命令的执行结果，我们在《一、Shell变量》一节中已经进行了详细讲解，并对比了两者的优缺点。本节我们使用$()这种形式，因为它不容易产生混淆。
例如，计算从 1 到 100 之间所有偶数的和：
#!/bin/bash
sum=0
for n in $(seq 2 2 100)
do
((sum+=n))
done
echo $sum
运行结果：
2550
seq 是一个 Linux 命令，用来产生某个范围内的整数，并且可以设置步长，不了解的读者请自行百度。seq 2 2 100表示从 2 开始，每次增加 2，到 100 结束。
再如，列出当前目录下的所有 Shell 脚本文件：
#!/bin/bash
for filename in $(ls *.sh)
do
echo $filename
done
运行结果：
demo.sh
test.sh
abc.sh
ls 是一个 Linux 命令，用来列出当前目录下的所有文件，*.sh表示匹配后缀为.sh的文件，也就是 Shell 脚本文件。
（4） 使用 Shell 通配符
Shell 通配符可以认为是一种精简化的正则表达式，通常用来匹配目录或者文件，而不是文本，不了解的读者请猛击Linux Shell 通配符 / glob 模式-CSDN博客。
有了 Shell 通配符，不使用 ls 命令也能显示当前目录下的所有脚本文件，请看下面的代码：
#!/bin/bash
for filename in *.sh
do
echo $filename
done
运行结果：
demo.sh
test.sh
abc.sh
（5）使用特殊变量
Shell 中有多个特殊的变量，例如 $#、$*、$@、$?、$$ 等（不了解的读者请猛击《五、Shell特殊变量》），在 value_list 中就可以使用它们。
#!/bin/bash
function func(){
for str in $@
do
echo $str
done
}
func C++ Java Python C#
运行结果：
C++
Java
Python
C#
其实，我们也可以省略 value_list，省略后的效果和使用$@一样。请看下面的演示：
#!/bin/bash
function func(){
for str
do
echo $str
done
}
func C++ Java Python C#
运行结果：
C++
Java
Python
C#
三十七、Shell select in循环详解
select in 循环用来增强交互性，它可以显示出带编号的菜单，用户输入不同的编号就可以选择不同的菜单，并执行不同的功能。
select in 是 Shell 独有的一种循环，非常适合终端（Terminal）这样的交互场景，C语言、C++、Java、Python、C#等其它编程语言中是没有的。
Shell select in 循环的用法如下：
select variable in value_list
do
statements
done
variable 表示变量，value_list 表示取值列表，in 是 Shell 中的关键字。你看，select in 和for in 的语法是多么地相似。
我们先来看一个 select in 循环的例子：
#!/bin/bash
echo "What is your favourite OS?"
select name in "Linux" "Windows" "Mac OS" "UNIX" "Android"
do
echo $name
done
echo "You have selected $name"
运行结果：
What is your favourite OS?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#? 4↙
You have selected UNIX
#? 1↙
You have selected Linux
#? 9↙
You have selected
#? 2↙
You have selected Windows
#?^D
#?用来提示用户输入菜单编号；^D表示按下 Ctrl+D 组合键，它的作用是结束 select in 循环。
运行到 select 语句后，取值列表 value_list 中的内容会以菜单的形式显示出来，用户输入菜单编号，就表示选中了某个值，这个值就会赋给变量 variable，然后再执行循环体中的 statements（do 和 done 之间的部分）。
每次循环时 select 都会要求用户输入菜单编号，并使用环境变量 PS3 的值作为提示符，PS3 的默认值为#?，修改 PS3 的值就可以修改提示符。
如果用户输入的菜单编号不在范围之内，例如上面我们输入的 9，那么就会给 variable 赋一个空值；如果用户输入一个空值（什么也不输入，直接回车），会重新显示一遍菜单。
注意，select 是无限循环（死循环），输入空值，或者输入的值无效，都不会结束循环，只有遇到 break 语句，或者按下 Ctrl+D 组合键才能结束循环。
完整实例
select in 通常和case in 一起使用，在用户输入不同的编号时可以做出不同的反应。
修改上面的代码，加入 case in 语句：
#!/bin/bash
echo "What is your favourite OS?"
select name in "Linux" "Windows" "Mac OS" "UNIX" "Android"
do
case $name in
"Linux")
echo "Linux是一个类UNIX操作系统，它开源免费，运行在各种服务器设备和嵌入式设备。"
break
;;
"Windows")
echo "Windows是微软开发的个人电脑操作系统，它是闭源收费的。"
break
;;
"Mac OS")
echo "Mac OS是苹果公司基于UNIX开发的一款图形界面操作系统，只能运行与苹果提供的硬件之上。"
break
;;
"UNIX")
echo "UNIX是操作系统的开山鼻祖，现在已经逐渐退出历史舞台，只应用在特殊场合。"
break
;;
"Android")
echo "Android是由Google开发的手机操作系统，目前已经占据了70%的市场份额。"
break
;;
*)
echo "输入错误，请重新输入"
esac
done
用户只有输入正确的编号才会结束循环，如果输入错误，会要求重新输入。
运行结果1，输入正确选项：
What is your favourite OS?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#? 2
Windows是微软开发的个人电脑操作系统，它是闭源收费的。
运行结果2，输入错误选项：
What is your favourite OS?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#? 7
输入错误，请重新输入
#? 4
UNIX是操作系统的开山鼻祖，现在已经逐渐退出历史舞台，只应用在特殊场合。
运行结果3，输入空值：
What is your favourite OS?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#? 3
Mac OS是苹果公司基于UNIX开发的一款图形界面操作系统，只能运行与苹果提供的硬件之上。
三十八、Shell break和continue跳出循环详解
使用 while、until、for、select 循环时，如果想提前结束循环（在不满足结束条件的情况下结束循环），可以使用 break 或者 continue 关键字。
在C语言、C++、C#、Python、Java等大部分编程语言中，break 和 continue 只能跳出当前层次的循环，内层循环中的 break 和 continue 对外层循环不起作用；但是 Shell 中的 break 和 continue 却能够跳出多层循环，也就是说，内层循环中的 break 和 continue 能够跳出外层循环。
在实际开发中，break 和 continue 一般只用来跳出当前层次的循环，很少有需要跳出多层循环的情况。
1、break 关键字
Shell break 关键字的用法为：
break n
n 表示跳出循环的层数，如果省略 n，则表示跳出当前的整个循环。break 关键字通常和 if 语句一起使用，即满足条件时便跳出循环。
图1：Shell break关键字原理示意图
【实例1】不断从终端读取用户输入的正数，求它们相加的和：
#!/bin/bash
sum=0
while read n; do
if((n>0)); then
((sum+=n))
else
break
fi
done
echo "sum=$sum"
运行结果：
10↙
20↙
30↙
0↙
sum=60
while 循环通过 read 命令的退出状态来判断循环条件是否成立，只有当按下 Ctrl+D 组合键（表示输入结束）时，read n才会判断失败，此时 while 循环终止。
除了按下 Ctrl+D 组合键，你还可以输入一个小于等于零的整数，这样会执行 break 语句来终止循环（跳出循环）。
【实例2】使用 break 跳出双层循环。
如果 break 后面不跟数字的话，表示跳出当前循环，对于有两层嵌套的循环，就得使用两个 break 关键字。例如，输出一个 4*4 的矩阵：
#!/bin/bash
i=0
while ((++i)); do #外层循环
if((i>4)); then
break #跳出外层循环
fi
j=0;
while ((++j)); do #内层循环
if((j>4)); then
break #跳出内层循环
fi
printf "%-4d" $((i*j))
done
printf "\n"
done
运行结果：
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
当 j>4 成立时，执行第二个 break，跳出内层循环；外层循环依然执行，直到 i>4 成立，跳出外层循环。内层循环共执行了 4 次，外层循环共执行了 1 次。
我们也可以在 break 后面跟一个数字，让它一次性地跳出两层循环，请看下面的代码：
#!/bin/bash
i=0
while ((++i)); do #外层循环
j=0;
while ((++j)); do #内层循环
if((i>4)); then
break 2 #跳出内外两层循环
fi
if((j>4)); then
break #跳出内层循环
fi
printf "%-4d" $((i*j))
done
printf "\n"
done
修改后的代码将所有 break 都移到了内层循环里面。读者需要重点关注break 2这条语句，它使得程序可以一次性跳出两层循环，也就是先跳出内层循环，再跳出外层循环。
2、continue 关键字
Shell continue 关键字的用法为：
continue n
n 表示循环的层数：
- 如果省略 n，则表示 continue 只对当前层次的循环语句有效，遇到 continue 会跳过本次循环，忽略本次循环的剩余代码，直接进入下一次循环。
- 如果带上 n，比如 n 的值为 2，那么 continue 对内层和外层循环语句都有效，不但内层会跳过本次循环，外层也会跳过本次循环，其效果相当于内层循环和外层循环同时执行了不带 n 的 continue。这么说可能有点难以理解，稍后我们通过代码来演示。
continue 关键字也通常和 if 语句一起使用，即满足条件时便跳出循环。
图2：Shell continue关键字原理示意图
【实例1】不断从终端读取用户输入的 100 以内的正数，求它们的和：
#!/bin/bash
sum=0
while read n; do
if((n<1 || n>100)); then
continue
fi
((sum+=n))
done
echo "sum=$sum"
运行结果：
10↙
20↙
-1000↙
5↙
9999↙
25↙
sum=60
变量 sum 最终的值为 60，-1000 和 9999 并没有计算在内，这是因为 -1000 和 9999 不在 1~100 的范围内，if 判断条件成立，所以执行了 continue 语句，跳过了当次循环，也就是跳过了((sum+=n))这条语句。
注意，只有按下 Ctrl+D 组合键输入才会结束，read n才会判断失败，while 循环才会终止。
【实例2】使用 continue 跳出多层循环，请看下面的代码：
#!/bin/bash
for((i=1; i<=5; i++)); do
for((j=1; j<=5; j++)); do
if((i*j==12)); then
continue 2
fi
printf "%d*%d=%-4d" $i $j $((i*j))
done
printf "\n"
done
运行结果：
1*1=1 1*2=2 1*3=3 1*4=4 1*5=5
2*1=2 2*2=4 2*3=6 2*4=8 2*5=10
3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
从运行结果可以看出，遇到continue 2时，不但跳过了内层 for 循环，也跳过了外层 for 循环。
3、break 和 continue 的区别
break 用来结束所有循环，循环语句不再有执行的机会；continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。
三十九、Shell函数详解（函数定义、函数调用）
Shell 函数的本质是一段可以重复使用的脚本代码，这段代码被提前编写好了，放在了指定的位置，使用时直接调取即可。
Shell 中的函数和C++、C#、Python、Java 等其它编程语言中的函数类似，只是在语法细节有所差别。
Shell 函数定义的语法格式如下：
function name() {
statements
[return value]
}
对各个部分的说明：
function是 Shell 中的关键字，专门用来定义函数；name是函数名；statements是函数要执行的代码，也就是一组语句；return value表示函数的返回值，其中 return 是 Shell 关键字，专门用在函数中返回一个值；这一部分可以写也可以不写。
由{ }包围的部分称为函数体，调用一个函数，实际上就是执行函数体中的代码。
1、函数定义的简化写法
如果你嫌麻烦，函数定义时也可以不写 function 关键字：
name() {
statements
[return value]
}
如果写了 function 关键字，也可以省略函数名后面的小括号：
function name {
statements
[return value]
}
我建议使用标准的写法，这样能够做到“见名知意”，一看就懂。
2、函数调用
调用 Shell 函数时可以给它传递参数，也可以不传递。如果不传递参数，直接给出函数名字即可：
name
如果传递参数，那么多个参数之间以空格分隔：
name param1 param2 param3
不管是哪种形式，函数名字后面都不需要带括号。
和其它编程语言不同的是，Shell 函数在定义时不能指明参数，但是在调用时却可以传递参数，并且给它传递什么参数它就接收什么参数。
Shell 也不限制定义和调用的顺序，你可以将定义放在调用的前面，也可以反过来，将定义放在调用的后面。
3、实例演示
1) 定义一个函数，输出 Shell 教程的地址：
#!/bin/bash
#函数定义
function url(){
echo "http://c.biancheng.net/shell/"
}
#函数调用
url
运行结果：
http://c.biancheng.net/shell/
你可以将调用放在定义的前面，也就是写成下面的形式：
#!/bin/bash
#函数调用
url
#函数定义
function url(){
echo "http://c.biancheng.net/shell/"
}
2) 定义一个函数，计算所有参数的和：
#!/bin/bash
function getsum(){
local sum=0
for n in $@
do
((sum+=n))
done
return $sum
}
getsum 10 20 55 15 #调用函数并传递参数
echo $?
运行结果：
100
$@表示函数的所有参数，$?表示函数的退出状态（返回值）。关于如何获取函数的参数，后边会详细讲解。
此处我们借助 return 关键字将所有数字的和返回，并使用$?得到这个值，这种处理方案在其它编程语言中没有任何问题，但是在 Shell 中是非常错误的，Shell 函数的返回值和其它编程语言大有不同，我们将在《四十一、Shell函数返回值》中展开讨论。
四十、Shell函数参数
和 C++、C#、Python、Java 等大部分编程语言不同，Shell 中的函数在定义时不能指明参数，但是在调用时却可以传递参数。
函数参数是《四、Shell位置参数（命令行参数）》 的一种，在函数内部可以使用$n来接收，例如，$1 表示第一个参数，$2 表示第二个参数，依次类推。
除了$n，还有另外三个比较重要的变量：
$#可以获取传递的参数的个数；$@或者$*可以一次性获取所有的参数（通过《六、Shell $*和$@之间的区别》可以了解更多内容）。
$n、$#、$@、$* 都属于特殊变量，不了解的读者请看《五、Shell特殊变量：Shell $#、$*、$@、$?、$$》。
【实例1】使用 $n 来接收函数参数。
#!/bin/bash
#定义函数
function show(){
echo "Tutorial: $1"
echo "URL: $2"
echo "Author: "$3
echo "Total $# parameters"
}
#调用函数
show C# http://c.biancheng.net/csharp/ Tom
运行结果：
Tutorial: C#
URL: http://c.biancheng.net/csharp/
Author: Tom
Total 3 parameters
注意，第 7 行代码的写法有点不同，这里使用了 《九、Shell字符串拼接（连接、合并）》技巧。
【实例2】使用 $@ 来遍历函数参数。
定义一个函数，计算所有参数的和：
#!/bin/bash
function getsum(){
local sum=0
for n in $@
do
((sum+=n))
done
echo $sum
return 0
}
#调用函数并传递参数，最后将结果赋值给一个变量
total=$(getsum 10 20 55 15)
echo $total
#也可以将变量省略
echo $(getsum 10 20 55 15)
运行结果：
100
100
四十一、Shell函数返回值精讲
在 C++、Java、C#、Python 等大部分编程语言中，返回值是指函数被调用之后，执行函数体中的代码所得到的结果，这个结果就通过 return 语句返回。
但是 Shell 中的返回值表示的是函数的退出状态：返回值为 0 表示函数执行成功了，返回值为非 0 表示函数执行失败（出错）了。if、while、for 等语句都是根据函数的退出状态来判断条件是否成立。
Shell 函数的返回值只能是一个介于 0~255 之间的整数，其中只有 0 表示成功，其它值都表示失败。
函数执行失败时，可以根据返回值（退出状态）来判断具体出现了什么错误，比如一个打开文件的函数，我们可以指定 1 表示文件不存在，2 表示文件没有读取权限，3 表示文件类型不对。
如果函数体中没有 return 语句，那么使用默认的退出状态，也就是最后一条命令的退出状态。如果这就是你想要的，那么更加严谨的写法为：
return $?
$?是一个特殊变量，用来获取上一个命令的退出状态，或者上一个函数的返回值，请看《七、Shell $?：获取函数返回值或者上一个命令的退出状态》了解更多。
如何得到函数的处理结果？
有人可能会疑惑，既然 return 表示退出状态，那么该如何得到函数的处理结果呢？比如，我定义了一个函数，计算从 m 加到 n 的和，最终得到的结果该如何返回呢？
这个问题有两种解决方案：
- 一种是借助全局变量，将得到的结果赋值给全局变量；
- 一种是在函数内部使用 echo、printf 命令将结果输出，在函数外部使用
$()或者``捕获结果。
下面我们具体来定义一个函数 getsum，计算从 m 加到 n 的和，并使用以上两种解决方案。
【实例1】将函数处理结果赋值给一个全局变量。
#!/bin/bash
sum=0 #全局变量
function getsum(){
for((i=$1; i<=$2; i++)); do
((sum+=i)) #改变全局变量
done
return $? #返回上一条命令的退出状态
}
read m
read n
if getsum $m $n; then
echo "The sum is $sum" #输出全局变量
else
echo "Error!"
fi
运行结果：
1
100
The sum is 5050
这种方案的弊端是：定义函数的同时还得额外定义一个全局变量，如果我们仅仅知道函数的名字，但是不知道全局变量的名字，那么也是无法获取结果的。
【实例2】在函数内部使用 echo 输出结果。
#!/bin/bash
function getsum(){
local sum=0 #局部变量
for((i=$1; i<=$2; i++)); do
((sum+=i))
done
echo $sum
return $?
}
read m
read n
total=$(getsum $m $n)
echo "The sum is $total"
#也可以省略 total 变量，直接写成下面的形式
#echo "The sum is "$(getsum $m $n)
运行结果：
1↙
100↙
The sum is 5050
代码中总共执行了两次 echo 命令，但是却只输出一次，这是因为$()捕获了第一个 echo 的输出结果，它并没有真正输出到终端上。除了$()，你也可以使用``来捕获 echo 的输出结果，请在《一、Shell变量》了解两者的区别。
这种方案的弊端是：如果不使用$()，而是直接调用函数，那么就会将结果直接输出到终端上，不过这貌似也无所谓，所以我推荐这种方案。
总起来说，虽然C语言、C++、Java 等其它编程语言中的返回值用起来更加方便，但是 Shell 中的返回值有它独特的用途，所以不要带着传统的编程思维来看待 Shell 函数的返回值。
