shell脚本基础知识讲解（Shell脚本基础）
shell脚本基础知识讲解（Shell脚本基础）#!/bin/bashecho "Hello World !"一、解释器1. 自动布署环境2. 自动批量生成测试数据3. 利用相关命令监控系统和平台资源
用途：完成特定的、较复杂的系统管理任务
格式：集中保存多条Linux命令，普通文本文件
执行方式：按照预设的顺序依次解释执行
shell脚本在测试过程中一般的作用：
1. 自动布署环境
2. 自动批量生成测试数据
3. 利用相关命令监控系统和平台资源
一、解释器
#!/bin/bash
echo "Hello World !"
执行：bash a1.sh
sh bash ./ .空格
#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。
echo 命令用于向窗口输出文本。
二、Shell 注释
以"#"开头的行就是注释，会被解释器忽略。
sh里没有多行注释，只能每一行加一个#号。
三、运行 shell 脚本有三种方法：
1、作为可执行程序
将上面的代码保存为 test.sh，并 cd 到相应目录：
chmod x ./test.sh #使脚本具有执行权限
./test.sh #执行脚本
注意，一定要写成 ./test.sh，而不是 test.sh，运行其它二进制的程序也一样，直接写 test.sh，linux 系统会去 PATH 里寻找有没有叫 test.sh 的，而只有 /bin /sbin /usr/bin，/usr/sbin 等在 PATH 里，你的当前目录通常不在 PATH 里，所以写成 test.sh 是会找不到命令的，要用 ./test.sh 告诉系统说，就在当前目录找。
2、作为解释器参数
这种运行方式是，直接运行解释器，其参数就是 shell 脚本的文件名，如：
/bin/sh test.sh
3、bash test.sh
四、echo: 格式：echo 字符串 #输出文本 （双引号，单引号，无引号）
1、echo "Hello World !" #echo #向窗口输出文本
练习1： 写一个shell脚本，在屏幕上输出以下结果
**********************************
Hello world!
**********************************
五、变量定义 格式 ： 变量名=""或''
注意，1.变量名和等号之间不能有空格，
2.命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
3.中间不能有空格，可以使用下划线（_）。
4.不能使用特殊符号。
5.不能使用bash里的关键字（可用help命令查看保留关键字）。
有效的 Shell 变量名示例如下：
RUNOOB
LD_LIBRARY_PATH
_var
var2
无效的变量命名：
?var=123
user*name=runoob
1、单引号字符串的限制：
A.单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
B.单引号字串中不能出现单引号（对单引号使用转义符后也不行）。
str='this is a string'
2、双引号的优点：
A.双引号里可以有变量
B.双引号里可以出现转义字符（Shell中的转义符是反斜线“\”，通过转义字符使其后面的字符单纯的出现，而不去解释其特殊的含义 如：$100）
）
your_name='qinjx'
str="Hello I know your are \"$your_name\"! \n"
六、变量使用： 格式：$变量名，或${变量名} 如 echo $name
1、使用一个定义过的变量，只要在变量名前面加美元符号即可，如：
your_name="qinjx"
echo $your_name
echo ${your_name}
注：变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界
如： echo "I am good at ${skill}Script"，如果不给skill变量加花括号，写成echo "I am good at $skillScript"，解释器就会把$skillScript当成一个变量（其值为空），代码执行结果就不是我们期望的样子了。推荐给所有变量加上花括号，这是个好的编程习惯。
2、已定义的变量，可以被重新定义，如：
#!/bin/bash
your_name="tom"
echo $your_name
your_name="alibaba"
echo $your_name
七、删除变量
使用 unset 命令可以删除变量。语法：
unset variable_name
如：your_name=”xiaohong”
unset your_name
变量被删除后不能再次使用
练习2： 写一个shell脚本，并在里面定义一个变量，将自已的名字
赋给这个变量，然后输出这个变量的值(通过这个例子，学会定义和引用变量)
八、拼接字符串
#!/bin/bash
your_name="qinjx"
greeting="hello "$your_name" !"
greeting_1="hello ${your_name} !"
echo $greeting $greeting_1
练习3 在第二个练习的shell脚本中，再定义两个变量，其中一个变量赋值为"shenzhen" 然后将第二个脚本中的变量与这个变量的值赋给第三个变量，并在屏幕上输出(通过这个例子，练习变量赋值、拼接字符串)
九、获取字符串的长度： 格式：{#变量名}
#!/bin/bash
string="abcd"
echo ${#string} #输出 4 #字符串中的引号不计数
十、提取子字符串 格式：${字符串名：开始索引号:字符串个数}
以下实例从字符串第 1 个字符开始截取 4 个字符：
#!/bin/bash
string="runoob is a great site"
echo ${string:1:4} # 输出 unoo #从O开始 包括引号计算在内
（1：指从第几位开始数 4：指取出后边的几位数）
十一、查找子字符串的位置 格式：`expr index “字符串名” 子字符串`
查找字符 "is" 的位置：
#!/bin/bash
string="runoob is a great company"
echo `expr index "$string" is` # 输出 #从1开始
注意： 以上脚本中 "`" 是反引号，而不是单引号 "'"，不要看错了哦。
练习4：在第三个练习脚本里，增加以下功能：
1. 输出拼接后的字符串的长度
2. 输出从第2个字符到第5个字符的内容
3. 查找出'z'在拼接后的字符串中的位置
十二、Shell 数组
bash支持一维数组（不支持多维数组），并且没有限定数组的大小。
类似与C语言，数组元素的下标由0开始编号。获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于0。
1、定义数组
在Shell中，用括号来表示数组，数组元素用"空格"符号分割开。定义数组的一般形式为：
数组名=(值1 值2 ... 值n)
例如：
array_name=(value0 value1 value2 value3)
或者
#!/bin/bash
array_name=(
value0
value1
value2
value3
)
还可以单独定义数组的各个元素：
array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen
valuen=${array_name[n]}
可以不使用连续的下标，而且下标的范围没有限制。
2、读取数组
读取数组元素值的一般格式是：
#!/bin/bash
${数组名[下标]}
my_array=(A B "C" D)
echo "第一个元素为: ${my_array[0]}"
echo "第二个元素为: ${my_array[1]}"
echo "第三个元素为: ${my_array[2]}"
echo "第四个元素为: ${my_array[3]}"
执行脚本，输出结果如下所示：
$ chmod x test.sh
$ ./test.sh
第一个元素为: A
第二个元素为: B
第三个元素为: C
第四个元素为: D
使用@符号可以获取数组中的所有元素，例如：
#!/bin/bash
echo ${my_array[@]} # 输出整个数组 ： * @
3、获取数组的长度
获取数组长度的方法与获取字符串长度的方法相同，例如：
#!/bin/bash
# 取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}
练习5. 新写一个shell脚本 完成以下功能：
1. 定义一个数组，将四个同学的名字放入数组中
2. 输出数组中所有内容
3. 输出数组的长度
4. 输出数组中下标为2的内容
5.输出数组中下标为2的长度
十三、Shell 传递参数（交互模式）
我们可以在执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推……
实例
以下实例我们向脚本传递三个参数，并分别输出，其中$0为执行的文件名，$n是根据输入参数个数的顺序
#!/bin/bash
echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";
为脚本设置可执行权限，并执行脚本，输出结果如下所示：
$ chmod x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例！
执行的文件名：./test.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3
另外，还有几个特殊字符用来处理参数：
|
参数处理 |
说明 |
|
$# |
传递到脚本的参数个数 |
|
$* |
以一个单字符串显示所有向脚本传递的参数。 |
|
$$ |
脚本运行的当前进程ID号 |
|
$! |
后台运行的最后一个进程的ID号 |
|
$@ |
与$*相同，但是使用时加引号，并在引号中返回每个参数。 |
|
$? |
显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。 |
#!/bin/bash
echo "Shell 传递参数实例！";
echo "第一个参数为：$1";
echo "参数个数为：$#";
echo "传递的参数作为一个字符串显示：$*";
执行脚本，输出结果如下所示：
$ chmod x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例！
第一个参数为：1
参数个数为：3
传递的参数作为一个字符串显示：1 2 3
$* 与 $@ 区别：
相同点：都是引用所有参数。
不同点：只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则 " * " 等价于 "1 2 3"（传递了一个参数），而 "@" 等价于 "1" "2" "3"（传递了三个参数）。即：（做为三个参数坚显，做为一个参数横显）
#!/bin/bash
# author:冠泰瑞恒教程
# url:www.runoob.com
echo "-- \$* 演示 ---"
for i in "$*"; do
echo $i
done
echo "-- \$@ 演示 ---"
for i in "$@"; do
echo $i
done
执行脚本，输出结果如下所示：
$ chmod x test.sh
$ ./test.sh 1 2 3
-- $* 演示 ---
1 2 3
-- $@ 演示 ---
1
2
3
练习6. 新写一个shell脚本，在执行脚本时输入两个参数(通过这个例子，
知道如何引用输入参数）
例如脚本的名称：test5.sh
执行命命: test5.sh shenzhen gtrh
输出以下结果(要求，shenzhen gtrh这两个参数要求可变）：
exec file name is: test5.sh
first value is: shenzhen
second value is: gtrh
十四、Shell 基本运算符—算术运算
Shell 和其他编程语言一样，支持多种运算符，包括：
算数运算符
关系运算符
布尔运算符
字符串运算符
文件测试运算符
原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，
expr 最常用。
expr 是一款表达式计算工具，使用它能完成表达式的求值操作。
例如，两个数相加(注意使用的是反引号 ` 而不是单引号 ')：
#!/bin/bash
val=`expr 2 2`
echo "两数之和为 : $val"
执行脚本，输出结果如下所示：
两数之和为 : 4
两点注意：
表达式和运算符之间要有空格，例如 2 2 是不对的，必须写成 2 2，这与我们熟悉的大多数编程语言不一样。
完整的表达式要被 ` ` 包含，注意这个字符不是常用的单引号，在 Esc 键下边(返引号 )。
1、算术运算符
下表列出了常用的算术运算符，假定变量 a 为 10，变量 b 为 20：
|
运算符 |
说明 |
举例 |
|
|
加法 |
`expr $a $b` 结果为 30。 |
|
- |
减法 |
`expr $a - $b` 结果为 -10。 |
|
* |
乘法 |
`expr $a \* $b` 结果为 200。 |
|
/ |
除法 |
`expr $b / $a` 结果为 2。 |
|
% |
取余 |
`expr $b % $a` 结果为 0。 |
|
= |
赋值 |
a=$b 将把变量 b 的值赋给 a。 |
|
== |
相等。用于比较两个数字，相同则返回 true。 |
[ $a == $b ] 返回 false。 |
|
!= |
不相等。用于比较两个数字，不相同则返回 true。 |
[ $a != $b ] 返回 true。 |
注意：条件表达式要放在方括号之间，并且要有空格，例如: [$a==$b] 是错误的，必须写成 [ $a == $b ]。
实例：算术运算符实例如下：
#!/bin/bash
a=10
b=20
val=`expr $a $b`
echo "a b : $val"
val=`expr $a - $b`
echo "a - b : $val"
val=`expr $a \* $b`
echo "a * b : $val"
val=`expr $b / $a`
echo "b / a : $val"
val=`expr $b % $a`
echo "b % a : $val"
if [ $a == $b ]
then
echo "a 等于 b"
fi
if [ $a != $b ]
then
echo "a 不等于 b"
fi
执行脚本，输出结果如下所示：
a b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等于 b
注意：
乘号(*)前边必须加反斜杠(\)才能实现乘法运算；
关系运算符关系运算符只支持数字，不支持字符串，除非字符串的值是数字。
下表列出了常用的关系运算符，假定变量 a 为 10，变量 b 为 20：
|
运算符 |
说明 |
举例 |
|
-eq |
检测两个数是否相等，相等返回 true。 |
[ $a -eq $b ] 返回 false。 |
|
-ne |
检测两个数是否相等，不相等返回 true。 |
[ $a -ne $b ] 返回 true。 |
|
-gt |
检测左边的数是否大于右边的，如果是，则返回 true。 |
[ $a -gt $b ] 返回 false。 |
|
-lt |
检测左边的数是否小于右边的，如果是，则返回 true。 |
[ $a -lt $b ] 返回 true。 |
|
-ge |
检测左边的数是否大于等于右边的，如果是，则返回 true。 |
[ $a -ge $b ] 返回 false。 |
|
-le |
检测左边的数是否小于等于右边的，如果是，则返回 true。 |
[ $a -le $b ] 返回 true。 |
关系运算符实例如下：
#!/bin/bash
a=10
b=20
if [ $a -eq $b ]
then
echo "$a -eq $b : a 等于 b"
else
echo "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]
then
echo "$a -ne $b: a 不等于 b"
else
echo "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]
then
echo "$a -gt $b: a 大于 b"
else
echo "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]
then
echo "$a -lt $b: a 小于 b"
else
echo "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]
then
echo "$a -ge $b: a 大于或等于 b"
else
echo "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]
then
echo "$a -le $b: a 小于或等于 b"
else
echo "$a -le $b: a 大于 b"
fi
执行脚本，输出结果如下所示：
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
布尔运算符下表列出了常用的布尔运算符，假定变量 a 为 10，变量 b 为 20：
|
运算符 |
说明 |
举例 |
|
! |
非运算，表达式为 true 则返回 false，否则返回 true。 |
[ ! false ] 返回 true。 |
|
-o |
或运算，有一个表达式为 true 则返回 true。 |
[ $a -lt 20 -o $b -gt 100 ] 返回 true。 |
|
-a |
与运算，两个表达式都为 true 才返回 true。 |
[ $a -lt 20 -a $b -gt 100 ] 返回 false。 |
布尔运算符实例如下：
#!/bin/bash
a=10
b=20
if [ $a != $b ]
then
echo "$a != $b : a 不等于 b"
else
echo "$a != $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi
执行脚本，输出结果如下所示：
10 != 20 : a 不等于 b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false
逻辑运算符以下介绍 Shell 的逻辑运算符，假定变量 a 为 10，变量 b 为 20:
|
运算符 |
说明 |
举例 |
|
&& |
逻辑的 AND |
[[ $a -lt 100 && $b -gt 100 ]] 返回 false |
|
|| |
逻辑的 OR |
[[ $a -lt 100 || $b -gt 100 ]] 返回 true |
逻辑运算符实例如下：
#!/bin/bash
a=10
b=20
if [[ $a -lt 100 && $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi
if [[ $a -lt 100 || $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi
执行脚本，输出结果如下所示：
返回 false
返回 true
字符串运算符下表列出了常用的字符串运算符，假定变量 a 为 "abc"，变量 b 为 "efg"：
|
运算符 |
说明 |
举例 |
|
= |
检测两个字符串是否相等，相等返回 true。 |
[ $a = $b ] 返回 false。 |
|
!= |
检测两个字符串是否相等，不相等返回 true。 |
[ $a != $b ] 返回 true。 |
|
-z |
检测字符串长度是否为0，为0返回 true。 |
[ -z $a ] 返回 false。 |
|
-n |
检测字符串长度是否为0，不为0返回 true。 |
[ -n $a ] 返回 true。 |
|
str |
检测字符串是否为空，不为空返回 true。 |
[ $a ] 返回 true。 |
字符串运算符实例如下：
#!/bin/bash
a="abc"
b="efg"
if [ $a = $b ]
then
echo "$a = $b : a 等于 b"
else
echo "$a != $b: a 不等于 b"
fi
if [ $a != $b ]
then
echo "$a != $b : a 不等于 b"
else
echo "$a = $b: a 等于 b"
fi
if [ -z $a ]
then
echo "-z $a : 字符串长度为 0"
else
echo "-z $a : 字符串长度不为 0"
fi
if [ -n $a ]
then
echo "-n $a : 字符串长度不为 0"
else
echo "-n $a : 字符串长度为 0"
fi
if [ $a ]
then
echo "$a : 字符串不为空"
else
echo "$a : 字符串为空"
fi
执行脚本，输出结果如下所示：
abc = efg: a 不等于 b
abc != efg : a 不等于 b
-z abc : 字符串长度不为 0
-n abc : 字符串长度不为 0
abc : 字符串不为空
文件测试运算符文件测试运算符用于检测 Unix 文件的各种属性。
属性检测描述如下：
|
操作符 |
说明 |
举例 |
|
-b file |
检测文件是否是块设备文件，如果是，则返回 true。 |
[ -b $file ] 返回 false。 |
|
-c file |
检测文件是否是字符设备文件，如果是，则返回 true。 |
[ -c $file ] 返回 false。 |
|
-d file |
检测文件是否是目录，如果是，则返回 true。 |
[ -d $file ] 返回 false。 |
|
-f file |
检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。 |
[ -f $file ] 返回 true。 |
|
-g file |
检测文件是否设置了 SGID 位，如果是，则返回 true。 |
[ -g $file ] 返回 false。 |
|
-k file |
检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回 true。 |
[ -k $file ] 返回 false。 |
|
-p file |
检测文件是否是有名管道，如果是，则返回 true。 |
[ -p $file ] 返回 false。 |
|
-u file |
检测文件是否设置了 SUID 位，如果是，则返回 true。 |
[ -u $file ] 返回 false。 |
|
-r file |
检测文件是否可读，如果是，则返回 true。 |
[ -r $file ] 返回 true。 |
|
-w file |
检测文件是否可写，如果是，则返回 true。 |
[ -w $file ] 返回 true。 |
|
-x file |
检测文件是否可执行，如果是，则返回 true。 |
[ -x $file ] 返回 true。 |
|
-s file |
检测文件是否为空（文件大小是否大于0），不为空返回 true。 |
[ -s $file ] 返回 true。 |
|
-e file |
检测文件（包括目录）是否存在，如果是，则返回 true。 |
[ -e $file ] 返回 true。 |
变量 file 表示文件"/var/www/runoob/test.sh"，它的大小为100字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：
#!/bin/bash
file="/var/www/runoob/test.sh"
if [ -r $file ]
then
echo "文件可读"
else
echo "文件不可读"
fi
if [ -w $file ]
then
echo "文件可写"
else
echo "文件不可写"
fi
if [ -x $file ]
then
echo "文件可执行"
else
echo "文件不可执行"
fi
if [ -f $file ]
then
echo "文件为普通文件"
else
echo "文件为特殊文件"
fi
if [ -d $file ]
then
echo "文件是个目录"
else
echo "文件不是个目录"
fi
if [ -s $file ]
then
echo "文件不为空"
else
echo "文件为空"
fi
if [ -e $file ]
then
echo "文件存在"
else
echo "文件不存在"
fi
执行脚本，输出结果如下所示：
文件可读
文件可写
文件可执行
文件为普通文件
文件不是个目录
文件不为空
文件存在
练习7. 新写一个shell脚本，通过 - * / 的运算输出 3 6
3-6 3*6 3/6的值、 检查一个文件 是否存在
十五、Shell test 命令
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。
1、数值测试
|
参数 |
说明 |
|
-eq |
等于则为真 |
|
-ne |
不等于则为真 |
|
-gt |
大于则为真 |
|
-ge |
大于等于则为真 |
|
-lt |
小于则为真 |
|
-le |
小于等于则为真 |
实例演示：
num1=100
num2=100
if test $[num1] -eq $[num2]
then
echo '两个数相等！'
else
echo '两个数不相等！'
fi
输出结果：
两个数相等！
代码中的 [] 执行基本的算数运算，如：
#!/bin/bash
a=5
b=6
result=$[a b] # 注意等号两边不能有空格
echo "result 为： $result"
结果为:
result 为： 11
2、字符串测试
|
参数 |
说明 |
|
= |
等于则为真 |
|
!= |
不相等则为真 |
|
-z 字符串 |
字符串的长度为零则为真 |
|
-n 字符串 |
字符串的长度不为零则为真 |
实例演示：
num1="ru1noob"
num2="runoob"
if test $num1 = $num2
then
echo '两个字符串相等!'
else
echo '两个字符串不相等!'
fi
输出结果：
两个字符串不相等!
3、文件测试
|
参数 |
说明 |
|
-e 文件名 |
如果文件存在则为真 |
|
-r 文件名 |
如果文件存在且可读则为真 |
|
-w 文件名 |
如果文件存在且可写则为真 |
|
-x 文件名 |
如果文件存在且可执行则为真 |
|
-s 文件名 |
如果文件存在且至少有一个字符则为真 |
|
-d 文件名 |
如果文件存在且为目录则为真 |
|
-f 文件名 |
如果文件存在且为普通文件则为真 |
|
-c 文件名 |
如果文件存在且为字符型特殊文件则为真 |
|
-b 文件名 |
如果文件存在且为块特殊文件则为真 |
实例演示：
cd /bin
if test -e ./bash
then
echo '文件已存在!'
else
echo '文件不存在!'
fi
输出结果：
文件已存在!
另外，Shell还提供了与( -a )、或( -o )、非( ! )三个逻辑操作符用于将测试条件连接起来，其优先级为："!"最高，"-a"次之，"-o"最低。例如：
cd /bin
if test -e ./notFile -o -e ./bash
then
echo '至少有一个文件存在!'
else
echo '两个文件都不存在'
fi
输出结果：
至少有一个文件存在!
十六、Shell 流程控制
1、if 语句 if 语句语法格式：if condition
then
command1
command2
...
commandN
fi
写成一行（适用于终端命令提示符）：
if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi
末尾的fi就是if倒过来拼写，后面还会遇到类似的。
2、if else 语法格式：if condition
then
command1
command2
...
commandN
else
command
fi
3、if else-if else 语法格式：if condition1
then
command1
elif condition2
then
command2
else
commandN
fi
以下实例判断两个变量是否相等：
a=10
b=20
if [ $a == $b ]
then
echo "a 等于 b"
elif [ $a -gt $b ]
then
echo "a 大于 b"
elif [ $a -lt $b ]
then
echo "a 小于 b"
else
echo "没有符合的条件"
fi
输出结果：
a 小于 b
if else语句经常与test命令结合使用，如下所示：
num1=$[2*3]
num2=$[1 5]
if test $[num1] -eq $[num2]
then
echo '两个数字相等!'
else
echo '两个数字不相等!'
fi
输出结果：
两个数字相等!
练习8. 新写一个shell脚本，输入两个数字，通过shell判断，
(通过这个例子，知道if语句的使用，和输入参数的引用)
如果这两个数字相同，则输出 "a==b"
如果这两个数字不相同，则输出"a!=b"
练习9. 新写一个shell脚本，判断usr/fuqin目录下是否存在shellfile.txt文件
如果存在，则输出文件名
如果不存在，则创建这个文件，并输出创建成功的信息
file="/usr/fq/shellfile.txt"
if [ -e $file ]
then
echo "$file"
else
cd /usr/fuqin
touch "$file"
echo "创建成功"
fi
十七、for 循环
与其他编程语言类似，Shell支持for循环。
for循环一般格式为：
for var in item1 item2 ... itemN
do
command1
command2
...
commandN
done
写成一行：
for var in item1 item2 ... itemN; do command1; command2… done;
当变量值在列表里，for循环即执行一次所有命令，使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。in列表可以包含替换、字符串和文件名。
in列表是可选的，如果不用它，for循环使用命令行的位置参数。
例如，顺序输出当前列表中的数字：
for loop in 1 2 3 4 5
do
echo "The value is: $loop"
done
输出结果：
The value is: 1
The value is: 2
The value is: 3
The value is: 4
The value is: 5
顺序输出字符串中的字符：
for str in 'This is a string'
do
echo $str
done
输出结果：
This is a string
十八、while 语句
while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件。其格式为：
while condition
do
command
done
以下是一个基本的while循环，测试条件是：如果int小于等于5，那么条件返回真。int从0开始，每次循环处理时，int加1。运行上述脚本，返回数字1到5，然后终止。
#!/bin/bash
int=1
while(( $int<=5 ))
do
echo $int
let "int "
done
运行脚本，输出：
1
2
3
4
5
使用中使用了 Bash let 命令，它用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量，具体可查阅：Bash let 命令
。
while循环可用于读取键盘信息。下面的例子中，输入信息被设置为变量FILM，按<Ctrl-D>结束循环。
echo '按下 <CTRL-D> 退出'
echo -n '输入你最喜欢的网站名: '
while read FILM
do
echo "是的！$FILM 是一个好网站"
done
运行脚本，输出类似下面：
按下 <CTRL-D> 退出
输入你最喜欢的网站名:冠泰瑞恒教程
是的！冠泰瑞恒教程 是一个好网站
无限循环
无限循环语法格式：
while :
do
command
done
或者
while true
do
command
done
或者
for (( ; ; ))
练习10. 写一个shell脚本，通过for循环或者while循环输出1加到100
的结果
练习11. 综合练习题（自动化脚本编写)
新写一个脚本，实现以下功能：
1. 显示当前系统日期，然后创建目录/tmp/lstest date
2. 切换工作目录至/tmp/lstest
3. 创建目录ald b56e 6test
4. 创建xy x2y 732文件
5. 列出当前目录下以a x或者6开头的文件或者目录
#!/bin/bash
date
rm -rf /tmp/lstest
mkdir /tmp/lstest
cd /tmp/lstest
rm -rf all a56e 6test
mkdir al1 a56e 6test
rm -rf xy x2y 732
touch xy x2y 732
ls a* x* 6*
练习12.检查 /var/ftp/pub/ 目录，将其中所有子目录及文件的详细列表、
当时的时间信息追加保存到 /var/log/pubdir.log 日志文件中，
然后清空该目录
ls –l #详情
-h #文件大小
-R #包括所有子目录及文件
[root@localhost ~]# vi /opt/ftpclean.sh
#!/bin/bash
date >> /var/log/pubdir.log
ls -lh /var/ftp/pub >> /var/log/pubdir.log
rm -rf /var/ftp/pub/*
十九、定时任务
crontab 格式: * * * * * ***
分 时 天 月 星期 命令
“*”代表取值范围内的数字
“/”代表”每”
“-”代表从某个数字到某个数字
“ ”分开几个离散的数字
这个格式的前一部分是对时间的设定，后面一部分是要执行的命令，如果要执行的命令太多，可以把这些命令写到一个脚本里面，然后在这里直接调用这个脚本就可以了，调用的时候记得写出命令的完整路径。时间的设定我们有一定的约定，前面五个*号代表五个数字，数字的取值范围和含义如下：
分钟(0-59)
小時(0-23)
日期(1-31)
月份(1-12)
星期(0-6) //0代表星期天
01 * * * * root run-parts /etc/cron.hourly //每小时执行/etc/cron.hourly内的脚本
02 4 * * * root run-parts /etc/cron.daily //每天执行/etc/cron.daily内的脚本
22 4 * * 0 root run-parts /etc/cron.weekly //每星期执行/etc/cron.weekly内的脚本
42 4 1 * * root run-parts /etc/cron.monthly //每月去执行/etc/cron.monthly内的脚本
*/n : 表示每隔多少个时间单位执行一次；
如小时位 */1 就表示每隔1个小时执行一次命令，也可以写成 1-23/1
如：*/10 * * * * /opt/script/backup.sh ：每隔10分 执行
*/30 * * * * /usr/sbin/ntpdate 210.72.145.20 //每半小时同步一下时间
* */1 * * * /etc/init.d/nginx restart //每一小时重启nginx
注意："run-parts"命令：遍历目录文件夹，执行目录下可执行权限的文件，如果去掉这个参数的话，后面就可以写要运行的某个脚本名，而不是文件夹名了。
You have mail in /var/spool/mail/root，指定定时任务后记录的文件存放的位置
如：
30 3 10 20 * * ls
#每月10号及20号的3：30执行ls命令[注：”，”用来连接多个不连续的时间段]
25 8-11 * * * ls
#每天8-11点的第25分钟执行ls命令[注：“-”用来连接连续的时段]
*/1 * * * * ls
#每1分钟执行一次ls命令 [即每个小时的第0 15 30 45 60分钟执行ls命令 ]
*/15 * * * * ls
#每15分钟执行一次ls命令 [即每个小时的第0 15 30 45 60分钟执行ls命令 ]
30 6 */10 * * ls 每隔10天，6:30执行一次ls命令
步骤：
第一步：执行命令 crontab -e进入编辑状态
第二步：编写crontab表达式如： 1 * * * * /cat/crontab/sbin.sh(每天凌晨1点执行sbin.sh脚本)>
第三步：crontab -l 是看已保存的定时任务
注意事项
1、新创建的cron job，不会马上执行，至少要过2分钟才执行。如果重启cron则马上执行。
cron是一个linux下的定时执行工具，可以在无需人工干预的情况下运行作业。由于Cron 是Linux的内置服务，但它不自动起来，可以用以下的方法启动、关闭这个服务：
/sbin/service crond start //启动服务
/sbin/service crond stop //关闭服务
/sbin/service crond restart //重启服务
/sbin/service crond reload //重新载入配置
/etc/init.d/crond status #检测crontab 服务是否启动，
例1：
每周五17:30清理FTP服务器的公共共享目录， 检查 /var/ftp/pub/ 目录，将其中所有子目录及文件的详细列表、当时的时间信息追加保存到 /var/log/pubdir.log 日志文件中，然后清空该目录
[root@localhost ~]# vi /opt/ftpclean.sh
#!/bin/bash
date >> /var/log/pubdir.log
ls -lhR /var/ftp/pub >> /var/log/pubdir.log
rm -rf /var/ftp/pub/*
[root@localhost ~]# crontab -e
30 17 * * 5 /opt/ftpclean.sh
例2：
公司内网开发服务器中的数据库目录位于“/var/lib/mysql”，根据数据安全管理要求，要求至少每隔3天做一次完整备份
[root@localhost ~]# vi /opt/dbbak.sh
#!/bin/bash
DAY=`date %Y%m%d` #设置DATA格式
SIZE=`du -sh /var/lib/mysql` #查看当前目录下文件占用磁盘大小
echo "Date: $DAY" >> /tmp/dbinfo.txt
echo "Size: $Size" >> /tmp/dbinfo.txt
cd /opt/dbbak
tar zcvf mysqlbak-${DAY}.tar.gz /var/lib/mysql /tmp/dbinfo.txt
rm -f /tmp/dbinfo.txt
[root@localhost ~]# crontab -e
- 3 */3 * * /opt/dbbak.sh
注：
DAY=`date %Y%m%d`用于设置date命令查询信息的显示格式，如：20191217
${DAY}.tar.gz 表示的是要生成的文件名，当变量名称可能容易和紧跟其后的其他字符相混淆时，
需要添加大括号“{}”包围起来（这是引用变量的一种习惯，可以有效的减少变量引用错误的发生）
练习13.每周五17:30清理FTP服务器的公共共享目录(/var/ftp/pub) test.sh
mkdir -p /var/ftp/pub
cd /var/ftp/pub
ls –alR >> /var/log/pubdir.log
date >> /var/log/pubdir.log
rm –rf /var/ftp/pub
退出保存脚本本
Ls参数：
-a 显示所有文件及目录 (ls内定将文件名或目录名称开头为"."的视为隐藏档，不会列出)
-l 除文件名称外，亦将文件型态、权限、拥有者、文件大小等资讯详细列出
-R 若目录下有文件，则以下之文件亦皆依序列出
[root@localhost ~]# crontab -e
30 17 * * 5 test.sh# 绝对路径
注：设置时间和日期
例如：将系统日期设定成2019年11月3日的命令
命令 ： "date -s 11/03/2019"
将系统时间设定成下午5点55分55秒的命令
命令 ： "date -s 17:55:55"
预告：下一期开始小编开始发python学习课程
