变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#!/bin/bash
# 1. 变量的定义和使用
username=helloshaohua
echo "1. $username"
# 2. 另一种定义方式
course="linux shell program"
echo 2. ${course}
# 3. 只读变量
readonly course
# course="Go program" # available.sh: line 13: course: readonly variable. | On the mac os.
# unset course # available.sh: line 14: unset: course: cannot unset: readonly variable.
echo "3. ${course}"
# 4. 删除变量
unset usernmae
echo "4. ${username}"
|
环境变量
定义一个 env.sh shell脚本如下：
1
2
3
4
5
6
7
|
#!/bin/bash
# 1. export 导出一个环境变量
export SHAOHUA="helloshaohua"
# 2. 查找自定义的环境变量
env | grep "SHAOHUA"
|
运行 env.sh shell脚本，得到如下结果：
1
2
3
|
$ sh env.sh
SHAOHUA=helloshaohua
|
特殊变量
| 变量 |
含义 |
$0 |
当前脚本的文件名 |
$n |
传递给脚本或函数的参数。n是一个数字，表示第几个参数，例如，第一个参数是$1，第二个参数是$2 |
$# |
传递给脚本或函数的参数个数 |
$* |
传递给脚本或函数的所有参数 |
$@ |
传递给脚本或函数的所有参数。被双引号(" “)包含时，与$*稍有不同，下面将会讲到。 |
$? |
上个命令的退出状态，或函数的返回值 |
$$ |
当前shell进程ID。对于shell脚本，就是这些脚本所在的进程ID。 |
定义一个 special-variable.sh shell脚本如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#!/bin/bash
# 特殊变量 $0 表示当前脚本的文件名称.
echo "当前脚本文件名称：$0"
# 获取传递给脚本的第一个参数.
echo "参数1：$1"
# 获取传递给脚本的第二个参数.
echo "参数2：$2"
# 传递给脚本或函数的参数个数.
echo "参数个数：$#"
# 获取传递给脚本的所有参数.
echo "所有参数：$@"
|
运行 special-variable.sh shell脚本，得到如下结果：
1
2
3
4
5
6
|
$ sh special.sh hello world helloshaohua hellochina
当前脚本文件名称：special.sh
参数1：hello
参数2：world
参数个数：4
所有参数：hello world helloshaohua hellochina
|
算术运算
| 运算符 |
含义 |
+ |
加 |
- |
减 |
* |
乘 |
/ |
除 |
% |
取余 |
定义一个 arithmetic-operation.sh shell脚本如下，以测试具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#!/bin/bash
a=10
b=25
# 加法 expr 运算符
sum=`expr $a + $b`
echo "$a + $b = $sum"
# 另一种数值运算 $[expression]
sub=$[a-b]
echo "$a - $b = $sub"
# 乘法
ride_val=$[a*b]
echo "$a * $b = $ride_val"
# 除法
divide_val=$[b/a]
echo "$b / $a = $divide_val"
# 取余
surplus_val=$[b%a]
echo "$b % $a = $surplus_val"
|
运行 arithmetic-operation.sh shell脚本，得到如下结果：
1
2
3
4
5
6
|
$ sh arithmetic-operation.sh
10 + 25 = 35
10 - 25 = -15
10 * 25 = 250
25 / 10 = 2
25 % 10 = 5
|
expr 运算符表示运算，意为将expr右侧的表达式进行计算，从上面的脚本文件代码中可以看出，其实这种方式不太常用，而$[expression] 这种方式更加常用，因为写起来比较方便嘛！
关系运算
| 运算符 |
含义 |
-eq |
相等 |
-ne |
不相等 |
-gt |
大于 |
-ge |
大于等于 |
-lt |
小于 |
-le |
小于等于 |
定义一个 relational-calculus.sh shell脚本如下，以测试 关系运算 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
#!/bin/bash
a=10
b=25
# -eq 相等
if [ $a -eq $b ]; then
echo "$a -eq $b: $a 等于 $b"
else
echo "$a -eq $b: $a 不等于 $b"
fi
# -ne 不相等
if [ $a -ne $b ]; then
echo "$a -ne $b: $a 不等于 $b"
else
echo "$a -ne $b: $a 等于 $b"
fi
# -gt 大于
if [ $a -gt $b ]; then
echo "$a -gt $b: $a 大于 $b"
else
echo "$a -gt $b: $a 不大于 $b"
fi
# -gt 大于等于
if [ $a -ge $b ]; then
echo "$a -ge $b: $a 大于等于 $b"
else
echo "$a -ge $b: $a 不大于等于 $b"
fi
# -lt 小于
if [ $a -lt $b ]; then
echo "$a -lt $b: $a 小于 $b"
else
echo "$a -lt $b: $a 不小于 $b"
fi
# -le 小于等于
if [ $a -le $b ]; then
echo "$a -le $b: $a 小于等于 $b"
else
echo "$a -le $b: $a 不小于等于 $b"
fi
|
运行 relational-calculus.sh shell脚本，得到如下结果：
1
2
3
4
5
6
7
|
$ sh relational-calculus.sh
10 -eq 25: 10 不等于 25
10 -ne 25: 10 不等于 25
10 -gt 25: 10 不大于 25
10 -ge 25: 10 不大于等于 25
10 -lt 25: 10 小于 25
10 -le 25: 10 小于等于 25
|
是不是灰常简单~
布尔与逻辑运算
| 运算符 |
含义 |
! |
非运算 [ !false ] |
-o |
或运算 |
-a |
与运算 [ $a -lt 100 -a $b -gt 15 ] |
&& |
逻辑与 [[ $a -lt 100 && $b -gt 1 ]] |
|| |
逻辑或 |
== |
相等（数字） |
!= |
不行（数字） |
定义一个 boolean-logic.sh shell脚本如下，以测试 布尔与逻辑运算 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#!/bin/bash
a=10
b=25
# 布尔运算(-eq, -ne, -gt, -ge, -lt, -le)，也可以理解为：由关系运算符组成的布尔运算表达式.
if [ $a -eq $b ]; then
echo "$a -eq $b: $a 等于 $b"
else
echo "$a -eq $b: $a 不等于 $b"
fi
# 逻辑运算， 注意两个[[ ]] 方括号.
if [[ $a -gt 0 && $b -gt 0 ]]; then
echo "$a, $b 都大于 0"
fi
|
运行 boolean-logic.sh shell脚本，得到如下结果：
1
2
3
|
$ sh boolean-logic.sh
10 -eq 25: 10 不等于 25
10, 25 都大于 0
|
所有的语言基本都是一样，分支语句都是测试布尔表达式进行代码路由的一个过程，代码路由，这个概念你可以没有听说过，这个是我随口说的哦，其实就是条件执行. 而布尔表达式最终可以得到这些 条件，布尔表达式一般由关系运算符组成。
文件测试运算
| 运算符 |
含义 |
-d |
是否为目录 |
-f |
是否为普通文件 |
-r |
是否可读 |
-w |
是否可写 |
-x |
是否可执行 |
-s |
文件是否为空 |
-e |
文件是否存在 |
定义一个 file.sh shell脚本如下，以测试 文件测试运算 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
#!/bin/bash
tmp_dir="/tmp"
tmp_helloshaohua_txt="$tmp_dir/helloshaohua.txt"
# 创建一个新文件，没有任何内容，也就是空文件.
touch $tmp_helloshaohua_txt
# -d 是否为目录
if [ -d $tmp_dir ]; then
echo "$tmp_dir 是目录"
else
echo "$tmp_dir 不是目录"
fi
# -f 文件是否为普通文件
if [ -f $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件是普通文件"
else
echo "$tmp_helloshaohua_txt 文件不是普通文件"
fi
# -r 文件是否可读
if [ -r $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件可读"
else
echo "$tmp_helloshaohua_txt 文件不可读"
fi
# -w 文件是否可写
if [ -w $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件可写"
else
echo "$tmp_helloshaohua_txt 文件不可写"
fi
# -x 文件是否可执行
if [ -x $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件可执行"
else
echo "$tmp_helloshaohua_txt 文件不可执行"
fi
# -s 文件是否为空，注意啦：The non zero output indicate that file is empty，
# 意为：非零输出表示文件为空。
# 可以参考：https://www.cyberciti.biz/faq/linux-unix-script-check-if-file-empty-or-not/
if [ ! -s $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件为空"
else
echo "$tmp_helloshaohua_txt 文件不为空"
fi
# -e 文件是否存在
if [ -e $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件存在"
else
echo "$tmp_helloshaohua_txt 文件不存在"
fi
# 写入内容到文件
echo "写入helloshaohua字符串到${tmp_helloshaohua_txt}文件"
echo "helloshaohua" >> $tmp_helloshaohua_txt
# 再次检测文件是否为空，这部分和上面部分代码重复可以提取定义为一个函数，
# 这里简单起见，暂不定义函数，具体会到函数部分说明.
# 这次检测应该是输出 `/tmp/helloshaohua.txt 文件不为空` 才对~
if [ ! -s $tmp_helloshaohua_txt ]; then
echo "$tmp_helloshaohua_txt 文件为空"
else
echo "$tmp_helloshaohua_txt 文件不为空"
fi
|
运行 file.sh shell脚本，得到如下结果：
1
2
3
4
5
6
7
8
9
10
|
$ sh file.sh
/tmp 是目录
/tmp/helloshaohua.txt 文件是普通文件
/tmp/helloshaohua.txt 文件可读
/tmp/helloshaohua.txt 文件可写
/tmp/helloshaohua.txt 文件不可执行
/tmp/helloshaohua.txt 文件不为空
/tmp/helloshaohua.txt 文件存在
写入helloshaohua字符串到/tmp/helloshaohua.txt文件
/tmp/helloshaohua.txt 文件不为空
|
字符串
| 定义方式 |
含义 |
单引号 |
原样输出，变量无效 |
双引号 |
可以包含变量 |
定义一个 string.sh shell脚本如下，以测试 字符串 具体使用情况，其实也特定简单：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/bin/bash
tutorial="Linux shell脚本编程快速入门"
# 单引号
question='Linux shell脚本编程如何学习？$tutorial'
echo $question
# 双引号
answer="请阅读《${tutorial}》博客内容！"
echo $answer
# 字符串拼接
echo -e "拼接后一起输出：\n"${question}"\n"$answer
|
运行 string.sh shell脚本，得到如下结果：
1
2
3
4
5
6
|
$ sh string.sh
Linux shell脚本编程如何学习？$tutorial
请阅读《Linux shell脚本编程快速入门》博客内容！
-e 拼接后一起输出：
Linux shell脚本编程如何学习？$tutorial
请阅读《Linux shell脚本编程快速入门》博客内容！
|
单引号字符串内如果包含变量将原样输出变量名，也就是说它不会解析，双引号字符串内如果包含变量将会解析变量为具体值，单引号 定义字符串并不常用。最常用的是 双引号 定义字符串。
字符串操作
| 定义方式 |
含义 |
${#variable} |
获取字符串长度。 |
${variable:start:end} |
获取字符串子串。 |
expr index "$variable" sub_str |
查找字符串子串。 |
定义一个 string-operate.sh shell脚本如下，以测试 字符串操作 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/bin/bash
# 普通变量定义
user="helloshaohua"
# 获取字符串长度
echo "字符串${user}的长度为：${#user}"
# 获取字符串子串
echo "字符串${user}子串：${user:5:${#user}-1}"
# 查找字符串子串位置
matched=`expr index "$user" s`
echo "字符串${user}查找字符串子串位置s为：$matched"
|
运行 string-operate.sh shell脚本，得到如下结果：
1
2
3
4
|
$ sh hello.sh
字符串helloshaohua的长度为：12
字符串helloshaohua子串：shaohua
字符串helloshaohua查找字符串子串位置s为：6
|
字符串操运算符
| 运算符 |
含义 |
= |
字符串是否相等[$a = $b] |
!= |
字符串是否不相等[$a != $b] |
-z |
字符串长度是否为0[-z $a] |
-n |
字符串长度是否不为0[-n "$a"] |
$ |
字符串是否为空[$a] |
注意: 左中括号[之后和右中括号]之前应该有一个空格
数组
- 定义，下标从
0 开始.
- 设置/读取数组元素.
- 读取数组所有元素
@.
- 读取数组长度.
定义一个 array.sh shell脚本如下，以测试 数组 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/bin/bash
# 1. 数组的定义
oss=("linux", "darwin", "window", "android")
# 2. 设置数组元素(是可以说是更新某个数组元素)
oss[1]="MacOSX"
# 3. 读取数组元素
echo "数组下标(索引)为2的元素：${oss[1]}"
# 4. 读取数组所有元素
echo "数组所有元素：${oss[@]}"
# 5. 获取数组长度
len=${#oss[@]}
echo "数组长度为：$len"
|
运行 array.sh shell脚本，得到如下结果：
1
2
3
4
|
$ sh array.sh
数组下标(索引)为2的元素：MacOSX
数组所有元素：linux, MacOSX window, android
数组长度为：4
|
分支语句
if
如果您有语言基础，这个分支语句肯定是对您来说是非常简单喽，没有也没有关系，所谓的分支语句就是根据判断条件的真假，选择具体的分支进行执行代码，如果被测试的条件都不为真，有 else 分支时，执行 else 分支，否则当前分支块执行结束，继续向下执行代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
#!/bin/bash
# 普通变量定义
age=18
# 第一种写法：if 分支语句，每一条判断语句后跟一个 then 关键字的使用方式.
if [ $age -le 10 ]; then
echo "${age}小于等于10：少年"
elif [ $age -le 20 ]; then
echo "${age}小于等于20：青年"
elif [ $age -le 50 ]; then
echo "${age}小于等于50：中年"
else
echo "老年"
fi
# 第二种写法：if 分支语句，每一条判断语句换行跟一个 then 关键字的使用方式.
if [ $age -le 10 ]
then
echo "${age}小于等于10：少年"
elif [ $age -le 20 ]
then
echo "${age}小于等于20：青年"
elif [ $age -le 50 ]
then
echo "${age}小于等于50：中年"
else
echo "老年"
fi
|
运行 if.sh shell脚本，得到如下结果：
1
2
3
|
$ sh if.sh
18小于等于20：青年
18小于等于20：青年
|
在上面的 if.sh shell脚本文件中有两种if分支结构的写法，第一种是最常用的用法，第二种使脚本代码不易读。建议使用第一种写法。
case
这个case中其它编程语言中就是 switch...case 分支结构喽，在shell中它叫case，所完成的功能是相同的。接下来定义一个 case.sh shell脚本，以测试 case 具体使用情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/bin/bash
# 普通变量定义
os="hello"
case $os in
"windows")
echo "当前系统是Windows操作系统." ;;
"linux")
echo "当前系统是Linux操作系统." ;;
"darwin")
echo "当前系统是Mac操作系统." ;;
"android")
echo "当前系统是Mac操作系统." ;;
*)
echo "当前系统是${os}，未知操作系统类型." ;;
esac
|
运行 case.sh shell脚本，得到如下结果：
1
2
|
$ sh case.sh
当前系统是hello，未知操作系统类型.
|
case的默认分支语句用星号 * 通配符表示，这是shell中与其它常规编程语言的的一个区别。表示当所有其它分支测试条件都不满足时，将会执行默认分支。通俗地讲就是不管测试的具体值是什么总是有一个分支将会被执行。
循环
通过循环结构让程序重复的执行某种操作，直到条件为真的时，退出循环。
for
与其他编程语言类似，Shell支持for循环。 for 循环的一般格式为：
1
2
3
4
5
6
7
|
for 变量 in 列表; do
command1
command2
command3
...
commandN
done
|
列表是一组值（数字、字符串等）组成的序列，第个值通过空格分隔。每循环一次，就将列表中的下一个值赋值给变量。in 列表是可选的，如果不用它，for 循环使用命令行的位置参数。
例如，定义一个 for-with-simple-list.sh shell脚本文件，顺序输出当前列表中的数字:
1
2
3
4
5
|
#!/bin/bash
for val in 1 2 3 4 5 6 7 8 9 10; do
echo "当前值为: ${val}"
done
|
执行 for-with-simple-list.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
8
9
10
11
|
$ sh for-with-simple-list.sh
当前值为: 1
当前值为: 2
当前值为: 3
当前值为: 4
当前值为: 5
当前值为: 6
当前值为: 7
当前值为: 8
当前值为: 9
当前值为: 10
|
接下来定义一个 for-with-string-char.sh shell脚本文件，以顺序输出字符串中的子字符串：
1
2
3
4
5
6
7
8
9
10
|
#!/bin/bash
# 普通变量定义
str='Hello World, 中国'
num=1
for c in ${str}; do
echo "字符串{${str}}，第${num}次循环获取到的子字符串为${c}"
num=$[num + 1]
done
|
执行 for-with-string-char.sh shell脚本文件，得到如下结果：
1
2
3
4
|
$ sh for-with-string-char.sh
字符串{Hello World, 中国}，第1次循环获取到的子字符串为Hello
字符串{Hello World, 中国}，第2次循环获取到的子字符串为World,
字符串{Hello World, 中国}，第3次循环获取到的子字符串为中国
|
再来看一个使用案例，定义一个 show-home-git-related-files.sh shell脚本文件，以顺序输出家目录下以 .git 开头的文件：
1
2
3
4
5
6
7
8
9
|
#!/bin/bash
# 普通变量定义
files=$HOME/.git*
# 循环输出每一个以 `.git` 开头的文件路径
for f in $files; do
echo "以{.git}开头的文件：${f}"
done
|
执行 show-home-git-related-files.sh shell脚本文件，得到如下结果：
1
2
3
4
|
$ sh show-home-git-related-files.sh
以{.git}开头的文件：/Users/helloshaohua/.gitconfig
以{.git}开头的文件：/Users/helloshaohua/.gitflow_export
以{.git}开头的文件：/Users/helloshaohua/.gitignore_global
|
while
while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为布尔表达式测试条件。其格式为：
1
2
3
|
while command; do
statements to be executed if command is true
done
|
命令执行完毕，当前一次的循环也就结束了，循环控制返回循环顶部，从头开始直至测试条件为假，while循环退出，继续下向执行代码。
来定义一个 while-with-counter-less-than-10.sh shell脚本文件，看一个基本的while循环如何使用，测试条件是：如果counter小10，那么返回true，否则返回false，counter从0开始，每次循环处理时，counter加1，当counter为10时，测试条件为false，while循环退出。
1
2
3
4
5
6
7
8
9
10
|
#!/bin/bash
# 普通变量定义
counter=0
# while 循环输出计数器的值
while [ $counter -lt 10 ]; do
counter=$[counter+1]
echo "第${counter}次循环，计数器为：${counter}"
done
|
执行 while-with-counter-less-than-10.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
8
9
10
11
|
$ sh while-with-counter-less-than-10.sh
第1次循环，计数器为：1
第2次循环，计数器为：2
第3次循环，计数器为：3
第4次循环，计数器为：4
第5次循环，计数器为：5
第6次循环，计数器为：6
第7次循环，计数器为：7
第8次循环，计数器为：8
第9次循环，计数器为：9
第10次循环，计数器为：10
|
while 读取文件内容，也非常方便，定义一个 read-files.sh shell脚本文件，以读取 /tmp/helloshaohua 目录下的所有文件内容并输出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/bin/bash
# 普通变量定义
files="/tmp/helloshaohua/*"
for fl in $files; do
# 检测是否是普通文件，并且文件内容不为空，
# 条件成立时读取，不成立时忽略该文件。
if [[ -f $fl && -s $fl ]]; then
# 循环读取每一行文件内容打印。
while IFS= read -r line; do
printf '%s\n' "$line"
done < $fl
fi
done
|
/tmp/helloshaohua目录具体的文件列表如下：
1
2
3
4
5
|
$ ll /tmp/helloshaohua
total 24
-rw-r--r-- 1 helloshaohua wheel 47B 5 20 18:11 a.txt
-rw-r--r-- 1 helloshaohua wheel 47B 5 20 18:13 b.txt
-rw-r--r-- 1 helloshaohua wheel 47B 5 20 18:13 c.txt
|
/tmp/helloshaohua目录具体的文件内容如下：
1
2
3
4
5
6
7
|
$ cat /tmp/helloshaohua/a.txt /tmp/helloshaohua/b.txt /tmp/helloshaohua/c.txt
This is a.txt file.
The file extension is txt.
This is b.txt file.
The file extension is txt.
This is c.txt file.
The file extension is txt.
|
执行 read-files.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
|
$ sh read-files.sh
This is a.txt file.
The file extension is txt.
This is b.txt file.
The file extension is txt.
This is c.txt file.
The file extension is txt.
|
可以看到打印出的文件内容信息，与cat多个文件是一致的。
while 循环可用于读取键盘输入信息。下面定义一个 read-input-data.sh shell脚本文件，以读取从自键盘的输入数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/bin/bash
echo '键入<CTRL-C>终止'
echo -n '输入您最喜欢的电影：'
while read FILE; do
# 如果输入的电影名为空，则提示输入，
# 否则输出关于该电影的评价。
if [ ${#FILE} -gt 0 ]; then
echo "是的！《${FILE}》非常赞的电影~"
else
echo -n '输入您最喜欢的电影：'
fi
done
|
执行 read-input-data.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
|
$ sh read-input-data.sh
键入<CTRL-C>终止
输入您最喜欢的电影：人之怒
是的！《人之怒》非常赞的电影~
输入您最喜欢的电影：hello
是的！《hello》非常赞的电影~
输入您最喜欢的电影：
|
你可以多次输入，按 CTRL-C 退出shell脚本程序运行。
until
until 循环执行一系列命令直至条件为 true 时停止。until 循环与 while 循环在处理方式上刚好相反。一般while循环优于until循环，但在某些时候，也只是极少数情况下，until 循环更加有用。until循环格式为：
1
2
3
|
until [ command ]; do
statements to be executed if command is false
done
|
command 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。
下面定义一个 until.sh shell脚本文件，以使用 until 命令输出 0 ~ 9 的数字：
1
2
3
4
5
6
7
8
9
10
|
#!/bin/bash
# 普通变量定义
counter=0
# until 循环输出
until [ ! $counter -lt 10 ]; do
echo "当前计数器为：${counter}"
counter=$[counter+1]
done
|
执行 until.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
8
9
10
11
|
$ sh until.sh
当前计数器为：0
当前计数器为：1
当前计数器为：2
当前计数器为：3
当前计数器为：4
当前计数器为：5
当前计数器为：6
当前计数器为：7
当前计数器为：8
当前计数器为：9
|
跳出循环
在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，像大多数编程语言一样，Shell也使用 break 和 continue 来跳出循环。
break命令
break命令允许跳出所有循环（终止执行当前循环结构后面的所有循环）。下面来定义一个 break-while.sh shell脚本文件，以测试脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，就要使用break命令。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/bin/bash
while : ; do
echo -n "输入1到5之间的数字: "
read NUMBER
case $NUMBER in
1|2|3|4|5)
echo "你输入的数字是：${NUMBER}"
;;
*)
echo "你输入的数字不是1到5之间的数字游戏结束~"
break
;;
esac
done
|
执行 break-while.sh shell脚本文件，得到如下结果：
1
2
3
4
5
6
7
8
9
10
11
|
$ sh break-while.sh
输入1到5之间的数字: 3
你输入的数字是：3
输入1到5之间的数字: 2
你输入的数字是：2
输入1到5之间的数字: 5
你输入的数字是：5
输入1到5之间的数字: 5
你输入的数字是：5
输入1到5之间的数字: 6
你输入的数字不是1到5之间的数字游戏结束~
|
在嵌套循环中，break 命令后面还可以跟一个整数，表示跳出第几层循环。例如：
表示跳出第n层循环。
continue