shell脚本应用（三）-阿里云开发者社区

使用for循环语句

当面对各种列表重复任务是，使用简单的if语句已经难以满足要求，而顺序编写全部代码更是显得异常繁琐、困难重复，for循环语句可以很好地解决类似问题。

for语句的结构

使用for循环语句时，需要指定一个变量及可能的取值列表，针对每个不同的取值重复执行相同的命令序列，直到变量使用完退出循环。在这里“取值列表”称为for语句的执行条件，其中包括多个属性相同的对象，需要预先指定（如通讯录，IP黑名单）。

for循环语句的语法结构如下。

1.  fro 变量名 in  取值列表
2.  do
3.      命令序列
4.  done

上述语句结构中，for语句的操作对象为用户指定名称的变量，并通过in关键字为变量预先设置了一个取值列表，多个取值之间以空格进行分隔。位于do...done之间的命令序列称为循环体，其中的执行语句需要引用变量以完成相应的任务。

for语句的执行流程：

首先将列表中的第一个取值赋给变量，并执行do...done循环体中的命令序列；然后将列表中的第二个取值赋给变量，并执行循环体中的命令序列......以此类推，直到列表中的所有取值用完，最后将跳至done语句，表示结束循环，如图所示。

for语句应用示例

1）根据姓名列表批量添加用户

根据人事部门给出的员工姓名的拼音列表，在linux服务器中添加相应的用户账户，初始密码均设置为“123456”。其中，员工姓名列表中的账号数量并不固定，而且除了要求账号名称是拼音之外，并无其他特殊规律。

针对上述要求，可先指定员工列表users.txt，然后编写一个名为uaddfor.sh的shell脚本，从users.txt文件中读取各用户名称，重复执行添加用户，设置初始密码的相关操作。

1.  [root@localhost ~]# vim /root/users.txt                         //用做测试的列表文件
2.  zhangsan
3.  wangwu
4.  zhaoliu
5.  [root@localhost ~]# vim uaddfor.sh                              //批量添加用户的脚本
6.  [root@localhost ~]# chmod +x uaddfor.sh 
7.  #!/bin/bash
8.  A=$(cat  /root/users.txt)
9.  for B in $A
10.  do
11.          useradd $B
12.          echo "123456" | passwd --stdin $B &>  /dev/null
13.  done
14.  [root@localhost ~]# ./uaddfor.sh                                //测试并确认执行结果
15.  [root@localhost ~]# tail -3 /etc/passwd
16.  zhangsan:x:1001:1001::/home/zhangsan:/bin/bash
17.  wangwu:x:1002:1002::/home/wangwu:/bin/bash
18.  zhaoliu:x:1003:1003::/home/zhaoliu:/bin/bash

若要删除addfor.sh脚本所添加的用户，只需参照上述脚本代码，将for循环体中添加用户的命令序列改为删除用户的操作即可。例如，建立一名为udelfor.sh的脚本如下所示。

1.  [root@localhost ~]# vim udelfor.sh                          //批量删除用户的脚本
2.  #!/bin/bash
3.  A=$(cat  /root/users.txt)
4.  for B in $A
5.  do
6.          userdel -r $B &>/dev/null
7.  done
8.  [root@localhost ~]# chmod +x udelfor.sh 
9.  [root@localhost ~]# ./udelfor.sh                            //测试并确认执行结果
10.  [root@localhost ~]# id zhangsan
11.  id: zhangsan: no such user                                  //提示无此用户

2）根据IP地址列表检查主机状态

根据包含公司各服务器IP地址的列表文件，检查其中各主机的ping连通性，输出个主机是否启动，关闭。其中，服务器的数量并不固定，个服务器的IP地址之间无特殊规律。

针对此案例要求，可先指定IP地址列表文件ipadds.txt，然后编写一个名为chkhosts.sh的shell脚本，从ipadds.txt文件中读取各服务器的IP地址，执行ping连通性测试，并根据测试结果输出相应的提示信息。

1.  [root@localhost ~]# vim /root/ipadds.txt
2.  192.168.1.10
3.  192.168.1.20
4.  192.168.1.30
5.  192.168.1.40
6.  192.168.1.50
7.  @localhost ~]# vim chkhosts.sh
8.  #!/bin/bash
9.  A=$(cat /root/ipadds.txt)
10.  for IP in $A
11.  do
12.   ping -c 3 -i 0.2 -W 3 $IP &>/dev/null
13.   if [ $? -eq 0 ]
14.   then
15.          echo "Host $IP is up"
16.   else
17.          echo "Host $IP is down"
18.  fi
19.  done
20.  [root@localhost ~]# chmod +x chkhosts.sh 
21.  [root@localhost ~]# ./chkhosts.sh 
22.  Host 192.168.1.10 is down
23.  Host 192.168.1.20 is down
24.  ...

上述执行脚本中，没有ipadds.txt文件中的IP地址，设置其他IP只需要在ipadds.txt文件中添加IP地址信息即可。例如，设置本机IP为1.10后在执行脚本查看结果，如下所示。

1.  [root@localhost ~]# ifconfig ens33 192.168.1.10
2.  [root@localhost ~]# ./chkhosts.sh 
3.  Host 192.168.1.10 is up
4.  Host 192.168.1.20 is down
5.  ...

上述脚本代码中，do...done循环体内嵌套使用了if条件选择语句，用来针对不同IP地址的测试结果进行判断，并输出相应的提示信息。嵌套可以理解为镶嵌、套用，就是在已有的语句，函数中再多加一个或多个语句、函数等。实际上，if语句、for语句及其他各种shell脚本语句都是可以嵌套使用的。

使用while循环语句

for循环语句非常适用于列表对象无规律，且列表来源固定（如某个列表文件）的场合。而对与要求控制循环次数，操作对象按数字顺序编号，按特定条件执行重复操作等情况，则更适合使用另外一种循环——while语句。

while语句的结构

使用while循环语句时，可以根据特定的条件反复执行一个命令序列，直到该条件不在满足时为止。在脚本应用中，应该避免出现死循环的情况，否则后边的命令操作将无法执行。因此，循环体内的命令序列中应包括修改测试条件的语句，以便在适当的时候使测试条件不再成立，从而结束循环。

while循环语句的语法结构如下所示。

1.  while 条件测试操作
2.  do
3.      命令序列
4.  done

while语句的执行流程：

首先判断while后的条件测试操作结果，如果条件成立，则执行do...done循环体中的命令序列；返回while后再此判断条件测试结果，如果条件仍然成立，则继续执行循环体；再次返回while后，判断条件测试结果......如此循环，直到while后的条件测试结果不再成立为止，最后转跳到done语句，表示结束循环。

使用while循环语句时，有两个特殊的条件测试操作，即true（真）和false（假）。使用true作为条件时，表示条件永远成立，循环体内的命令序列将无限执行下去，除非强制终止脚本（或通过exit语句退出脚本）；反之，若false作为条件，则循环体将不会被执行。这两个特殊条件也可以用在if语句的条件测试中。

while语句应用示例

1. 批量添加规律编号的用户

在一些技术培训和学习领域，出于实验或测试的目的，需要批量添加用户账号，这些用户的名称中包含固定的前缀字串，并按照数字顺序依次进行编号，账号的数量往往是固定的。例如，若要添加20个用户，名称依次为stu1,stu2,...,stu20，可以参考以下操作。

1.  [root@localhost ~]# vim uaddwhile.sh
2.  #!/bin/bash
3.  A="stu"
4.  i=1
5.  while [ $i -le 20 ]
6.  do
7.   useradd ${A}$i
8.   echo "123456" | passwd --stdin ${A}$i &> /dev/null
9.  let i++
10.  done
11.  [root@localhost ~]# chmod +x uaddwhile.sh

上述脚本代码中，使用变量”i“来控制用户名称的编号，初始赋值为1，并且当取值大于20时终止循环。在循环体内部，通过语句“let i++” ,等同于i=$(expr $i + 1)来使用变量i的值增加1，因此当执行第一次循环后i的值将变为2，执行第二次循环后i的值将变为3，......，以此类推。

测试并确认uaddwhile.sh脚本的执行结果如下。

1.  [root@localhost ~]# ./uaddwhile.sh 
2.  [root@localhost ~]# grep "stu" /etc/passwd | tail -3
3.  stu18:x:1018:1018::/home/stu18:/bin/bash
4.  stu19:x:1019:1019::/home/stu19:/bin/bash
5.  stu20:x:1020:1020::/home/stu20:/bin/bash

若要删除uaddwhile.sh脚本所添加的用户，只需要参考上述脚本代码，将while循环体中添加用户的命令序列改为删除用户的操作即可。

1.  [root@localhost ~]# vim udelwhile.sh                    //批量删除用户的脚本
2.  #!/bin/bash
3.  A="stu"
4.  i=1
5.  while [ $i -le 20 ]
6.  do
7.   userdel -r ${A}$i
8.  let i++
9.  done
10.  [root@localhost ~]# ./udelwhile.sh                      //测试并确认执行结果
11.  [root@localhost ~]# id stu20
12.  id: stu20: no such user                                 //用户stu20不存在

2. 猜价格游戏

案例要求如下：由脚本预先生成一个随机的价格数目（0-999）作为实际价格，判断用户猜测的价格是否高出或低于实际价格，给出相应提示后再此要求用户猜测；一直到用户猜中实际价格位置，输出用户共猜测的次数，实际价格。

针对上述要求，主要设计思路如下：通过环境变量RANDOM可获得一个小于2的16次方的随机整数，计算其与1000的余数即可获得0~999的随机价格，反复猜测操作可以用个以true作为测试条件的while循环实现，当用户猜中实际价格时终止循环，判断猜测价格与实际价格的过程采用if语句实现，嵌套在while循环体内；使用变量来记录猜测次数。

1.  [root@localhost ~]# vim pricegame.sh
2.  #!/bin/bash
3.  PRICE=$(expr $RANDOM % 1000)
4.  TIMES=0
5.  echo "商品实际价格范围为0-999，猜猜看是多少？"
6.  while true
7.  do
8.  read -p "请输入你猜测的价格数目：" INT
9.  let TIMES++
10.  if [ $INT -eq $PRICE ] ; then
11.   echo "恭喜你猜对了，实际价格时$PRICE"
12.   echo "你总共猜测了 $TIMES 次"
13.   exit 0
14.  elif [ $INT -gt $PRICE ] ; then
15.   echo "太高了！"
16.  else
17.   echo "太低了！"
18.  fi
19.  done
20.  [root@localhost ~]# chmod +x pricegame.sh

测试并确认pricegame.sh脚本的执行结果如下

1.  [root@localhost ~]# ./pricegame.sh 
2.  商品实际价格范围为0-999，猜猜看是多少？
3.  请输入你猜测的价格数目：500
4.  太高了！
5.  请输入你猜测的价格数目：400
6.  太高了！
7.  请输入你猜测的价格数目：300
8.  太低了！
9.  请输入你猜测的价格数目：350
10.  太高了！
11.  请输入你猜测的价格数目：340
12.  太高了！
13.  请输入你猜测的价格数目：320
14.  恭喜你猜对了，实际价格时320
15.  你总共猜测了 6 次

学会条件测试操作及if，for，while语句的使用以后，已基本可以编写一般的管理脚本。当然只有大家对各种命令，管道，重定向等命令操作融汇贯通，才能编写出更优秀的脚本程序。shell脚本的应用灵活多变，即使是完成同一项任务，也可能有许多种不同的实现方式，大家应该勤加练习，在实践过程中慢慢去领会。

使用case分支语句

case语句可以使脚本程序的结构更加清晰、层次分明。

case语句的结构

case语句主要适用于以下情况；某个变量存在多种取值，需要对其中的每一种取值分别执行不同的命令序列。这种情况与多分支的if语句非常相似，只不过if语句需要判断多个不同的条件，而case语句只是判断一个变量的不同取值。

case分支语句的语法结构如下所示

1.  case 变量值 in
2.  模式1）
3.      命令序列1
4.      ;;
5.  模式2）
6.      命令序列2
7.      ;;
8.      ......
9.  *)
10.  默认命令序列
11.  esac

在上述语句结构中，关键字case后面跟的是“变量值”，即“$变量名”，这点需要与for循环语句的结构加以区别。整个分支结构包括在case...esac之间，中间的模式1，模式2, ...，*对应为变量的不同取值（程序期望的取值），其中 “ * ”号作为通配符，可以匹配任意值。

case语句的执行流程：

首先使用“变量值”与模式1进行比较，若取值相同则执行模式1后的命令序列，直到遇见双分号“；；”后转跳至esac，表示结束分支；若与模式1不相匹配，则继续与模式2进行比较，若取值相同则执行模式2后的命令序列，只到遇见双分号“；；”后跳转至esac，表示结束分支...以此类推，若找不到任何匹配的值，则执行默认模式“*)”后的命令序列，只到遇见esac后结束分支。

使用case分支语句时，有几个值得注意的特点如下所述。

case行尾必须为单词“in”，每一模式必须以左括号“）”结束
双分号“；；“表示命令序列的结束。
模式字符串中，可以用方括号表示一个连续的范围，如“[0-9]”; 还可以用竖行符号“|”表示或，如“A|B"。
最后的“*）”表示默认模式，其中的” * “相当于通配符。

case语句应用示例

1）检查用户输入的字符类型

提示用户号从键，盘输入的一个字符，通过case语句判断字符是否为字母，数字或者其他控制字符，并给出相应的提示信息。

1.  [root@localhost ~]# vim hitkey.sh
2.  
3.  #!/bin/bash
4.  read -p "请输入一个字符，并按Enter键确认：" KEY
5.  case "$KEY" in
6.    [a-z]|[A-Z])                                      //匹配任意字母
7.          echo "您输入的是 字母."
8.          ;;
9.    [0-9])                                            //匹配任意数字
10.          echo "您输入的是 数字."
11.          ;;
12.  *)                                                  //默认模式，匹配任意字符
13.          echo "您输入的是 空格、功能键或其他控制字符."
14.  esac
15.  [root@localhost ~]# chmod +x hitkey.sh

测试并确认hitkey.sh脚本执行结果如下

1.  [root@localhost ~]# ./hitkey.sh
2.  请输入一个字符，并按Enter键确认：f
3.  您输入的是 字母.
4.  [root@localhost ~]# ./hitkey.sh
5.  请输入一个字符，并按Enter键确认：1
6.  您输入的是 数字.
7.  [root@localhost ~]# ./hitkey.sh
8.  请输入一个字符，并按Enter键确认：^[[19~
9.  您输入的是 空格、功能键或其他控制字符.

2）编写系统服务脚本

编写一个名为myprog的系统服务脚本，通过位置变量$1指定的start，stop，restart，status控制参数，分别用来启动，停止，重启sleep进程，以及查看sleep进程的状态。其中，命令sleep用来暂停指定秒数的时间，这里仅用做测试，在实际运维工作中应将sleep改为相应后台服务的控制命令序列。

1.  [root@localhost ~]# vim myprog
2.  #!/bin/bash
3.  case "$1" in
4.  start)
5.    echo -n "正在启动sleep服务 ..."
6.    if sleep 7200 &
7.  then                                                //在后台启动sleep进程
8.          echo "OK"
9.    fi
10.    ;;
11.  stop)
12.    echo -n "正在停止sleep服务 ..."
13.    pkill "sleep" &> /dev/null
14.    echo "OK"                                         //停止sleep进程
15.    ;;
16.  status)
17.    if pgrep "sleep" &>/dev/null ; then               //判断并提示sleep进程状态
18.      echo "sleep服务已经启动"
19.  else
20.      echo "sleep服务已经停止"
21.    fi
22.    ;;
23.  restart)                                            //先停止、在启动服务
24.          $0 stop
25.          $0 start
26.    ;;
27.  *)                                                  //默认显示用法信息 
28.    echo "用法：*0 {start|stop|status|restart}"
29.  esac
30.  [root@localhost ~]# chmod +x myprog
31.  [root@localhost ~]# ./myprog start
32.  正在启动sleep服务 ...OK
33.  [root@localhost ~]# ./myprog status
34.  sleep服务已经启动
35.  [root@localhost ~]# ./myprog stop
36.  正在停止sleep服务 ...OK
37.  [root@localhost ~]# ./myprog reload
38.  用法：*0 {start|stop|status|restart}

在Linux系统中，源码软件包编译安装后提供的服务控制脚本使用了case分支语句；也有一些源码包没有提供服务控制脚本，编译安装后可参照上例自行编写服务控制脚本。平时控制各种系统服务时，提供的start，stop，restart等位置参数，正是由case语句结构来识别并完成相应的操作的。若要将myporg服务交给systemd来管理，还需要在/lib/systemd/system 目录下添加相应的myprog.service配置文件。

shell脚本应用（三）