【大数据】08脚本编程（下）

1、Shell 

Shell 是一个用C语言编写的程序&＃xff0c;它是用户使用Linux的桥梁。Shell既是一种命令语言&＃xff0c;又是一种程序设计语言。

Shell 是指一种应用程序&＃xff0c;这个应用程序提供了一个界面&＃xff0c;用户通过这个界面访问操作系统内核的服务。

Ken Thompson的sh是第一种Unix Shell&＃xff0c;Windows Explorer是一个典型的图形界面Shell。

---

Shell 脚本

Shell 脚本&＃xff08;shell script&＃xff09;&＃xff0c;是一种为shell编写的脚本程序。

业界所说的shell通常都是指shell脚本&＃xff0c;但读者朋友要知道&＃xff0c;shell和shell script是两个不同的概念。

由于习惯的原因&＃xff0c;简洁起见&＃xff0c;本文出现的”shell编程”都是指shell脚本编程&＃xff0c;不是指开发shell自身。

---

Shell 环境

Shell 编程跟java、php编程一样&＃xff0c;只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Linux的Shell种类众多&＃xff0c;常见的有&＃xff1a;

• Bourne Shell&＃xff08;/usr/bin/sh或/bin/sh&＃xff09;
• Bourne Again Shell&＃xff08;/bin/bash&＃xff09;
• C Shell&＃xff08;/usr/bin/csh&＃xff09;
• K Shell&＃xff08;/usr/bin/ksh&＃xff09;
• Shell for Root&＃xff08;/sbin/sh&＃xff09;
• ……

本教程关注的是 Bash&＃xff0c;也就是 Bourne Again Shell&＃xff0c;由于易用和免费&＃xff0c;Bash在日常工作中被广泛使用。同时&＃xff0c;Bash也是大多数Linux系统默认的Shell。

在一般情况下&＃xff0c;人们并不区分 Bourne Shell 和 Bourne Again Shell&＃xff0c;所以&＃xff0c;像 #!/bin/sh&＃xff0c;它同样也可以改为#!/bin/bash。

#!告诉系统其后路径所指定的程序即是解释此脚本文件的Shell程序。

---

第一个shell脚本

打开文本编辑器(可以使用vi/vim命令来创建文件)&＃xff0c;新建一个文件test.sh&＃xff0c;扩展名为sh&＃xff08;sh代表shell&＃xff09;&＃xff0c;扩展名并不影响脚本执行&＃xff0c;见名知意就好&＃xff0c;如果你用php写shell 脚本&＃xff0c;扩展名就用php好了。

输入一些代码&＃xff0c;第一行一般是这样&＃xff1a;

实例

#!/bin/bash
echo “Hello World !”

“#!” 是一个约定的标记&＃xff0c;它告诉系统这个脚本需要什么解释器来执行&＃xff0c;即使用哪一种Shell。

echo命令用于向窗口输出文本。

运行Shell脚本有两种方法&＃xff1a;

1、作为可执行程序

将上面的代码保存为test.sh&＃xff0c;并cd到相应目录&＃xff1a;

chmod &＃43;x ./test.sh #使脚本具有执行权限
./test.sh #执行脚本

注意&＃xff0c;一定要写成./test.sh&＃xff0c;而不是test.sh&＃xff0c;运行其它二进制的程序也一样&＃xff0c;直接写test.sh&＃xff0c;linux系统会去PATH里寻找有没有叫test.sh的&＃xff0c;而只有/bin, /sbin, /usr/bin&＃xff0c;/usr/sbin等在PATH里&＃xff0c;你的当前目录通常不在PATH里&＃xff0c;所以写成test.sh是会找不到命令的&＃xff0c;要用./test.sh告诉系统说&＃xff0c;就在当前目录找。

2、作为解释器参数

这种运行方式是&＃xff0c;直接运行解释器&＃xff0c;其参数就是shell脚本的文件名&＃xff0c;如&＃xff1a;

/bin/sh test.sh
/bin/php test.php

这种方式运行的脚本&＃xff0c;不需要在第一行指定解释器信息&＃xff0c;写了也没用。

彩蛋 &＃xff1a;

sh/bash/csh/Tcsh/ksh/pdksh等shell的区别

• sh(全称 Bourne Shell): 是UNIX最初使用的 shell&＃xff0c;而且在每种 UNIX 上都可以使用。
  Bourne Shell 在 shell 编程方便相当优秀&＃xff0c;但在处理与用户的交互方便作得不如其他几种 shell。
• bash&＃xff08;全称 Bourne Again Shell&＃xff09;: LinuxOS 默认的&＃xff0c;它是 Bourne Shell 的扩展。
  与 Bourne Shell 完全兼容&＃xff0c;并且在 Bourne Shell 的基础上增加了很多特性。可以提供命令补全&＃xff0c;命令编辑和命令历史等功能。它还包含了很多 C Shell 和 Korn Shell 中的优点&＃xff0c;有灵活和强大的编辑接口&＃xff0c;同时又很友好的用户界面。
• csh(全称 C Shell): 是一种比 Bourne Shell更适合的变种 Shell&＃xff0c;它的语法与 C 语言很相似。
• Tcsh: 是 Linux 提供的 C Shell 的一个扩展版本。
  Tcsh 包括命令行编辑&＃xff0c;可编程单词补全&＃xff0c;拼写校正&＃xff0c;历史命令替换&＃xff0c;作业控制和类似 C 语言的语法&＃xff0c;他不仅和 Bash Shell 提示符兼容&＃xff0c;而且还提供比 Bash Shell 更多的提示符参数。
• ksh (全称 Korn Shell): 集合了 C Shell 和 Bourne Shell 的优点并且和 Bourne Shell 完全兼容。
• pdksh: 是 Linux 系统提供的 ksh 的扩展。
  pdksh 支持人物控制&＃xff0c;可以在命令行上挂起&＃xff0c;后台执行&＃xff0c;唤醒或终止程序

---

2、Shell 变量

定义变量时&＃xff0c;变量名不加美元符号&＃xff08;$&＃xff0c;PHP语言中变量需要&＃xff09;&＃xff0c;如&＃xff1a;

your_url&＃61;"www.csdn.net"

注意&＃xff0c;变量名和等号之间不能有空格&＃xff0c;这可能和你熟悉的所有编程语言都不一样。同时&＃xff0c;变量名的命名须遵循如下规则&＃xff1a;

• 首个字符必须为字母&＃xff08;a-z&＃xff0c;A-Z&＃xff09;。
• 中间不能有空格&＃xff0c;可以使用下划线&＃xff08;_&＃xff09;。
• 不能使用标点符号。
• 不能使用bash里的关键字&＃xff08;可用help命令查看保留关键字&＃xff09;。

除了显式地直接赋值&＃xff0c;还可以用语句给变量赋值&＃xff0c;如&＃xff1a;

for file in &＃96;ls /etc&＃96;

以上语句将 /etc 下目录的文件名循环出来。

---

使用变量

使用一个定义过的变量&＃xff0c;只要在变量名前面加美元符号即可&＃xff0c;如&＃xff1a;

your_name&＃61;"csdn"
echo $your_name
echo ${your_name}

变量名外面的花括号是可选的&＃xff0c;加不加都行&＃xff0c;加花括号是为了帮助解释器识别变量的边界&＃xff0c;比如下面这种情况&＃xff1a;

for skill in Ada Coffe Action Java; doecho "I am good at ${skill}Script"
done

如果不给skill变量加花括号&＃xff0c;写成echo “I am good at $skillScript”&＃xff0c;解释器就会把$skillScript当成一个变量&＃xff08;其值为空&＃xff09;&＃xff0c;代码执行结果就不是我们期望的样子了。

推荐给所有变量加上花括号&＃xff0c;这是个好的编程习惯。

已定义的变量&＃xff0c;可以被重新定义&＃xff0c;如&＃xff1a;

your_name&＃61;"tom"
echo $your_name
your_name&＃61;"alibaba"
echo $your_name

这样写是合法的&＃xff0c;但注意&＃xff0c;第二次赋值的时候不能写$your_name&＃61;”alibaba”&＃xff0c;使用变量的时候才加美元符&＃xff08;$&＃xff09;。

只读变量

使用 readonly 命令可以将变量定义为只读变量&＃xff0c;只读变量的值不能被改变。

下面的例子尝试更改只读变量&＃xff0c;结果报错&＃xff1a;

#!/bin/bash
myUrl&＃61;"http://www.csdn.net"
readonly myUrl
myUrl&＃61;"http://www.baidu.com"

运行脚本&＃xff0c;结果如下&＃xff1a;

/bin/sh: NAME: This variable is read only.

删除变量

使用 unset 命令可以删除变量。语法&＃xff1a;

unset variable_name

变量被删除后不能再次使用。unset 命令不能删除只读变量。

实例

#!/bin/sh
myUrl&＃61;"http://www.baidu.com"
unset myUrl
echo $myUrl

以上实例执行将没有任何输出。

变量类型

运行shell时&＃xff0c;会同时存在三种变量&＃xff1a;

• 1) 局部变量 局部变量在脚本或命令中定义&＃xff0c;仅在当前shell实例中有效&＃xff0c;其他shell启动的程序不能访问局部变量。
• 2) 环境变量 所有的程序&＃xff0c;包括shell启动的程序&＃xff0c;都能访问环境变量&＃xff0c;有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
• 3) shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量&＃xff0c;有一部分是局部变量&＃xff0c;这些变量保证了shell的正常运行

---

Shell 字符串

字符串是shell编程中最常用最有用的数据类型&＃xff08;除了数字和字符串&＃xff0c;也没啥其它类型好用了&＃xff09;&＃xff0c;字符串可以用单引号&＃xff0c;也可以用双引号&＃xff0c;也可以不用引号。单双引号的区别跟PHP类似。

单引号

str&＃61;&＃39;this is a string&＃39;

单引号字符串的限制&＃xff1a;

• 单引号里的任何字符都会原样输出&＃xff0c;单引号字符串中的变量是无效的&＃xff1b;
• 单引号字串中不能出现单引号&＃xff08;对单引号使用转义符后也不行&＃xff09;。

双引号

your_name&＃61;&＃39;csdn&＃39;
str&＃61;"Hello, I know your are \"$your_name\"! \n"

双引号的优点&＃xff1a;

• 双引号里可以有变量
• 双引号里可以出现转义字符

拼接字符串

your_name&＃61;"csdn"
greeting&＃61;"hello, "$your_name" !"
greeting_1&＃61;"hello, ${your_name} !"
echo $greeting $greeting_1

获取字符串长度

string&＃61;"abcd"
echo ${#string} #输出 4

提取子字符串

以下实例从字符串第 2 个字符开始截取 4 个字符&＃xff1a;

string&＃61;"ipcmen is a great site"
echo ${string:1:4} # 输出 unoo

查找子字符串

查找字符 “i 或 s” 的位置&＃xff1a;

string&＃61;"ipcmen is a great company"
echo &＃96;expr index "$string" is&＃96; # 输出 8

注意&＃xff1a; 以上脚本中 “&＃96;” 是反引号&＃xff0c;而不是单引号 “‘”&＃xff0c;不要看错了哦。

---

Shell 数组

bash支持一维数组&＃xff08;不支持多维数组&＃xff09;&＃xff0c;并且没有限定数组的大小。

类似与C语言&＃xff0c;数组元素的下标由0开始编号。获取数组中的元素要利用下标&＃xff0c;下标可以是整数或算术表达式&＃xff0c;其值应大于或等于0。

定义数组

在Shell中&＃xff0c;用括号来表示数组&＃xff0c;数组元素用”空格”符号分割开。定义数组的一般形式为&＃xff1a;

数组名&＃61;(值1 值2 ... 值n)

例如&＃xff1a;

array_name&＃61;(value0 value1 value2 value3)

或者

array_name&＃61;(
value0
value1
value2
value3
)

还可以单独定义数组的各个分量&＃xff1a;

array_name[0]&＃61;value0
array_name[1]&＃61;value1
array_name[n]&＃61;valuen

可以不使用连续的下标&＃xff0c;而且下标的范围没有限制。

读取数组

读取数组元素值的一般格式是&＃xff1a;

${数组名[下标]}

例如&＃xff1a;

valuen&＃61;${array_name[n]}

使用&＃64;符号可以获取数组中的所有元素&＃xff0c;例如&＃xff1a;

echo ${array_name[&＃64;]}

获取数组的长度

获取数组长度的方法与获取字符串长度的方法相同&＃xff0c;例如&＃xff1a;

# 取得数组元素的个数
length&＃61;${#array_name[&＃64;]}
# 或者
length&＃61;${#array_name[*]}
# 取得数组单个元素的长度
lengthn&＃61;${#array_name[n]}

---

Shell 注释

以”#”开头的行就是注释&＃xff0c;会被解释器忽略。

sh里没有多行注释&＃xff0c;只能每一行加一个#号。只能像这样&＃xff1a;

#--------------------------------------------
# 这是一个注释
# author&＃xff1a;csdn
# site&＃xff1a;www.csdn.com
# slogan&＃xff1a;学的不仅是技术&＃xff0c;更是梦想&＃xff01;
#--------------------------------------------
##### 用户配置区 开始 #####
#
#
# 这里可以添加脚本描述信息
#
#
##### 用户配置区 结束 #####

如果在开发过程中&＃xff0c;遇到大段的代码需要临时注释起来&＃xff0c;过一会儿又取消注释&＃xff0c;怎么办呢&＃xff1f;

每一行加个#符号太费力了&＃xff0c;可以把这一段要注释的代码用一对花括号括起来&＃xff0c;定义成一个函数&＃xff0c;没有地方调用这个函数&＃xff0c;这块代码就不会执行&＃xff0c;达到了和注释一样的效果。

---

3、Shell 传递参数

我们可以在执行 Shell 脚本时&＃xff0c;向脚本传递参数&＃xff0c;脚本内获取参数的格式为&＃xff1a;$n。n 代表一个数字&＃xff0c;1 为执行脚本的第一个参数&＃xff0c;2 为执行脚本的第二个参数&＃xff0c;以此类推……

实例

以下实例我们向脚本传递三个参数&＃xff0c;并分别输出&＃xff0c;其中 $0 为执行的文件名&＃xff1a;

#!/bin/bash
# author:csdn
# url:www.csdn.comecho "Shell 传递参数实例&＃xff01;";
echo "执行的文件名&＃xff1a;$0";
echo "第一个参数为&＃xff1a;$1";
echo "第二个参数为&＃xff1a;$2";
echo "第三个参数为&＃xff1a;$3";

为脚本设置可执行权限&＃xff0c;并执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例&＃xff01;
执行的文件名&＃xff1a;./test.sh
第一个参数为&＃xff1a;1
第二个参数为&＃xff1a;2
第三个参数为&＃xff1a;3

另外&＃xff0c;还有几个特殊字符用来处理参数&＃xff1a;

参数处理	说明
$#	传递到脚本的参数个数
$*	以一个单字符串显示所有向脚本传递的参数。 如”$*”用「”」括起来的情况、以”$1 $2 … $n”的形式输出所有参数。
$$	脚本运行的当前进程ID号
$!	后台运行的最后一个进程的ID号
$&＃64;	与$*相同&＃xff0c;但是使用时加引号&＃xff0c;并在引号中返回每个参数。 如”$&＃64;”用「”」括起来的情况、以”$1″ “$2” … “$n” 的形式输出所有参数。
$-	显示Shell使用的当前选项&＃xff0c;与set命令功能相同。
$?	显示最后命令的退出状态。0表示没有错误&＃xff0c;其他任何值表明有错误。

#!/bin/bash
# author:csdn
# url:www.csdn.comecho "Shell 传递参数实例&＃xff01;";
echo "第一个参数为&＃xff1a;$1";echo "参数个数为&＃xff1a;$#";
echo "传递的参数作为一个字符串显示&＃xff1a;$*";

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例&＃xff01;
第一个参数为&＃xff1a;1
参数个数为&＃xff1a;3
传递的参数作为一个字符串显示&＃xff1a;1 2 3

$* 与 $&＃64; 区别&＃xff1a;

• 相同点&＃xff1a;都是引用所有参数。
• 不同点&＃xff1a;只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3&＃xff0c;&＃xff0c;则 ” * ” 等价于 “1 2 3″&＃xff08;传递了一个参数&＃xff09;&＃xff0c;而 “&＃64;” 等价于 “1” “2” “3”&＃xff08;传递了三个参数&＃xff09;。

#!/bin/bash
# author:IPCMEN
# url:www.ipcmen.comecho "-- \$* 演示 ---"
for i in "$*"; doecho $i
doneecho "-- \$&＃64; 演示 ---"
for i in "$&＃64;"; doecho $i
done

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh 1 2 3
-- $* 演示 ---
1 2 3
-- $&＃64; 演示 ---
1
2
3

---

4、Shell 数组

数组中可以存放多个值。Bash Shell 只支持一维数组&＃xff08;不支持多维数组&＃xff09;&＃xff0c;初始化时不需要定义数组大小&＃xff08;与 PHP 类似&＃xff09;。

与大部分编程语言类似&＃xff0c;数组元素的下标由0开始。

Shell 数组用括号来表示&＃xff0c;元素用”空格”符号分割开&＃xff0c;语法格式如下&＃xff1a;

array_name&＃61;(value1 ... valuen)

实例

#!/bin/bash
# author:csdn
# url:www.csdn.netmy_array&＃61;(A B "C" D)

我们也可以使用下标来定义数组:

array_name[0]&＃61;value0
array_name[1]&＃61;value1
array_name[2]&＃61;value2

读取数组

读取数组元素值的一般格式是&＃xff1a;

${array_name[index]}

实例

#!/bin/bash
# author:csdn
# url:www.csdn.netmy_array&＃61;(A B "C" D)echo "第一个元素为: ${my_array[0]}"
echo "第二个元素为: ${my_array[1]}"
echo "第三个元素为: ${my_array[2]}"
echo "第四个元素为: ${my_array[3]}"

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh
第一个元素为: A
第二个元素为: B
第三个元素为: C
第四个元素为: D

获取数组中的所有元素

使用&＃64; 或 * 可以获取数组中的所有元素&＃xff0c;例如&＃xff1a;

#!/bin/bash
# author:csdn
# url:www.csdn.netmy_array[0]&＃61;A
my_array[1]&＃61;B
my_array[2]&＃61;C
my_array[3]&＃61;Decho "数组的元素为: ${my_array[*]}"
echo "数组的元素为: ${my_array[&＃64;]}"

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh
数组的元素为: A B C D
数组的元素为: A B C D

获取数组的长度

获取数组长度的方法与获取字符串长度的方法相同&＃xff0c;例如&＃xff1a;

#!/bin/bashmy_array[0]&＃61;A
my_array[1]&＃61;B
my_array[2]&＃61;C
my_array[3]&＃61;Decho "数组元素个数为: ${#my_array[*]}"
echo "数组元素个数为: ${#my_array[&＃64;]}"

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

$ chmod &＃43;x test.sh
$ ./test.sh
数组元素个数为: 4
数组元素个数为: 4

---

5、Shell 基本运算符

Shell 和其他编程语言一样&＃xff0c;支持多种运算符&＃xff0c;包括&＃xff1a;

• 算数运算符
• 关系运算符
• 布尔运算符
• 字符串运算符
• 文件测试运算符

原生bash不支持简单的数学运算&＃xff0c;但是可以通过其他命令来实现&＃xff0c;例如 awk 和 expr&＃xff0c;expr 最常用。

expr 是一款表达式计算工具&＃xff0c;使用它能完成表达式的求值操作。

例如&＃xff0c;两个数相加(注意使用的是反引号 &＃96; 而不是单引号 ‘)&＃xff1a;

#!/bin/bashval&＃61;&＃96;expr 2 &＃43; 2&＃96;
echo "两数之和为 : $val"

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

两数之和为 : 4

两点注意&＃xff1a;

• 表达式和运算符之间要有空格&＃xff0c;例如 2&＃43;2 是不对的&＃xff0c;必须写成 2 &＃43; 2&＃xff0c;这与我们熟悉的大多数编程语言不一样。
• 完整的表达式要被 &＃96; &＃96; 包含&＃xff0c;注意这个字符不是常用的单引号&＃xff0c;在 Esc 键下边。

---

算术运算符

下表列出了常用的算术运算符&＃xff0c;假定变量 a 为 10&＃xff0c;变量 b 为 20&＃xff1a;

运算符	说明	举例
&＃43;	加法	&＃96;expr $a &＃43; $b&＃96; 结果为 30。
–	减法	&＃96;expr $a – $b&＃96; 结果为 -10。
*	乘法	&＃96;expr $a \* $b&＃96; 结果为  200。
/	除法	&＃96;expr $b / $a&＃96; 结果为 2。
%	取余	&＃96;expr $b % $a&＃96; 结果为 0。
&＃61;	赋值	a&＃61;$b 将把变量 b 的值赋给 a。
&＃61;&＃61;	相等。用于比较两个数字&＃xff0c;相同则返回 true。	[ $a &＃61;&＃61; $b ] 返回 false。
!&＃61;	不相等。用于比较两个数字&＃xff0c;不相同则返回 true。	[ $a !&＃61; $b ] 返回 true。

注意&＃xff1a;条件表达式要放在方括号之间&＃xff0c;并且要有空格&＃xff0c;例如: [$a&＃61;&＃61;$b] 是错误的&＃xff0c;必须写成 [ $a &＃61;&＃61; $b ]。

实例

算术运算符实例如下&＃xff1a;

#!/bin/basha&＃61;10
b&＃61;20val&＃61;&＃96;expr $a &＃43; $b&＃96;
echo "a &＃43; b : $val"val&＃61;&＃96;expr $a - $b&＃96;
echo "a - b : $val"val&＃61;&＃96;expr $a \* $b&＃96;
echo "a * b : $val"val&＃61;&＃96;expr $b / $a&＃96;
echo "b / a : $val"val&＃61;&＃96;expr $b % $a&＃96;
echo "b % a : $val"if [ $a &＃61;&＃61; $b ]
thenecho "a 等于 b"
fi
if [ $a !&＃61; $b ]
thenecho "a 不等于 b"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

a &＃43; b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等于 b

注意&＃xff1a;

• 乘号(*)前边必须加反斜杠(\)才能实现乘法运算&＃xff1b;
• if…then…fi 是条件语句&＃xff0c;后续将会讲解。
• 在 MAC 中 shell 的 expr 语法是&＃xff1a;$((表达式))&＃xff0c;此处表达式中的 “*” 不需要转义符号 “\” 。

---

关系运算符

关系运算符只支持数字&＃xff0c;不支持字符串&＃xff0c;除非字符串的值是数字。

下表列出了常用的关系运算符&＃xff0c;假定变量 a 为 10&＃xff0c;变量 b 为 20&＃xff1a;

运算符	说明	举例
-eq	检测两个数是否相等&＃xff0c;相等返回 true。	[ $a -eq $b ] 返回 false。
-ne	检测两个数是否相等&＃xff0c;不相等返回 true。	[ $a -ne $b ] 返回 true。
-gt	检测左边的数是否大于右边的&＃xff0c;如果是&＃xff0c;则返回 true。	[ $a -gt $b ] 返回 false。
-lt	检测左边的数是否小于右边的&＃xff0c;如果是&＃xff0c;则返回 true。	[ $a -lt $b ] 返回 true。
-ge	检测左边的数是否大于等于右边的&＃xff0c;如果是&＃xff0c;则返回 true。	[ $a -ge $b ] 返回 false。
-le	检测左边的数是否小于等于右边的&＃xff0c;如果是&＃xff0c;则返回 true。	[ $a -le $b ] 返回 true。

实例

关系运算符实例如下&＃xff1a;

#!/bin/basha&＃61;10
b&＃61;20if [ $a -eq $b ]
thenecho "$a -eq $b : a 等于 b"
elseecho "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]
thenecho "$a -ne $b: a 不等于 b"
elseecho "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]
thenecho "$a -gt $b: a 大于 b"
elseecho "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]
thenecho "$a -lt $b: a 小于 b"
elseecho "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]
thenecho "$a -ge $b: a 大于或等于 b"
elseecho "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]
thenecho "$a -le $b: a 小于或等于 b"
elseecho "$a -le $b: a 大于 b"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

10 -eq 20: a 不等于 b
10 -ne 20: a 不等于 b
10 -gt 20: a 不大于 b
10 -lt 20: a 小于 b
10 -ge 20: a 小于 b
10 -le 20: a 小于或等于 b


---

布尔运算符

下表列出了常用的布尔运算符&＃xff0c;假定变量 a 为 10&＃xff0c;变量 b 为 20&＃xff1a;

运算符	说明	举例
!	非运算&＃xff0c;表达式为 true 则返回 false&＃xff0c;否则返回 true。	[ ! false ] 返回 true。
-o	或运算&＃xff0c;有一个表达式为 true 则返回 true。	[ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a	与运算&＃xff0c;两个表达式都为 true 才返回 true。	[ $a -lt 20 -a $b -gt 100 ] 返回 false。

实例

布尔运算符实例如下&＃xff1a;

#!/bin/basha&＃61;10
b&＃61;20if [ $a !&＃61; $b ]
thenecho "$a !&＃61; $b : a 不等于 b"
elseecho "$a !&＃61; $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
thenecho "$a -lt 100 -a $b -gt 15 : 返回 true"
elseecho "$a -lt 100 -a $b -gt 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
thenecho "$a -lt 100 -o $b -gt 100 : 返回 true"
elseecho "$a -lt 100 -o $b -gt 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
thenecho "$a -lt 100 -o $b -gt 100 : 返回 true"
elseecho "$a -lt 100 -o $b -gt 100 : 返回 false"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

10 !&＃61; 20 : a 不等于 b
10 -lt 100 -a 20 -gt 15 : 返回 true
10 -lt 100 -o 20 -gt 100 : 返回 true
10 -lt 100 -o 20 -gt 100 : 返回 false

---

逻辑运算符

以下介绍 Shell 的逻辑运算符&＃xff0c;假定变量 a 为 10&＃xff0c;变量 b 为 20:

运算符	说明	举例
&&	逻辑的 AND	[[ $a -lt 100 && $b -gt 100 ]] 返回 false
||	逻辑的 OR	[[ $a -lt 100 || $b -gt 100 ]] 返回 true

实例

逻辑运算符实例如下&＃xff1a;

#!/bin/basha&＃61;10
b&＃61;20if [[ $a -lt 100 && $b -gt 100 ]]
thenecho "返回 true"
elseecho "返回 false"
fiif [[ $a -lt 100 || $b -gt 100 ]]
thenecho "返回 true"
elseecho "返回 false"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

返回 false
返回 true

---

字符串运算符

下表列出了常用的字符串运算符&＃xff0c;假定变量 a 为 “abc”&＃xff0c;变量 b 为 “efg”&＃xff1a;

运算符	说明	举例
&＃61;	检测两个字符串是否相等&＃xff0c;相等返回 true。	[ $a &＃61; $b ] 返回 false。
!&＃61;	检测两个字符串是否相等&＃xff0c;不相等返回 true。	[ $a !&＃61; $b ] 返回 true。
-z	检测字符串长度是否为0&＃xff0c;为0返回 true。	[ -z $a ] 返回 false。
-n	检测字符串长度是否为0&＃xff0c;不为0返回 true。	[ -n $a ] 返回 true。
str	检测字符串是否为空&＃xff0c;不为空返回 true。	[ $a ] 返回 true。

实例

字符串运算符实例如下&＃xff1a;

#!/bin/basha&＃61;"abc"
b&＃61;"efg"if [ $a &＃61; $b ]
thenecho "$a &＃61; $b : a 等于 b"
elseecho "$a &＃61; $b: a 不等于 b"
fi
if [ $a !&＃61; $b ]
thenecho "$a !&＃61; $b : a 不等于 b"
elseecho "$a !&＃61; $b: a 等于 b"
fi
if [ -z $a ]
thenecho "-z $a : 字符串长度为 0"
elseecho "-z $a : 字符串长度不为 0"
fi
if [ -n $a ]
thenecho "-n $a : 字符串长度不为 0"
elseecho "-n $a : 字符串长度为 0"
fi
if [ $a ]
thenecho "$a : 字符串不为空"
elseecho "$a : 字符串为空"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

abc &＃61; efg: a 不等于 b
abc !&＃61; efg : a 不等于 b
-z abc : 字符串长度不为 0
-n abc : 字符串长度不为 0
abc : 字符串不为空

---

文件测试运算符

文件测试运算符用于检测 Unix 文件的各种属性。

属性检测描述如下&＃xff1a;

操作符	说明	举例
-b file	检测文件是否是块设备文件&＃xff0c;如果是&＃xff0c;则返回 true。	[ -b $file ] 返回 false。
-c file	检测文件是否是字符设备文件&＃xff0c;如果是&＃xff0c;则返回 true。	[ -c $file ] 返回 false。
-d file	检测文件是否是目录&＃xff0c;如果是&＃xff0c;则返回 true。	[ -d $file ] 返回 false。
-f file	检测文件是否是普通文件&＃xff08;既不是目录&＃xff0c;也不是设备文件&＃xff09;&＃xff0c;如果是&＃xff0c;则返回 true。	[ -f $file ] 返回 true。
-g file	检测文件是否设置了 SGID 位&＃xff0c;如果是&＃xff0c;则返回 true。	[ -g $file ] 返回 false。
-k file	检测文件是否设置了粘着位(Sticky Bit)&＃xff0c;如果是&＃xff0c;则返回 true。	[ -k $file ] 返回 false。
-p file	检测文件是否是有名管道&＃xff0c;如果是&＃xff0c;则返回 true。	[ -p $file ] 返回 false。
-u file	检测文件是否设置了 SUID 位&＃xff0c;如果是&＃xff0c;则返回 true。	[ -u $file ] 返回 false。
-r file	检测文件是否可读&＃xff0c;如果是&＃xff0c;则返回 true。	[ -r $file ] 返回 true。
-w file	检测文件是否可写&＃xff0c;如果是&＃xff0c;则返回 true。	[ -w $file ] 返回 true。
-x file	检测文件是否可执行&＃xff0c;如果是&＃xff0c;则返回 true。	[ -x $file ] 返回 true。
-s file	检测文件是否为空&＃xff08;文件大小是否大于0&＃xff09;&＃xff0c;不为空返回 true。	[ -s $file ] 返回 true。
-e file	检测文件&＃xff08;包括目录&＃xff09;是否存在&＃xff0c;如果是&＃xff0c;则返回 true。	[ -e $file ] 返回 true。

实例

变量 file 表示文件”/var/test.sh”&＃xff0c;它的大小为100字节&＃xff0c;具有 rwx 权限。下面的代码&＃xff0c;将检测该文件的各种属性&＃xff1a;

#!/bin/bashfile&＃61;"/var/test.sh"
if [ -r $file ]
thenecho "文件可读"
elseecho "文件不可读"
fi
if [ -w $file ]
thenecho "文件可写"
elseecho "文件不可写"
fi
if [ -x $file ]
thenecho "文件可执行"
elseecho "文件不可执行"
fi
if [ -f $file ]
thenecho "文件为普通文件"
elseecho "文件为特殊文件"
fi
if [ -d $file ]
thenecho "文件是个目录"
elseecho "文件不是个目录"
fi
if [ -s $file ]
thenecho "文件不为空"
elseecho "文件为空"
fi
if [ -e $file ]
thenecho "文件存在"
elseecho "文件不存在"
fi

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

文件可读
文件可写
文件可执行
文件为普通文件
文件不是个目录
文件不为空
文件存在


---

6、Shell echo命令

Shell 的 echo 指令与 PHP 的 echo 指令类似&＃xff0c;都是用于字符串的输出。命令格式&＃xff1a;

echo string

您可以使用echo实现更复杂的输出格式控制。

&＃xff08;1&＃xff09;.显示普通字符串:

echo "It is a test"

这里的双引号完全可以省略&＃xff0c;以下命令与上面实例效果一致&＃xff1a;

echo It is a test

&＃xff08;2&＃xff09;.显示转义字符

echo "\"It is a test\""

结果将是:

"It is a test"

同样&＃xff0c;双引号也可以省略

&＃xff08;3&＃xff09;.显示变量

read 命令从标准输入中读取一行,并把输入行的每个字段的值指定给 shell 变量

#!/bin/sh
read name
echo "$name It is a test"

以上代码保存为 test.sh&＃xff0c;name 接收标准输入的变量&＃xff0c;结果将是:

[root&＃64;www ~]# sh test.sh
OK #标准输入
OK It is a test #输出

&＃xff08;4&＃xff09;.显示换行

echo -e "OK! \n" # -e 开启转义
echo "It it a test"

输出结果&＃xff1a;

OK!It it a test

&＃xff08;5&＃xff09;.显示不换行

#!/bin/sh
echo -e "OK! \c" # -e 开启转义 \c 不换行
echo "It is a test"

输出结果&＃xff1a;

OK! It is a test

&＃xff08;6&＃xff09;.显示结果定向至文件

echo "It is a test" > myfile

&＃xff08;7&＃xff09;.原样输出字符串&＃xff0c;不进行转义或取变量(用单引号)

echo &＃39;$name\"&＃39;

输出结果&＃xff1a;

$name\"

&＃xff08;8&＃xff09;.显示命令执行结果

echo &＃96;date&＃96;

结果将显示当前日期

2019年 11月 23日 星期六 03:41:49 CST

---

7、Shell printf命令

前面我们学习了 Shell 的 echo 命令&＃xff0c;接下来我们来学习 Shell 的另一个输出命令 printf。

printf 命令模仿 C 程序库&＃xff08;library&＃xff09;里的 printf() 程序。

标准所定义&＃xff0c;因此使用printf的脚本比使用echo移植性好。

printf 使用引用文本或空格分隔的参数&＃xff0c;外面可以在printf中使用格式化字符串&＃xff0c;还可以制定字符串的宽度、左右对齐方式等。默认printf不会像 echo 自动添加换行符&＃xff0c;我们可以手动添加 \n。

printf 命令的语法&＃xff1a;

printf format-string [arguments...]

参数说明&＃xff1a;

• format-string: 为格式控制字符串
• arguments: 为参数列表。

实例如下&＃xff1a;

$ echo "Hello, Shell"
Hello, Shell
$ printf "Hello, Shell\n"
Hello, Shell
$

接下来,我来用一个脚本来体现printf的强大功能&＃xff1a;

#!/bin/bashprintf "%-10s %-8s %-4s\n" 姓名 性别 体重kg
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

姓名 性别 体重kg
郭靖 男 66.12
杨过 男 48.65
郭芙 女 47.99

%s %c %d %f都是格式替代符

%-10s 指一个宽度为10个字符&＃xff08;-表示左对齐&＃xff0c;没有则表示右对齐&＃xff09;&＃xff0c;任何字符都会被显示在10个字符宽的字符内&＃xff0c;如果不足则自动以空格填充&＃xff0c;超过也会将内容全部显示出来。

%-4.2f 指格式化为小数&＃xff0c;其中.2指保留2位小数。

更多实例&＃xff1a;

#!/bin/bash# format-string为双引号
printf "%d %s\n" 1 "abc"# 单引号与双引号效果一样
printf &＃39;%d %s\n&＃39; 1 "abc" # 没有引号也可以输出
printf %s abcdef# 格式只指定了一个参数&＃xff0c;但多出的参数仍然会按照该格式输出&＃xff0c;format-string 被重用
printf %s abc defprintf "%s\n" abc defprintf "%s %s %s\n" a b c d e f g h i j# 如果没有 arguments&＃xff0c;那么 %s 用NULL代替&＃xff0c;%d 用 0 代替
printf "%s and %d \n"

执行脚本&＃xff0c;输出结果如下所示&＃xff1a;

1 abc
1 abc
abcdefabcdefabc
def
a b c
d e f
g h i
j and 0

---

printf的转义序列

序列	说明
\a	警告字符&＃xff0c;通常为ASCII的BEL字符
\b	后退
\c	抑制&＃xff08;不显示&＃xff09;输出结果中任何结尾的换行字符&＃xff08;只在%b格式指示符控制下的参数字符串中有效&＃xff09;&＃xff0c;而且&＃xff0c;任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符&＃xff0c;都被忽略
\f	换页&＃xff08;formfeed&＃xff09;
\n	换行
\r	回车&＃xff08;Carriage return&＃xff09;
\t	水平制表符
\v	垂直制表符
\\	一个字面上的反斜杠字符
\ddd	表示1到3位数八进制值的字符。仅在格式字符串中有效
\0ddd	表示1到3位的八进制值字符

实例

[root&＃64;node0001 ~]# printf "a string, no processing:<%s>\n" "A\nB"
a string, no processing:[root&＃64;node0001 ~]# printf "a string, no processing:<%b>\n" "A\nB"
a string, no processing:B>[root&＃64;node0001 ~]# printf "www.csdn.net \a"
www.csdn.net [root&＃64;node0001 ~]#


---

8、Shell test 命令

Shell中的 test 命令用于检查某个条件是否成立&＃xff0c;它可以进行数值、字符和文件三个方面的测试。

---

数值测试

参数	说明
-eq	等于则为真
-ne	不等于则为真
-gt	大于则为真
-ge	大于等于则为真
-lt	小于则为真
-le	小于等于则为真

实例演示&＃xff1a;

num1&＃61;100
num2&＃61;100
if test $[num1] -eq $[num2]
thenecho &＃39;两个数相等&＃xff01;&＃39;
elseecho &＃39;两个数不相等&＃xff01;&＃39;
fi

输出结果&＃xff1a;

两个数相等&＃xff01;

代码中的 [] 执行基本的算数运算&＃xff0c;如&＃xff1a;

#!/bin/basha&＃61;5
b&＃61;6result&＃61;$[a&＃43;b] # 注意等号两边不能有空格
echo "result 为&＃xff1a; $result"

结果为:

result 为&＃xff1a; 11


---

字符串测试

参数	说明
&＃61;	等于则为真
!&＃61;	不相等则为真
-z 字符串	字符串的长度为零则为真
-n 字符串	字符串的长度不为零则为真

实例演示&＃xff1a;

num1&＃61;"ru1noob"
num2&＃61;"csdn"
if test $num1 &＃61; $num2
thenecho &＃39;两个字符串相等!&＃39;
elseecho &＃39;两个字符串不相等!&＃39;
fi

输出结果&＃xff1a;

两个字符串不相等!

---

文件测试

参数	说明
-e 文件名	如果文件存在则为真
-r 文件名	如果文件存在且可读则为真
-w 文件名	如果文件存在且可写则为真
-x 文件名	如果文件存在且可执行则为真
-s 文件名	如果文件存在且至少有一个字符则为真
-d 文件名	如果文件存在且为目录则为真
-f 文件名	如果文件存在且为普通文件则为真
-c 文件名	如果文件存在且为字符型特殊文件则为真
-b 文件名	如果文件存在且为块特殊文件则为真

实例演示&＃xff1a;

cd /bin
if test -e ./bash
thenecho &＃39;文件已存在!&＃39;
elseecho &＃39;文件不存在!&＃39;
fi

输出结果&＃xff1a;

文件已存在!

另外&＃xff0c;Shell还提供了与( -a )、或( -o )、非( ! )三个逻辑操作符用于将测试条件连接起来&＃xff0c;其优先级为&＃xff1a;”!”最高&＃xff0c;”-a”次之&＃xff0c;”-o”最低。例如&＃xff1a;

cd /bin
if test -e ./notFile -o -e ./bash
thenecho &＃39;有一个文件存在!&＃39;
elseecho &＃39;两个文件都不存在&＃39;
fi

输出结果&＃xff1a;

有一个文件存在!

---

9、Shell 流程控制

和Java、PHP等语言不一样&＃xff0c;sh的流程控制不可为空&＃xff0c;如(以下为PHP流程控制写法)&＃xff1a;

if (isset($_GET["q"])) {search(q);
}
else {// 不做任何事情
}

在sh/bash里可不能这么写&＃xff0c;如果else分支没有语句执行&＃xff0c;就不要写这个else。

---

if else

if

if 语句语法格式&＃xff1a;

if condition
thencommand1 command2...commandN
fi

写成一行&＃xff08;适用于终端命令提示符&＃xff09;&＃xff1a;

if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi

末尾的fi就是if倒过来拼写&＃xff0c;后面还会遇到类似的。

if else

if else 语法格式&＃xff1a;

if condition
thencommand1 command2...commandN
elsecommand
fi

if else-if else

if else-if else 语法格式&＃xff1a;

if condition1
thencommand1
elif condition2
then command2
elsecommandN
fi

以下实例判断两个变量是否相等&＃xff1a;

a&＃61;10
b&＃61;20
if [ $a &＃61;&＃61; $b ]
thenecho "a 等于 b"
elif [ $a -gt $b ]
thenecho "a 大于 b"
elif [ $a -lt $b ]
thenecho "a 小于 b"
elseecho "没有符合的条件"
fi

输出结果&＃xff1a;

a 小于 b

if else语句经常与test命令结合使用&＃xff0c;如下所示&＃xff1a;

num1&＃61;$[2*3]
num2&＃61;$[1&＃43;5]
if test $[num1] -eq $[num2]
thenecho &＃39;两个数字相等!&＃39;
elseecho &＃39;两个数字不相等!&＃39;
fi

输出结果&＃xff1a;

两个数字相等!

---

for 循环

与其他编程语言类似&＃xff0c;Shell支持for循环。

for循环一般格式为&＃xff1a;

for var in item1 item2 ... itemN
docommand1command2...commandN
done

写成一行&＃xff1a;

for var in item1 item2 ... itemN; do command1; command2… done;

当变量值在列表里&＃xff0c;for循环即执行一次所有命令&＃xff0c;使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。in列表可以包含替换、字符串和文件名。

in列表是可选的&＃xff0c;如果不用它&＃xff0c;for循环使用命令行的位置参数。

例如&＃xff0c;顺序输出当前列表中的数字&＃xff1a;

for loop in 1 2 3 4 5
doecho "The value is: $loop"
done

输出结果&＃xff1a;

The value is: 1
The value is: 2
The value is: 3
The value is: 4
The value is: 5

顺序输出字符串中的字符&＃xff1a;

for str in &＃39;This is a string&＃39;
doecho $str
done

输出结果&＃xff1a;

This is a string


---

while 语句

while循环用于不断执行一系列命令&＃xff0c;也用于从输入文件中读取数据&＃xff1b;命令通常为测试条件。其格式为&＃xff1a;

while condition
docommand
done

以下是一个基本的while循环&＃xff0c;测试条件是&＃xff1a;如果int小于等于5&＃xff0c;那么条件返回真。int从0开始&＃xff0c;每次循环处理时&＃xff0c;int加1。运行上述脚本&＃xff0c;返回数字1到5&＃xff0c;然后终止。

#!/bin/sh
int&＃61;1
while(( $int<&＃61;5 ))
doecho $intlet "int&＃43;&＃43;"
done

运行脚本&＃xff0c;输出&＃xff1a;

1
2
3
4
5

使用中使用了 Bash let 命令&＃xff0c;它用于执行一个或多个表达式&＃xff0c;变量计算中不需要加上 $ 来表示变量。while循环可用于读取键盘信息。下面的例子中&＃xff0c;输入信息被设置为变量FILM&＃xff0c;按结束循环。

echo &＃39;按下 退出&＃39;
echo -n &＃39;输入你最喜欢的电影名: &＃39;
while read FILM
doecho "是的&＃xff01;$FILM 是一部好电影"
done

运行脚本&＃xff0c;输出类似下面&＃xff1a;

按下 退出
输入你最喜欢的电影名: love
是的&＃xff01;love 是一部好电影

无限循环

无限循环语法格式&＃xff1a;

while :
docommand
done

或者

while true
docommand
done

或者

for (( ; ; ))

---

until 循环

until循环执行一系列命令直至条件为真时停止。

until循环与while循环在处理方式上刚好相反。

一般while循环优于until循环&＃xff0c;但在某些时候—也只是极少数情况下&＃xff0c;until循环更加有用。

until 语法格式:

until condition
docommand
done

条件可为任意测试条件&＃xff0c;测试发生在循环末尾&＃xff0c;因此循环至少执行一次—请注意这一点。

---

case

Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式&＃xff0c;如果匹配成功&＃xff0c;执行相匹配的命令。case语句格式如下&＃xff1a;

case 值 in
模式1)command1command2...commandN;;
模式2&＃xff09;command1command2...commandN;;
esac

case工作方式如上所示。取值后面必须为单词in&＃xff0c;每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后&＃xff0c;其间所有命令开始执行直至 ;;。

取值将检测匹配的每一个模式。一旦模式匹配&＃xff0c;则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式&＃xff0c;使用星号 * 捕获该值&＃xff0c;再执行后面的命令。

下面的脚本提示输入1到4&＃xff0c;与每一种模式进行匹配&＃xff1a;

echo &＃39;输入 1 到 4 之间的数字:&＃39;
echo &＃39;你输入的数字为:&＃39;
read aNum
case $aNum in1) echo &＃39;你选择了 1&＃39;;;2) echo &＃39;你选择了 2&＃39;;;3) echo &＃39;你选择了 3&＃39;;;4) echo &＃39;你选择了 4&＃39;;;*) echo &＃39;你没有输入 1 到 4 之间的数字&＃39;;;
esac

输入不同的内容&＃xff0c;会有不同的结果&＃xff0c;例如&＃xff1a;

输入 1 到 4 之间的数字:
你输入的数字为:
3
你选择了 3

---

跳出循环

在循环过程中&＃xff0c;有时候需要在未达到循环结束条件时强制跳出循环&＃xff0c;Shell使用两个命令来实现该功能&＃xff1a;break和continue。

break命令

break命令允许跳出所有循环&＃xff08;终止执行后面的所有循环&＃xff09;。

下面的例子中&＃xff0c;脚本进入死循环直至用户输入数字大于5。要跳出这个循环&＃xff0c;返回到shell提示符下&＃xff0c;需要使用break命令。

#!/bin/bash
while :
doecho -n "输入 1 到 5 之间的数字:"read aNumcase $aNum in1|2|3|4|5) echo "你输入的数字为 $aNum!";;*) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"break;;esac
done

执行以上代码&＃xff0c;输出结果为&＃xff1a;

输入 1 到 5 之间的数字:3
你输入的数字为 3!
输入 1 到 5 之间的数字:7
你输入的数字不是 1 到 5 之间的! 游戏结束

continue

continue命令与break命令类似&＃xff0c;只有一点差别&＃xff0c;它不会跳出所有循环&＃xff0c;仅仅跳出当前循环。

对上面的例子进行修改&＃xff1a;

#!/bin/bash
while :
doecho -n "输入 1 到 5 之间的数字: "read aNumcase $aNum in1|2|3|4|5) echo "你输入的数字为 $aNum!";;*) echo "你输入的数字不是 1 到 5 之间的!"continueecho "游戏结束";;esac
done

运行代码发现&＃xff0c;当输入大于5的数字时&＃xff0c;该例中的循环不会结束&＃xff0c;语句 echo “Game is over!” 永远不会被执行。

---

esac

case的语法和C family语言差别很大&＃xff0c;它需要一个esac&＃xff08;就是case反过来&＃xff09;作为结束标记&＃xff0c;每个case分支用右圆括号&＃xff0c;用两个分号表示break。

---

10、Shell 函数

linux shell 可以用户定义函数&＃xff0c;然后在shell脚本中可以随便调用。

shell中函数的定义格式如下&＃xff1a;

[ function ] funname [()]{action;[return int;]}

说明&＃xff1a;

• 1、可以带function fun() 定义&＃xff0c;也可以直接fun() 定义,不带任何参数。
• 2、参数返回&＃xff0c;可以显示加&＃xff1a;return 返回&＃xff0c;如果不加&＃xff0c;将以最后一条命令运行结果&＃xff0c;作为返回值。 return后跟数值n(0-255

下面的例子定义了一个函数并进行调用&＃xff1a;

#!/bin/bashdemoFun(){echo "这是我的第一个 shell 函数!"
}
echo "-----函数开始执行-----"
demoFun
echo "-----函数执行完毕-----"

输出结果&＃xff1a;

-----函数开始执行-----
这是我的第一个 shell 函数!
-----函数执行完毕-----

下面定义一个带有return语句的函数&＃xff1a;

#!/bin/bashfunWithReturn(){echo "这个函数会对输入的两个数字进行相加运算..."echo "输入第一个数字: "read aNumecho "输入第二个数字: "read anotherNumecho "两个数字分别为 $aNum 和 $anotherNum !"return $(($aNum&＃43;$anotherNum))
}
funWithReturn
echo "输入的两个数字之和为 $? !"

输出类似下面&＃xff1a;

这个函数会对输入的两个数字进行相加运算...
输入第一个数字:
1
输入第二个数字:
2
两个数字分别为 1 和 2 !
输入的两个数字之和为 3 !

函数返回值在调用该函数后通过 $? 来获得。

注意&＃xff1a;所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分&＃xff0c;直至shell解释器首次发现它时&＃xff0c;才可以使用。调用函数仅使用其函数名即可。

---

函数参数

在Shell中&＃xff0c;调用函数时可以向其传递参数。在函数体内部&＃xff0c;通过 $n 的形式来获取参数的值&＃xff0c;例如&＃xff0c;$1表示第一个参数&＃xff0c;$2表示第二个参数…

带参数的函数示例&＃xff1a;

#!/bin/bashfunWithParam(){echo "第一个参数为 $1 !"echo "第二个参数为 $2 !"echo "第十个参数为 $10 !"echo "第十个参数为 ${10} !"echo "第十一个参数为 ${11} !"echo "参数总数有 $# 个!"echo "作为一个字符串输出所有参数 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果&＃xff1a;

第一个参数为 1 !
第二个参数为 2 !
第十个参数为 10 !
第十个参数为 34 !
第十一个参数为 73 !
参数总数有 11 个!
作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

注意&＃xff0c;$10 不能获取第十个参数&＃xff0c;获取第十个参数需要${10}。当n>&＃61;10时&＃xff0c;需要使用${n}来获取参数。

另外&＃xff0c;还有几个特殊字符用来处理参数&＃xff1a;

参数处理	说明
$#	传递到脚本的参数个数
$*	以一个单字符串显示所有向脚本传递的参数
$$	脚本运行的当前进程ID号
$!	后台运行的最后一个进程的ID号
$&＃64;	与$*相同&＃xff0c;但是使用时加引号&＃xff0c;并在引号中返回每个参数。
$-	显示Shell使用的当前选项&＃xff0c;与set命令功能相同。
$?	显示最后命令的退出状态。0表示没有错误&＃xff0c;其他任何值表明有错误。

---

11、Shell 输入/输出重定向

大多数 UNIX 系统命令从你的终端接受输入并将所产生的输出发送回​​到您的终端。一个命令通常从一个叫标准输入的地方读取输入&＃xff0c;默认情况下&＃xff0c;这恰好是你的终端。同样&＃xff0c;一个命令通常将其输出写入到标准输出&＃xff0c;默认情况下&＃xff0c;这也是你的终端。

重定向命令列表如下&＃xff1a;

命令	说明
command > file	将输出重定向到 file。
command	将输入重定向到 file。
command >> file	将输出以追加的方式重定向到 file。
n > file	将文件描述符为 n 的文件重定向到 file。
n >> file	将文件描述符为 n 的文件以追加的方式重定向到 file。
n >& m	将输出文件 m 和 n 合并。
n <& m	将输入文件 m 和 n 合并。
<	将开始标记 tag 和结束标记 tag 之间的内容作为输入。

需要注意的是文件描述符 0 通常是标准输入&＃xff08;STDIN&＃xff09;&＃xff0c;1 是标准输出&＃xff08;STDOUT&＃xff09;&＃xff0c;2 是标准错误输出&＃xff08;STDERR&＃xff09;。

---

输出重定向

重定向一般通过在命令间插入特定的符号来实现。特别的&＃xff0c;这些符号的语法如下所示:

command1 > file1

上面这个命令执行command1然后将输出的内容存入file1。

注意任何file1内的已经存在的内容将被新内容替代。如果要将新内容添加在文件末尾&＃xff0c;请使用>>操作符。

实例

执行下面的 who 命令&＃xff0c;它将命令的完整的输出重定向在用户文件中(users):

$ who > users

执行后&＃xff0c;并没有在终端输出信息&＃xff0c;这是因为输出已被从默认的标准输出设备&＃xff08;终端&＃xff09;重定向到指定的文件。

你可以使用 cat 命令查看文件内容&＃xff1a;

$ cat users
_mbsetupuser console Oct 31 17:35
tianqixin console Oct 31 17:35
tianqixin ttys000 Dec 1 11:33

输出重定向会覆盖文件内容&＃xff0c;请看下面的例子&＃xff1a;

$ echo "name&＃xff1a;www.csdn.net" > users
$ cat users
name: www.csdn.net
$

如果不希望文件内容被覆盖&＃xff0c;可以使用 >> 追加到文件末尾&＃xff0c;例如&＃xff1a;

$ echo "name&＃xff1a;www.csdn.net" >> users
$ cat users
name&＃xff1a;www.csdn.net
name&＃xff1a;www.csdn.net
$

---

输入重定向

和输出重定向一样&＃xff0c;Unix 命令也可以从文件获取输入&＃xff0c;语法为&＃xff1a;

command1

这样&＃xff0c;本来需要从键盘获取输入的命令会转移到文件读取内容。

注意&＃xff1a;输出重定向是大于号(>)&＃xff0c;输入重定向是小于号(<)。

实例

接着以上实例&＃xff0c;我们需要统计 users 文件的行数,执行以下命令&＃xff1a;

$ wc -l users2 users

也可以将输入重定向到 users 文件&＃xff1a;

$ wc -l

注意&＃xff1a;上面两个例子的结果不同&＃xff1a;第一个例子&＃xff0c;会输出文件名&＃xff1b;第二个不会&＃xff0c;因为它仅仅知道从标准输入读取内容。

command1 outfile

同时替换输入和输出&＃xff0c;执行command1&＃xff0c;从文件infile读取内容&＃xff0c;然后将输出写入到outfile中。

重定向深入讲解

一般情况下&＃xff0c;每个 Unix/Linux 命令运行时都会打开三个文件&＃xff1a;

• 标准输入文件(stdin)&＃xff1a;stdin的文件描述符为0&＃xff0c;Unix程序默认从stdin读取数据。
• 标准输出文件(stdout)&＃xff1a;stdout 的文件描述符为1&＃xff0c;Unix程序默认向stdout输出数据。
• 标准错误文件(stderr)&＃xff1a;stderr的文件描述符为2&＃xff0c;Unix程序会向stderr流中写入错误信息。

默认情况下&＃xff0c;command > file 将 stdout 重定向到 file&＃xff0c;command

如果希望 stderr 重定向到 file&＃xff0c;可以这样写&＃xff1a;

$ command 2 > file

如果希望 stderr 追加到 file 文件末尾&＃xff0c;可以这样写&＃xff1a;

$ command 2 >> file

2 表示标准错误文件(stderr)。

如果希望将 stdout 和 stderr 合并后重定向到 file&＃xff0c;可以这样写&＃xff1a;

$ command > file 2>&1

或者

$ command >> file 2>&1

如果希望对 stdin 和 stdout 都重定向&＃xff0c;可以这样写&＃xff1a;

$ command file2

command 命令将 stdin 重定向到 file1&＃xff0c;将 stdout 重定向到 file2。

---

Here Document

Here Document 是 Shell 中的一种特殊的重定向方式&＃xff0c;用来将输入重定向到一个交互式 Shell 脚本或程序。

它的基本的形式如下&＃xff1a;

command <delimiter

它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。

注意&＃xff1a;

• 结尾的delimiter 一定要顶格写&＃xff0c;前面不能有任何字符&＃xff0c;后面也不能有任何字符&＃xff0c;包括空格和 tab 缩进。
• 开始的delimiter前后的空格会被忽略掉。

实例

在命令行中通过 wc -l 命令计算 Here Document 的行数&＃xff1a;

$ wc -l <EOF
3 # 输出结果为 3 行
$

我们也可以将 Here Document 用在脚本中&＃xff0c;例如&＃xff1a;

#!/bin/bash
# author:csdn
# url:www.csdn.netcat <欢迎来到
csdn
www.csdn.net
EOF

执行以上脚本&＃xff0c;输出结果&＃xff1a;

欢迎来到
csdn
www.csdn.net

---

/dev/null 文件

如果希望执行某个命令&＃xff0c;但又不希望在屏幕上显示输出结果&＃xff0c;那么可以将输出重定向到 /dev/null&＃xff1a;

$ command > /dev/null

/dev/null 是一个特殊的文件&＃xff0c;写入到它的内容都会被丢弃&＃xff1b;如果尝试从该文件读取内容&＃xff0c;那么什么也读不到。但是 /dev/null 文件非常有用&＃xff0c;将命令的输出重定向到它&＃xff0c;会起到”禁止输出”的效果。

如果希望屏蔽 stdout 和 stderr&＃xff0c;可以这样写&＃xff1a;

$ command > /dev/null 2>&1

注意&＃xff1a;0 是标准输入&＃xff08;STDIN&＃xff09;&＃xff0c;1 是标准输出&＃xff08;STDOUT&＃xff09;&＃xff0c;2 是标准错误输出&＃xff08;STDERR&＃xff09;。

---

12、Shell 文件包含

和其他语言一样&＃xff0c;Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。

Shell 文件包含的语法格式如下&＃xff1a;

. filename # 注意点号(.)和文件名中间有一空格


或


source filename

实例

创建两个 shell 脚本文件。

test1.sh 代码如下&＃xff1a;

#!/bin/bashurl&＃61;"http://www.csdn.net"

test2.sh 代码如下&＃xff1a;

#!/bin/bash#使用 . 号来引用test1.sh 文件
. ./test1.sh# 或者使用以下包含文件代码
# source ./test1.shecho "教程官网地址&＃xff1a;$url"

接下来&＃xff0c;我们为 test2.sh 添加可执行权限并执行&＃xff1a;

$ chmod &＃43;x test2.sh
$ ./test2.sh
教程官网地址&＃xff1a;http://www.csdn.net

注&＃xff1a;被包含的文件 test1.sh 不需要可执行权限。