bash脚本编程---循环

时间：2023-03-08 16:11:51
bash为过程式编程语言
代码执行顺序：
1.顺序执行：逐条执行
2.选择执行：代码有一个分支，条件满足时才会执行
                      两个或以上的分支，只会执行其中一个满足条件的分支
3.循环执行：代码片段（循环体）要执行0，1或多个来回
4.选择执行：
单分支的if语句：
if 测试语句
then
   代码分支
fi

双分支的if语句：

if 测试条件；then
      条件为真时执行的分支
else
     条件为假时执行的分支
fi

例1：通过参数传递一个用户名给脚本，此用户不存时，则添加之； 

    

  1. #!/bin/bash
    2. 

    3. 

  3. if ! (grep "^$1\>" /etc/passwd &> /dev/null);then
    4. 

  4.      useradd $1
    5. 

  5.      echo $1 | passwd --stdin $1 &>/dev/null
    6. 

  6.      echo "add user $1 finished."
    7. 

  7. else
    8. 

  8.      echo "the user $1 is exists."
    9. 

  9. fi
    10. 

  10. #如果给出的用户不存在，就添加，用户帐号与密码相同，如果存在就提示存在
    11.
注意：重定向>之前加&表示不论对错全部输出至指定文件夹
上面的补充：
    

  1. #!/bin/bash
    2. 

    3. 

  3. if [ $# -eq 1 ];then
    4. 

  4.    echo "At least one username."
    5. 

  5.    exit 2
    6. 

  6. fi
    7. 

  7. #先判断是否输入了一个参数，如果没有或者输入了多个参数就退出
    8. 

  8. #如果是“-lt”，则表示最少一个参数，即使输入多个也只取第一个
    9. 

    10. 

  10. if ! (grep "^$1\>" /etc/passwd &> /dev/null);then
    11. 

  11.      useradd $1
    12. 

  12.      echo $1 | passwd --stdin $1 &>/dev/null
    13. 

  13.      echo "add user $1 finished."
    14. 

  14. else
    15. 

  15.      echo "the user $1 is exists."
    16. 

  16. fi
    17.
例2：通过命令行参数给定两个数字，输出其中较大的数值；
    

  1. #!/bin/bash
    2. 

    3. 

  3. if [ $# -lt 2 ];then
    4. 

  4.    echo "Must give two num."
    5. 

  5.    exit 2
    6. 

  6. fi
    7. 

    8. 

  8. if [ $1 -ge $2 ];then
    9. 

  9.    echo "Max num is $1."
    10. 

  10. else
    11. 

  11.    echo "Max num is $2."
    12. 

  12. fi
    13.
另一种表达方式：
    

  1. #!/bin/bash
    2. 

  2. if [ $# -lt 2 ];then
    3. 

  3.    echo "Must give two num."
    4. 

  4. fi
    5. 

    6. 

  6. declare -i max=$1
    7. 

  7. if [ $1 -lt $2 ];then
    8. 

  8.    max=$2
    9. 

  9. fi
    10. 

  10. echo "The max num is $max"
    11. 

  11. #先对max进行赋值，然后进行比较
    12.
例2：通过命令行参数给定一个用户名，判断其ID号是偶数还是奇数；
    

  1. #!/bin/bash
    2. 

  2. if [ $# -lt 1 ];then
    3. 

  3.    echo "Must give a username."
    4. 

  4. fi
    5. 

    6. 

  6. num=$(id -u $1)
    7. 

  7. let num2=$num%2
    8. 

  8. #echo "num is $num"
    9. 

  9. #echo "num2 is $num2"
    10. 

  10. if [ $num2 -eq 1 ];then
    11. 

  11.    echo "the uid is ji"
    12. 

  12. else
    13. 

  13.    echo "the uid is ou"
    14. 

  14. fi
    15.
例3：通过命令行参数给定两个文本文件名，如果某文件不存在，则结束脚本执行；
都存在时返回每个文件的行数，并说明其中行数较多的文件；
    

  1. #!/bin/bash
    2. 

  2. if [ $# -lt 2 ];then
    3. 

  3.    echo "Must give two filename."
    4. 

  4.    exit 2
    5. 

  5. fi
    6. 

    7. 

  7. if [ -f $1 ];then
    8. 

  8.    num1=$(cat $1 |wc -l)
    9. 

  9.    echo "the file $1 is exists and hangshu is $num1."
    10. 

  10. else
    11. 

  11.    echo "the file $1 is not exists."
    12. 

  12.    exit 4
    13. 

  13. fi
    14. 

    15. 

  15. if [ -f $2 ];then
    16. 

  16.    num2=$(cat $2 |wc -l)
    17. 

  17.    echo "the file $2 is exists and hangshu is $num2."
    18. 

  18. else
    19. 

  19.    echo "the file $2 is not exists."
    20. 

  20.    exit 3
    21. 

  21. fi
    22. 

    23. 

  23. if [ $num1 -lt $num2 ];then
    24. 

  24.    echo "$2 hangshu is more."
    25. 

  25. else
    26. 

  26.    echo "$1 hangshu us more."
    27.

1.bash编程之选择执行--if语句

选择执行：
1.&&，||
2.if语句
3.case语句
if语句有三种格式：

1.1 单分支if语句

    

  1. if 测试条件；then
    2. 

  2.    为真时执行；
    3. 

  3. fi
    4.

1.2 双分支if语句

    

  1. if 测试条件；then
    2. 

  2.    为真时执行
    3. 

  3. else
    4. 

  4.    为假时执行
    5. 

  5. fi
    6.

1.3 多分支语句

    

  1. if 测试条件；then
    2. 

  2.    条件1为真时执行
    3. 

  3. elif condition-2;then
    4. 

  4.    条件2为真时执行
    5. 

  5. elif condition-3;then
    6. 

  6.    条件3为真时执行
    7. 

  7. 。。。。
    8. 

  8. elif condition-n;then
    9. 

  9.    条件n为真时执行
    10. 

  10. else 
    11. 

  11.    所有条件都不满足时执行的分支
    12. 

  12. fi
    13.
注意：即便多个条件可能同时都能满足，分支只会执行中其中一个，首先测试为“真”；
例1：脚本参数传递一个文件路径给脚本，判断此文件的类型；
    

  1. #!/bin/bash
    2. 

  2. #
    3. 

  3. if [ $# -lt 1 ];then
    4. 

  4.    echo "Must give a path."
    5. 

  5.    exit 2
    6. 

  6. fi
    7. 

    8. 

  8. if [ -L $1 ];then
    9. 

  9.   echo "Symbolic link."
    10. 

  10. elif [ -b $1 ];then
    11. 

  11.   echo "block special."
    12. 

  12. elif [ -c $1 ];then
    13. 

  13.   echo "Character special file."
    14. 

  14. elif [ -S $1 ];then
    15. 

  15.   echo "Socket file."
    16. 

  16. elif [ -f $1 ];then
    17. 

  17.    echo "common file."
    18. 

  18. elif [ -d $1 ];then
    19. 

  19.    echo "Directory."lse
    20. 

  20.   echo "UNKNOW."
    21. 

  21. fi
    22.
例2：写一个脚本
(1) 传递一个参数给脚本，此参数为用户名；
(2) 根据其ID号来判断用户类型（centos7系统）：
      0： 管理员
      1-999：系统用户
      1000+：登录用户
    

  1. #!/bin/bash
    2. 

    3. 

  3. [ $# -lt 1 ] && echo "At least one username."&& exit 1  #先判断参量是否存在
    4. 

  4. ! id $1 &>/dev/null && echo "Bo such user."&& exit 2    #判断用户是否存在
    5. 

  5. uid=$(id -u $1)
    6. 

    7. 

  7. if [ $uid -eq 0 ];then
    8. 

  8.    echo "the user is root."
    9. 

  9. elif [ $uid -le 1000 ];then
    10. 

  10.    echo "the user is system user."
    11. 

  11. else
    12. 

  12.    echo "the user is login user."
    13. 

  13. fi
    14.

2.bash编程之循环执行

循环执行：将一段代码重复执行0、1或多次
进入条件：条件满足时才进入循环
退出条件：每个循环都应该有退出条件，以有条件退出循环
bash脚本：for，while，until

2.1 for循环

两种格式：1.遍历列表；2.控制变量
1.遍历列表：
    

  1. for VARIABLE in LIST;do
    2. 

  2.     循环体
    3. 

  3. done
    4.
进入条件：只要列表有元素，即可进入循环
退出条件：列表中的元素表里完成
列表的生成方式：
1.直接给出
2.整数给出
（a）：｛start..end｝
（b）：seq [start [incremtal]] last

3.返回列表的命令

4.glob
5.变量引用：$@,$*

2.2 while循环

    

  1. while CONDITION;do
    2. 

  2.      循环体
    3. 

  3.      循环控制变量修正表达式
    4. 

  4. done
    5.
进入条件：condition测试条件为”真“
退出条件：condition测试条件为”假“

2.3 until循环

    

  1. until CONDITION;do
    2. 

  2.     循环体
    3. 

  3.     循环控制变量修正表达式
    4. 

  4. done
    5.
进入条件：condition测试条件为”假“
退出条件：condition测试条件为”真“
例1：求100以内所有正整数之和，用三种方法（for，while，until）
    

  1. #!/bin/bash
    2. 

  2. declare -i sum=0
    3. 

  3. declare -i i=1
    4. 

    5. 

  5. #until [ $i -gt 100 ];do
    6. 

  6. #判断i的值是否大于100，为假时循环
    7. 

  7. while [ $i -le 100 ];do
    8. 

  8. #判断i的值是否小于等于100，为真时循环
    9. 

  9.      let sum+=$i
    10. 

  10.      let i++
    11. 

  11. done
    12. 

  12. echo $sum
    13.
for循环
    

  1. #!/bin/bash
    2. 

  2. declare -i sum=0
    3. 

    4. 

  4. #for i in {1..100};do
    5. 

  5. for i in `seq 1 100`;do
    6. 

  6.     let sum=$sum+$i
    7. 

  7. done
    8. 

  8. echo "sum=$sum"
    9.
例2：创建10个用户，user101-user110；密码同用户名；
    

  1. #!/bin/bash
    2. 

  2. for i in {101..103};do
    3. 

  3.     name="user${i}"
    4. 

  4.     ! id $name &> /dev/null && useradd $name && echo "add user ${name} succeed!"
    5. 

  5.     echo "$i" | passwd --stdin "$name" &> /dev/null && echo "set passwd '${name}' for $name succeed!"
    6. 

  6. done
    7.
例3：打印九九乘法表
提示：外循环控制乘数，内循环控制被乘数
    

  1. #!/bin/bash
    2. 

  2. for j in {1..9};do
    3. 

  3.     for i in `seq 1 $j`;do
    4. 

  4.         echo -n -e "${i}x${j}=$[${i}*${j}]\t"
    5. 

  5.     done
    6. 

  6.     echo
    7. 

  7. done
    8.
例4：打印逆序九九乘法表
    

  1. #!/bin/bash
    2. 

  2. for s in {1..9};do
    3. 

  3.     j=$[10-$s]
    4. 

  4.     for i in $(seq 1 $j);do
    5. 

  5.         echo -n -e "${i}X${j}=$[${i}*${j}]\t"
    6. 

  6.     done
    7. 

  7.     echo
    8. 

  8. done
    9.
until
    

  1. #!/bin/bash
    2. 

  2. declare -i s=9
    3. 

  3. until [ $s -eq 0 ];do
    4. 

  4. declare -i j=1         
    5. 

  5. #注意：每次循环，i的值都会发生变化，一定要重新定义
    6. 

  6. until [ $j -gt $s ];do
    7. 

  7.      echo -n -e "${s}X${j}=$[${s}*${j}]\t"
    8. 

  8.      let j++
    9. 

  9.      done
    10. 

  10. let s--
    11. 

  11.      echo
    12. 

  12. done
    13.
while
    

  1. #!/bin/bash
    2. 

  2. declare -i s=9
    3. 

  3. while [ $s -gt 0 ];do
    4. 

  4.    declare -i j=1
    5. 

  5.    while [ $j -le $s ];do
    6. 

  6.        echo -n -e "${s}X${j}=$[${s}*${j}]\t"
    7. 

  7.        let j++
    8. 

  8.    done
    9. 

  9.    let s--
    10. 

  10.    echo
    11. 

  11. done
    12.

相关文章