shell条件判断流程控制与循环语句

本文主要是介绍shell条件判断流程控制与循环语句，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

条件判断

1、语法格式

　　1、test 条件表达式

　　2、[ 条件表达式 ] ***中括号两边得有空格有空值得加双引号否则会报错，[]里面不能加&& ||

　　3、[[ 条件表达式 ]] 支持正侧 = ~ ***中括号两边得有空格可以有空值里面可以用&& ||

2、常用判断条件

为真则输出0假则输出1
-e         #判断文件是否存在（任何类型文件）（存在为真，不存在为假） [ -e ./app ];echo $?
-f         #判断文件是否存在并且是一个普通文件    [ -f ./stu ];echo $?
-d         #判断文件是否存在并且是一个目录    [ -d ./app ]; echo $?
-L         #判断文件是否存在并且是一个软连接文件    [ -L ./test ];echo $?
-b         #判断文件是否存在并且是一个设备文件
-S（大写S） #判断文件是否存在并且是一个套接字文件
-s（小写s） #判断文件是否有内容（非空为真）
! -s(小写)  #判断文件是否无内容（空文件为真）
-c         #判断文件是否存在并且是一个字符设备文件
-p         #判断文件是否存在并且是一个命名管道文件
！　　　　　　#取反 用以以上条件的取反

文件权限相关判断
-r        #当前用户对其是否可读    [ -r ./frist_text.sh ];echo $?
-w        #当前用户是否可写
-x         #当前用户对其是否可执行
-u         #是否有suid 高级权限冒险位
-g         #是否sgid,高级权限强制位
-k         #是否有T位，高级权限粘滞位


判断文件新旧：

file1 -nt file2        #比较file1是否比file2新    test file1 -nt file2;echo $?
file1 -ot file2     #比较file1是否比file2旧    test file1 -nt file2;echo $?
file1 -ef file2     #比较是否为同一个文件，或者用于判断硬连接，是否指向同一个inode

-eq         #相等    [ 1 -eq 2 ];echo $?
-ne         #不等
-gt         #大于
-lt         #小于
-ge         #大于等于
-le         #小于等于
字符串的判断：（=和==都表示判断，但不等于只能用!=）
-z 判断是否为空字符，字符串长度为0则成立 A=123   [ -z "" ];echo $?　　[ -z "$A"];echo $? (判断变量A是否为空)
-n 判断是否为非空字符串，字符串长度不为0则成立    [ -z "aaa" ];echo $?
[ string1 = string2 ] 判断字符串是否相等 (字符串最好要用引号引起来，作为一个整体[]若有空字符串且不加引号会报错)
[ string1 != string2 ]判断字符串是否不相等  [ "$A" != "$B" ];echo $? (判断变量A和B 是否不相等)
#read -p "input yours name:" name
marry
[ "$name" = "marry" ] (变量name是否等于marry)
多重条件判断
-a 和 && 逻辑与  (全真为真，有假就假)
-o 和 || 逻辑或      (全假才假，有真必真)
a&&b : a和b同时为true 才返回 true， 否则返回false；
a || b ：a或b任意一个为true 就返回true ， 否则返回false
[ 1 -eq 1 -a 1 -ne 0 ]  整个表达式为真
[ 1 -eq 1 ]&&[ 1 -ne 0 ]
[[ 1 -eq 1 && 1 -ne 0 ]]

[ 1 -eq 1 -o 1 -ne 1 ]    第一个为真，第二个为假。整个表达式为真

[ 1 -eq 1 ]||[ 1 -ne 1 ]

[[ 1 -eq 1 || 1 -ne 1 ]]

总结：
1、； && ||都可以用来分割命令或表达式
2、；无论前面的语句是否错误，都会执行后边的语句
3、&& 前面的语句正确，才会执行后边的语句
4、|| 前面的语句错误，才会执行后边的语句
5、如果&&与||一起出现，从左往右依次看，遵循上边的规则

[ 1 -eq 1 ] && echo hello || echo world :第一个为真所以&&后的正确执行输出 因为第二个正确执行为真所以||不执行

[ 1 -eq 2 ] && echo hello || echo world :第一个为假所以&&后的不执行  ||直接对第一个进行判断为假 所以执行

[ 1 -eq 1 ] || echo hello && echo world :第一个为真所以||后的不执行 &&直接对第一个判断为真 所以执行

[ 1 -eq 2 ] || echo hello && echo world :第一个为假所以||后的执行输出 ||后的执行正确 为真 所以&&后的执行

类c风格的数值比较：(())中=表示赋值（只能赋予数值），==表示判断 < 小于 >=大于等于 !=不等于

(( $(id -u)==0 )) &&echo is admin :id-u 表示uid用户编号

流程控制语句

1、语法

F:files假

T：true真

1、
if [condition];then     #[condition] 判断语句：若为真则执行下面语句
　　command
fi

2、
if [condition1];then   若满足条件一则执行command1结束
　　command 1
elif[condition2];then　　若不满足条件一，满足条件二，则执行command2结束
　　command2
else　　　　　　　　　　　　若12都不满足，则执行commamd3结束
　　command3
fi

3、

if [condition1];then   若满足条件一则执行command1
　　command 1
　　if [condition2];then　　若满足条件2则执行command2结束 不满足2则结束
　　　　command2
　　if
else
　　if [condition3];then  若不满足条件一满足条件3，则执行command3结束
　　　　command3
　　elif[condition4];then　　若不满足条件一，满足条件4，则执行command4结束
　　　　command4
　　else　　　　　　　　　　　　若1 3 4都不满足，则执行commamd5结束
　　　　command5
　　fi

fi

应用案例

需求一：判断当前主机是否能够和远程主机ping通

#!/bin/bash
read -p "输入远程主机IP：" IP
ping -c1 $IP &>/tmp/file1 #把输出的放入到file1文件
if [ $? -eq 0 ];then
　　echo "ping通了"
else
　　echo "没ping通"
fi

#!/bin/bash

if [ $# -ne 1 ];then
　　echo "没有ip" && exit
fi
ping -c1 $1 &>/tmp/file1
[ $? -eq 0 ] && echo "ping通了" || echo "没ping通"

或者

#!/bin/bash

if [ $# -ne 1 ];then
　　echo "没有ip"
else

　　ping -c1 $1 &>/tmp/file1
　　[ $? -eq 0 ] && echo "ping通了" || echo "没ping通"
fi

需求2 判断进程是否存在

思路：
1.查看进程的相关命令 ps -ef pgrep ps auxf pidof
2.根据命令的返回状态值来判断进程是否存在 $?
3.根据逻辑用脚本语言实现

#!/bin/bash
# Name:process.sh
# Path:/shell02/
# Usage:/shell02/process.sh
# Describe:判断一个进程是否存在

# 定义变量
read -p "请输入需要判断的进程名(httpd):" process
# 通过命令来查看进程是否存在
pgrep $process &>/dev/null
# 通过命令执行的状态来判断是否存在
if [ $? -eq 0 ];then
echo "进程$process存在"
else
echo "进程$process不存在"
fi
或者
[ $? -eq 0 ] && echo "进程$process存在" || echo "进程$process不存在"

pgrep命令：以名称为依据从运行进程队列中查找进程，并显示查找到的进程id
选项
-o：仅显示找到的最小（起始）进程号;
-n：仅显示找到的最大（结束）进程号；
-l：显示进程名称；
-P：指定父进程号；pgrep -p 4764 查看父进程下的子进程id
-g：指定进程组；
-t：指定开启进程的终端；
-u：指定进程的有效用户ID。

需求3：判断一个服务是否正常（以httpd为例):

思路：

可以判断进程是否存在，用/etc/init.d/httpd status判断状态等方法
最好的方法是直接去访问一下，通过访问成功和失败的返回值来判断

#!/bin/bash
wget http://10.1.1.2 &>/dev/null
[ $? -eq 0 ] && echo "该web服务是正常的" && rm -f /shell/shell01/index.* || echo "该web服务异常请检查"

####3. 课堂练习

1、输入一个用户，用脚本判断该用户是否存在

read -p "请输入需要判断的用户名：" user
id $user &>/dev/null
test $? -eq 0 && echo "该$user存在" || echo "该$user不存在"

2、判断vsftpd软件包是否安装，如果没有则自动安装（yum源已配好）

#!/bin/bash
rpm -q vsftpd &> /dev/null  #-q 查询是否安装
if [ $? -eq 0 ];then
        echo "vsftpd已经安装"
else
        echo "该软件包没有安装，正在安装...."
        yum install -y vsftpd &> /dev/null

        if [ $? -eq 0 ];then
                echo "vsftpd安装成功"
        else
                echo "vsftpd安装失败"
        fi
fi

3、判断当前内核主版本是否为3，且次版本是否大于等于6；如果都满足则输出当前内核版本

思路：
1. 先查看内核的版本号    uname -r
2. 先将内核的版本号保存到一个变量里，然后再根据需求截取出该变量的一部分：主版本和次版本
3. 根据需求进步判断


#!/bin/bash
kernel=`uname -r`               # ``=$()
var1=`echo $kernel|cut -d. -f1`
var2=`echo $kernel|cut -d. -f2`
test $var1 -eq 3 -a $var2 -ge 6 && echo $kernel || echo "当前内核版本不符合要求"   #  -a=&&
或者
[ $var1 -eq 3 -a $var2 -ge 6 ] && echo $kernel || echo "当前内核版本不符合要求"
或者
[[ $var1 -eq 3 && $var2 -ge 6 ]] && echo $kernel || echo "当前内核版本不符合要求"

#如果用下边两个得知道版本和次版本的位数

或者 #!/bin/bash 
kernel=`uname -r` 
test ${kernel:0:1} -eq 3 -a ${kernel:2:2} -ge 6 && echo $kernel || echo '不符合要求' 
其他命令参考： 
uname -r|grep ^3.[6-9] || echo '不符合要求' #次版本为单位数

4、判断ftp服务是否已启动，如果已启动输出以下信息：

vsftpd服务器已启动...

vsftpd监听的端口是:

vsftpd的进程PID是:

参考1：
#!/bin/bash
service vsftpd status &>/dev/null
if [ $? -eq 0 ];then
    port=`netstat -tnltp|grep vsftpd|cut -d: -f2|cut -d' ' -f1`
    pid=`pgrep -l vsftpd|cut -d ' ' -f1`
    echo -e "vsftpd服务器已启动...\nvsftpd监听的端口是:$port\nvsftpd的进程PID是:$pid"
else
    service vsftpd start &>/dev/null
    port=`netstat -tnltp|grep vsftpd|cut -d: -f2|cut -d' ' -f1`
   pid=`pgrep -l vsftpd|cut -d ' ' -f1`
   echo -e "vsftpd服务器已启动...\nvsftpd监听的端口是:$port\nvsftpd的进程PID是:$pid"
fi


参考2：
[root@server shell02]# cat liufeng.sh 
#!/bin/bash
service $1 status
if [ $? -eq 0 ];then
        echo " '$1'服务器已启动..."
        a=$( netstat -tnulp | grep $1 )
        array=($a)
        echo "$1的监听端口是:$(echo ${array[3]} | cut -d: -f2) "
        echo "$1的进程ID为:$(echo ${array[6]}| cut -d/ -f1)"
else
        echo "$1进程未启动！"
fi

参考3：
vim /lt/2.sh
#! /bin/bash
duankou=`netstat -ntlp|grep vsftpd|cut -d: -f2|cut -d" " -f1`
pid=`pgrep -o vsftpd`

vim 1.sh
pgrep -l vsftpd >/dev/null
if [ $? -eq 0 ];then
        echo "vsftpd服务器已启动..."
        echo "vsftpd监听的端口是：$duankou"
        echo "vsftpd的进程PID是：$pid"
else
        echo "vsftpd服务器没启动"
        service vsftpd start
        source /lt/2.sh
fi

二、循环语句

1. for循环

1.1 语法结构

列表循环

列表for循环：用于将一组命令执行已知的次数，下面给出了for循环语句的基本格式：

for variable in {list}
     do
          command 
          command
          …
     done
或者
for variable in a b c
     do
         command
         command
     done
-n是换行
/n是不换行

语法结构举例说明：

 1045  for var in {1..10};do echo $var;done
 1046  for var in 1 2 3 4 5;do echo $var;done
 1047  for var in `seq 10`;do echo $var;done
 1048  for var in $(seq 10);do echo $var;done
 1049  for var in {0..10..2};do echo $var;done
 1050  for var in {2..10..2};do echo $var;done
 1051  for var in {10..1};do echo $var;done
 1052  for var in {10..1..-2};do echo $var;done
 1055  for var in `seq 10 -2 1`;do echo $var;done
{0..10..2}表示 从零开始打印，没打印一次var加2一直到其大于10为止 停止打印 输出 0，3，5，7，9
{10..1..-2} 表示 从10开始打印 没打印一次var减2 一直到其小于1 停止打印 输出 10，8，6，4，2
 for var in {1..10..-2};do echo $var;done 也会输出 1 ，3，5，7，9

seq命令的使用

作用：seq命令用于以指定增量从首数开始打印数字到尾数，即产生从某个数到另外一个数之间的所有整数，并且可以对整数的格式、宽度、分割符号进行控制

语法：

　　[1] seq [选项] 尾数

　　[2] seq [选项] 首数尾数

　　[3] seq [选项] 首数增量尾数（seq 起始值步长终止值）

选项：

-f, --format=格式按照指定的格式输出，不能和-f一起用（在不指定格式的情况下，默认格式为'%g'）

-s, --separator=分隔符指定输出的分隔符，默认为\n，即默认为回车换行

-w, --sequal-width 指定为定宽输出，不能和-w一起使用

　制表符（\t）相当于 Tab 键

实例：

[1] 产生5以内的整数

命令：seq 5

输出：

[2]产生-2~10内的整数，增量为2

命令：seq -2 2 10

　　　输出：

[3] 产生98~101之间的整数，并且要求输出数字宽度相同，不足的用空格补足。

命令： seq -f "%3g" 98 101 （"%3g" 这种格式表示指定“位宽”为三位，数字位数不足部分用空格补位）

输出：

命令：seq -f "%03g" 98 101 （"%03g" 这种格式表示指定“位宽”为三位，数字位数不足部分用0补位，通过%后添加0替代空格补足空位）

　　输出：

注意：其实 % 前面还可以指定字符串

列如：一次性创建5个名为dir001，dir002，..dir005的目录

1、mkdir $(seq -f 'dir%03g' 1 5)

　　 2、seq -f 'dir%03g' 1 5 | xargs mkdir

[4] 产生98~101之间的整数，并且要求数字之间的分隔符为":::"。

命令：seq -s ":::" -f "%03g" 98 101

输出：

[5]输出98~100之间的整数，要求宽度一致（-w 以最大值的位数为标准宽度，不足标准宽度的数字将会用0补位）

命令：seq -w 98 101

输出：

　　　注意：-w选项不能和-f选项一起用，输出是同宽的

1.2 不带列表循环

不带列表的for循环执行时由用户指定参数和参数的个数，下面给出了不带列表的for循环的基本格式

for variable
    do
        command 
        command
        …
   done

语法结构举例说明：

#!/bin/bash
for var
do
echo $var
done

echo "脚本后面有$#个参数"

1.3 类C风格的for循环

for(( expr1;expr2;expr3 ))
    do
        command
        command
        …
    done
for (( i=1;i<=5;i++))
    do
        echo $i
    done


expr1：定义变量并赋初值
expr2：决定是否进行循环（条件）
expr3：决定循环变量如何改变，决定循环什么时候退出

语法结构举例说明：

1068  for ((i=1;i<=5;i++));do echo $i;done
 1069  for ((i=1;i<=10;i+=2));do echo $i;done
 1070  for ((i=2;i<=10;i+=2));do echo $i;done

1.2 举例说明

例1：计算1到100的奇数之和，方法不止一思路：1. 定义一个变量来保存奇数的和 sum=02. 找出1-100的奇数，保存到另一个变量里 i3. 从1-100中找出奇数后，再相加，然后将和赋值给sum变量4. 遍历完毕后，将sum的值打印出#!/bin/bash#定义一个变量来保存奇数的和

思路：
1. 定义一个变量来保存奇数的和 sum=0
2. 找出1-100的奇数，保存到另一个变量里 i
3. 从1-100中找出奇数后，再相加，然后将和赋值给sum变量
4. 遍历完毕后，将sum的值打印出来


延伸：
true    真
:        真
false     假



方法1：
#!/bin/bash
sum=0
for i in {1..100..2}
do
    sum=$[$i+$sum]
done
echo "1-100的奇数和为:$sum"

方法2：
#!/bin/bash
sum=0
for ((i=1;i<=100;i+=2))
do
    let sum=i+sum   #let 命令是 BASH 中用于计算的工具，用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量。如果表达式中包含了空格或其他特殊字符，则必须引起来。

#let sum=sum+$i

#let sum=sum+i

 #let sum=$sum+$i

done
echo "1-100的奇数和为:$sum"

方法3：
#!/bin/bash
sum=0
for ((i=1;i<=100;i++))
do
    if [ $[$i%2] -ne 0 ];then        #$[] $(()) :它们是一样的，都是进行数学运算的。支持+ - * / %：分别为 “加、减、乘、除、取模”。但是注意，bash只能作整数运算，对于浮点数是当作字符串处理的。

    let sum=$sum+$i
    fi
或者
test $[$i%2] -ne 0 && let sum=$sum+$i 

done
echo "1-100的奇数和为:$sum"

方法4：
sum=0
for ((i=1;i<=100;i++))
do
    if [ $[$i%2] -eq 0 ];then
    continue
    else
    let sum=$sum+$i
    fi
done
echo "1-100的奇数和为:$sum"

#!/bin/bash
sum=0
for ((i=1;i<=100;i++))
do
    test $[$i%2] -eq 0 && continue || let sum=sum+$i  #continue 代表继续 也可以换成true 或： 代表0为真
done
echo "1-100的奇数和是:$sum"

循环控制：

循环体： ==do....done==之间的内容

continue：继续；表示==循环体==内下面的代码不执行，重新开始下一次循环
break：打断；马上停止执行本次循环，执行==循环体==后面的代码
exit：表示直接跳出程序

[root@server ~]# cat for5.sh 
#!/bin/bash
for i in {1..5}
do
    test $i -eq 2 && break || touch /tmp/file$i
done
echo hello hahahah

例2：输入一个正整数,判断是否为质数(素数）

质数：只能被1和它本身整除的数叫质数。

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

思路：
0. 让用户输入一个数，保存到一个变量里   read num
1、如果能被其他数整除就不是质数——>$num%$i 是否等于0    $i=2~$num-1
2、如果输入的数是1或者2取模根据上面判断又不符合，所以先排除1和2
3、测试序列从2开始，输入的数是4——>得出结果$num不能和$i相等，并且$num不能小于$i

#!/bin/bash
read -p "请输入一个正整数字:" number

[ $number -eq 1 ] && echo "$number不是质数" && exit
[ $number -eq 2 ] && echo "$number是质数" && exit

for i in `seq 2 $[$number-1]`
do
[ $[$number%$i] -eq 0 ] && echo "$number不是质数" && exit
done
echo "$number是质数" && exit

bash -x for6.sh

举例3：批量加5个新用户，以u1到u5命名，并统一加一个新组，组名为class,统一改密码为123

思路：
1. 添加用户的命令 useradd -G
2. 判断class组是否存在    grep -w class /etc/group；echo $?
3. 根据题意，判断该脚本循环5次来添加用户    for循环
4. 给用户设置密码，应该放到循环体里面

#!/bin/bash
#判断class组是否存在
grep -w class /etc/group &>/dev/null
[ $? -ne 0 ] && groupadd class
#批量创建5个用户
for i in {1..5}
do
    useradd -G class u$i
    echo 123|passwd --stdin u$i
done


#!/bin/bash
#判断class组是否存在
cut -d: -f1 /etc/group|grep -w class &>/dev/null
[ $? -ne 0 ] && groupadd class

#循环增加用户，循环次数5次，for循环,给用户设定密码
for ((i=1;i<=5;i++))
do
    useradd u$i -G class
    echo 123|passwd --stdin u$i
done



#!/bin/bash
grep -w class /etc/group &>/dev/null
test $? -ne 0 && groupadd class
或者
groupadd class &>/dev/null

for ((i=1;i<=5;i++))
do
useradd -G class u$i && echo 123|passwd --stdin u$i
done

1.3 课堂练习

批量新建5个用户stu1~stu5，要求这几个用户的家目录都在/rhome.提示：需要判断该目录是否存在

#!/bin/bash
#判断/rhome是否存在
[ -f /rhome ] && mv /rhome /rhome.bak
test ! -f /rhome -a ! -d /rhome && mkdir /rhome
或者
[ -f /rhome ] && mv /rhome /rhome.bak || [ ! -d /rhome ] && mkdir /rhome 
#创建用户，循环5次
for ((i=1;i<=5;i++))
do
    useradd -d /rhome/stu$i stu$i
    echo 123|passwd --stdin stu$i
done

写一个脚本，局域网内，把能ping通的IP和不能ping通的IP分类，并保存到两个文本文件里,这是一个局域网内机器检查通讯的一个思路。

以10.1.1.1~10.1.1.10为例

#!/bin/bash
#定义变量
ip=10.1.1
#循环去ping主机的IP
for ((i=1;i<=10;i++))
do
    ping -c1 $ip.$i &>/dev/null
    if [ $? -eq 0 ];then
        echo "$ip.$i is ok" >> /tmp/ip_up.txt
    else
        echo "$ip.$i is down" >> /tmp/ip_down.txt
    fi
    或者
    [ $? -eq 0 ] && echo "$ip.$i is ok" >> /tmp/ip_up.txt || echo "$ip.$i is down" >> /tmp/ip_down.txt
done

[root@server shell03]# time ./ping.sh         

real    0m24.129s
user    0m0.006s
sys     0m0.005s

并行执行：
{程序}&表示将程序放到后台并行执行，如果需要等待程序执行完毕再进行下面内容，需要加wait

#!/bin/bash
#定义变量
ip=10.1.1
#循环去ping主机的IP
for ((i=1;i<=10;i++))
do
{

        ping -c1 $ip.$i &>/dev/null
        if [ $? -eq 0 ];then
                echo "$ip.$i is ok" >> /tmp/ip_up.txt
        else
                echo "$ip.$i is down" >> /tmp/ip_down.txt
        fi
}&
done
wait
echo "ip is ok...."

[root@server ~]# time ./ping.sh 
ip is ok...

real    0m3.091s
user    0m0.001s
sys     0m0.008s

3、输入一个年份，判断是否是润年（能被4整除但不能被100整除，或能被400整除的年份即为闰年。）

#!/bin/bash
read -p "Please input year:(2017)" year
if [ $[$year%4] -eq 0 -a $[$year%100] -ne 0 ];then
    echo "$year is leap year"
elif [ $[$year%400] -eq 0 ];then
    echo "$year is leap year"
else
    echo "$year is not leap year"
fi

2. while循环

特点：==条件为真就进入循环；条件为假就退出循环==

2.1 语法结构

while 表达式
    do
        command...
    done
    
while  [ 1 -eq 1 ] 或者 (( 1 > 2 ))
  do
     command
     command
     ...
 done
=========================================================
打印1-5数字
FOR循环打印：
for ((i=1;i<=5;i++))
do
    echo $i
done

while循环打印：
i=1
while [ $i -le 5 ]
do
    echo $i
    let i++
done

2.2 举例说明

需求：用while循环计算1-50的偶数和

#!/bin/bash
#定义变量
sum=0
i=2
#循环打印1-50的偶数和并且计算后重新赋值给sum
while [ $i -le 50 ]
do
    let sum=sum+i
    let i+=2
done
#打印sum的值
echo "1-50的偶数和为:$sum"

2.3 应用案例

需求：

写一个30秒同步一次时间，向同步服务器10.1.1.250的脚本,如果同步失败，则进行邮件报警,每次失败都报警;同步成功,也进行邮件通知,但是成功100次才通知一次。

分析：

每个30s同步一次时间，该脚本是一个死循环
- while true;do 同步时间，然后休息30s（sleep 30）done
同步失败发送邮件
- 在do.....done循环体之间加if...else...(判断同步失败还是成功)
同步成功100次发送邮件
- 统计成功次数——>count=0——>成功1次加+1——>let count++

#!/bin/bash
#定义变量
count=0
ntp_server=10.1.1.250
while true
do
    rdate -s $ntp-server &>/dev/null
    if [ $? -ne 0 ];then
        echo "system date failed" |mail -s 'check system date'  root@localhost    
    else
        let count++
        if [ $[$count%100] -eq 0 ];then
        echo "system date successfull" |mail -s 'check system date'  root@localhost && count=0
        fi
    fi
sleep 3
done

3. until循环

3.1 语法结构

特点：==条件为假就进入循环；条件为真就退出循环==

until expression   [ 1 -eq 1 ]  (( 1 >= 1 ))
    do
        command
        command
        ...
    done
    
i=1
while [ $i -le 5 ]
do
    echo $i
    let i++
done

i=1
until [ $i -gt 5 ]
do
    echo $i
    let i++
done

3.2 举例说明

使用until语句批量创建10个用户，要求stu1—stu5用户的UID分别为1001—1005；stu6~stu10用户的家目录分别在/rhome/stu6—/rhome/stu10

#!/bin/bash
i=1
until [ $i -gt 10 ]
do
    if [ $i -le 5 ];then
        useradd -u $[1000+$i] stu$i && echo 123|passwd --stdin stu$i
    else
        [ ! -d /rhome ] && mkdir /rhome
        useradd -d /rhome/stu$i stu$i && echo 123|passwd --stdin stu$i        
    fi
let i++
done

这篇关于shell条件判断流程控制与循环语句的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程