Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 第一部分 初见shell

      • 第一章 为什么使用shell编程
        • 第二章 和Sha-Bang(#!)一起出发

          • 2.1 调用一个脚本
            • 2.2 牛刀小试
          • 第二部分 shell基础

            • 第三章 特殊字符
              • 第四章 变量与参数

                • 4.1 变量替换
                  • 4.2 变量赋值
                    • 4.3 Bash变量是弱类型的
                      • /code/shell/part2/04_4_special_variable_types
                      • 第五章 引用

                        • 5.1 引用变量
                          • 5.2 转义
                          • 第六章 退出与退出状态
                            • 第七章 测试

                              • 7.1 测试结构
                                • 7.2 文件测试操作
                                  • 7.3 其他比较操作
                                    • 7.4 嵌套 if/then 条件测试
                                      • 7.5 牛刀小试
                                      • 第八章 运算符相关话题

                                        • 8.1 运算符
                                          • 8.2 数字常量
                                            • 8.3 双圆括号结构
                                              • 8.4 运算符优先级
                                            • 第三部分 shell进阶

                                              • 第九章 换个角度看变量

                                                • 9.1 内部变量
                                                  • 9.2 变量类型标注:declare 与 typeset
                                                    • 9.2.1 declare 的另类用法
                                                      • 9.3 $RANDOM:生成随机数
                                                      • 第十章 变量处理

                                                        • 10.1 字符串处理
                                                          • 10.1.1 使用 awk 处理字符串
                                                            • 10.1.2 参考资料
                                                              • 10.2 参数替换
                                                              • 第十一章 循环与分支

                                                                • 11.1 循环
                                                                  • 11.2 嵌套循环
                                                                    • 11.3 循环控制
                                                                      • break, continue
                                                                      • 11.4 测试与分支
                                                                      • 第十二章 命令替换
                                                                        • 第十三章 算术扩展
                                                                        • 第四部分 命令
                                                                          • 第五部分 高级话题

                                                                            • 18 正则表达式

                                                                              • 18.1 正则表达式简介
                                                                                • 18.2文件名替换
                                                                                  • 18.3 正则表达式对照表
                                                                                  • 19 嵌入文档
                                                                                    • 20 I/O 重定向

                                                                                      • 20.1 使用 exec
                                                                                        • 20.2 重定向代码块
                                                                                          • 20.3 应用程序
                                                                                          • 第二十一章 子shell
                                                                                            • 第二十二章. 限制模式的Shell
                                                                                              • 第二十三章. 进程替换
                                                                                                • 24 函数

                                                                                                  • 24.1 复杂函数和函数复杂性
                                                                                                    • 24.2 局部变量
                                                                                                      • 24.3 不使用局部变量的递归
                                                                                                      • 25. 别名
                                                                                                        • 26. 列表结构
                                                                                                          • 27 数组
                                                                                                            • 30 网络编程
                                                                                                              • 33 选项
                                                                                                                • 第34章 陷阱
                                                                                                                  • 第36章 杂项
                                                                                                                    • echo命令
                                                                                                                    • 第六部分 Google Shell 风格指南
                                                                                                                    • 前端学习笔记

                                                                                                                      11.3 循环控制

                                                                                                                      author iconLinuxStorycalendar icon2021年5月11日category icon
                                                                                                                      • Linux
                                                                                                                      tag icon
                                                                                                                      • Bash
                                                                                                                      timer icon大约 4 分钟

                                                                                                                      此页内容
                                                                                                                      • break, continue

                                                                                                                      # 11.3 循环控制

                                                                                                                      Tournez cent tours, tournez mille tours,

                                                                                                                      Tournez souvent et tournez toujours . . .

                                                                                                                      ——保尔·魏尔伦,《木马》

                                                                                                                      本节介绍两个会影响循环行为的命令。

                                                                                                                      # break, continue

                                                                                                                      break 和 continue 命令[1]的作用和在其他编程语言中的作用一样。break 用来中止(跳出)循环,而 continue 则是略过未执行的循环部分,直接进行下一次循环。

                                                                                                                      样例 11-21. 循环中 break 与 continue 的作用

                                                                                                                      #!/bin/bash
                                                                                                                      
                                                                                                                      LIMIT=19  # 循环上界
                                                                                                                      
                                                                                                                      echo
                                                                                                                      echo "Printing Numbers 1 through 20 (but not 3 and 11)."
                                                                                                                      
                                                                                                                      a=0
                                                                                                                      
                                                                                                                      while [ $a -le "$LIMIT" ]
                                                                                                                      do
                                                                                                                       a=$(($a+1))
                                                                                                                       
                                                                                                                       if [ "$a" -eq 3 ] || [ "$a" -eq 11 ]  # 除了 3 和 11。
                                                                                                                       then
                                                                                                                         continue      # 略过本次循环的剩余部分。
                                                                                                                       fi
                                                                                                                       
                                                                                                                       echo -n "$a "   # 当 a 等于 3 和 11 时,将不会执行这条语句。
                                                                                                                      done
                                                                                                                      
                                                                                                                      # 思考:
                                                                                                                      # 为什么循环不会输出到20?
                                                                                                                      
                                                                                                                      echo; echo
                                                                                                                      
                                                                                                                      echo Printing Numbers 1 through 20, but something happens after 2.
                                                                                                                      
                                                                                                                      ##################################################################
                                                                                                                      
                                                                                                                      # 用 'break' 代替了 'continue'。
                                                                                                                      
                                                                                                                      a=0
                                                                                                                      
                                                                                                                      while [ "$a" -le "$LIMIT" ]
                                                                                                                      do
                                                                                                                       a=$(($a+1))
                                                                                                                       
                                                                                                                       if [ "$a" -gt 2 ]
                                                                                                                       then
                                                                                                                         break  # 中止循环。
                                                                                                                       fi
                                                                                                                       
                                                                                                                       echo -n "$a"
                                                                                                                      done
                                                                                                                      
                                                                                                                      echo; echo; echo
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21
                                                                                                                      22
                                                                                                                      23
                                                                                                                      24
                                                                                                                      25
                                                                                                                      26
                                                                                                                      27
                                                                                                                      28
                                                                                                                      29
                                                                                                                      30
                                                                                                                      31
                                                                                                                      32
                                                                                                                      33
                                                                                                                      34
                                                                                                                      35
                                                                                                                      36
                                                                                                                      37
                                                                                                                      38
                                                                                                                      39
                                                                                                                      40
                                                                                                                      41
                                                                                                                      42
                                                                                                                      43
                                                                                                                      44
                                                                                                                      45
                                                                                                                      46
                                                                                                                      47
                                                                                                                      48
                                                                                                                      49

                                                                                                                      break 命令接受一个参数。普通的 break 命令仅仅跳出其所在的那层循环,而 break N 命令则可以跳出其上 N 层的循环。

                                                                                                                      样例 11-22. 跳出多层循环

                                                                                                                      #!/bin/bash
                                                                                                                      # break-levels.sh: 跳出循环.
                                                                                                                      
                                                                                                                      # "break N" 跳出 N 层循环。
                                                                                                                      
                                                                                                                      for outerloop in 1 2 3 4 5
                                                                                                                      do
                                                                                                                        echo -n "Group $outerloop:   "
                                                                                                                      
                                                                                                                        # ------------------------------------------
                                                                                                                        for innerloop in 1 2 3 4 5
                                                                                                                        do
                                                                                                                          echo -n "$innerloop "
                                                                                                                          
                                                                                                                          if [ "$innerloop" -eq 3 ]
                                                                                                                          then
                                                                                                                            break  # 尝试一下 break 2 看看会发生什么。
                                                                                                                                   # (它同时中止了内层和外层循环。)
                                                                                                                          fi
                                                                                                                        done
                                                                                                                        # ------------------------------------------
                                                                                                                      
                                                                                                                        echo
                                                                                                                      done
                                                                                                                      
                                                                                                                      echo
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21
                                                                                                                      22
                                                                                                                      23
                                                                                                                      24
                                                                                                                      25
                                                                                                                      26
                                                                                                                      27
                                                                                                                      28

                                                                                                                      与 break 类似,continue 也接受一个参数。普通的 continue 命令仅仅影响其所在的那层循环,而 continue N 命令则可以影响其上 N 层的循环。

                                                                                                                      样例 11-23. continue 影响外层循环

                                                                                                                      #!/bin/bash
                                                                                                                      # "continue N" 命令可以影响其上 N 层循环。
                                                                                                                      
                                                                                                                      for outer in I II III IV V           # 外层循环
                                                                                                                      do
                                                                                                                        echo; echo -n "Group $outer: "
                                                                                                                        
                                                                                                                        # --------------------------------------------------------------------
                                                                                                                        for inner in 1 2 3 4 5 6 7 8 9 10  # 内层循环
                                                                                                                        do
                                                                                                                        
                                                                                                                          if [[ "$inner" -eq 7 && "$outer" = "III" ]]
                                                                                                                          then
                                                                                                                            continue 2  # 影响两层循环,包括“外层循环”。
                                                                                                                                        # 将其替换为普通的 "continue",那么只会影响内层循环。
                                                                                                                          fi
                                                                                                                          
                                                                                                                          echo -n "$inner "  # 7 8 9 10 将不会出现在 "Group III."中。
                                                                                                                        done
                                                                                                                        # --------------------------------------------------------------------
                                                                                                                      
                                                                                                                      done
                                                                                                                      
                                                                                                                      echo; echo
                                                                                                                      
                                                                                                                      # 思考:
                                                                                                                      # 想一个 "continue N" 在脚本中的实际应用情况。
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21
                                                                                                                      22
                                                                                                                      23
                                                                                                                      24
                                                                                                                      25
                                                                                                                      26
                                                                                                                      27
                                                                                                                      28
                                                                                                                      29

                                                                                                                      样例 11-24. 真实环境中的 continue N

                                                                                                                      # Albert Reiner 举出了一个如何使用 "continue N" 的例子:
                                                                                                                      # ---------------------------------------------------
                                                                                                                      
                                                                                                                      #  如果我有许多任务需要运行,并且运行所需要的数据都以文件的形
                                                                                                                      #+ 式存在文件夹中。现在有多台设备可以访问这个文件夹,我想将任
                                                                                                                      #+ 务分配给这些不同的设备来完成。
                                                                                                                      #  那么我通常会在每台设备上执行下面的代码:
                                                                                                                      
                                                                                                                      while true:
                                                                                                                      do
                                                                                                                        for n in .iso.*
                                                                                                                        do
                                                                                                                          [ "$n" = ".iso.opts" ] && continue
                                                                                                                          beta=${n#.iso.}
                                                                                                                          [ -r .Iso.$beta ] && continue
                                                                                                                          [ -r .lock.$beta ] && sleep 10 && continue
                                                                                                                          lockfile -r0 .lock.$beta || continue
                                                                                                                          echo -n "$beta: " `date`
                                                                                                                          run-isotherm $beta
                                                                                                                          date
                                                                                                                          ls -alF .Iso.$beta
                                                                                                                          [ -r .Iso.$beta ] && rm -rf .lock.$beta
                                                                                                                          continue 2
                                                                                                                        done
                                                                                                                        break
                                                                                                                      done
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      # 这个脚本中出现的 sleep N 只针对这个脚本,通常的形式是:
                                                                                                                      
                                                                                                                      while true
                                                                                                                      do
                                                                                                                        for job in {pattern}
                                                                                                                        do
                                                                                                                          {job already done or running} && continue
                                                                                                                          {mark job as running, do job, mark job as done}
                                                                                                                          continue 2
                                                                                                                        done
                                                                                                                        break        # 或者使用类似 `sleep 600` 这样的语句来防止脚本结束。
                                                                                                                      done
                                                                                                                      
                                                                                                                      #  这样做可以保证脚本只会在没有任务时(包括在运行过程中添加的任务)
                                                                                                                      #+ 才会停止。合理使用文件锁保证多台设备可以无重复的并行执行任务(这
                                                                                                                      #+ 在我的设备上通常会消耗好几个小时,所以我想避免重复计算)。并且,
                                                                                                                      #+ 因为每次总是从头开始搜索文件,因此可以通过文件名决定执行的先后
                                                                                                                      #+ 顺序。当然,你可以不使用 'continue 2' 来完成这些,但是你必须
                                                                                                                      #+ 添加代码去检测某项任务是否完成(以此判断是否可以执行下一项任务或
                                                                                                                      #+ 终止、休眠一段时间再执行下一项任务)。
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21
                                                                                                                      22
                                                                                                                      23
                                                                                                                      24
                                                                                                                      25
                                                                                                                      26
                                                                                                                      27
                                                                                                                      28
                                                                                                                      29
                                                                                                                      30
                                                                                                                      31
                                                                                                                      32
                                                                                                                      33
                                                                                                                      34
                                                                                                                      35
                                                                                                                      36
                                                                                                                      37
                                                                                                                      38
                                                                                                                      39
                                                                                                                      40
                                                                                                                      41
                                                                                                                      42
                                                                                                                      43
                                                                                                                      44
                                                                                                                      45
                                                                                                                      46
                                                                                                                      47
                                                                                                                      48
                                                                                                                      49

                                                                                                                      caution continue N 结构不易理解并且可能在一些情况下有歧义,因此不建议使用。


                                                                                                                      1. 这两个命令是 内建命令open in new window,而另外的循环命令,如 whileopen in new window 和 caseopen in new window 则是 关键词open in new window。 ↩︎

                                                                                                                      edit icon编辑此页open in new window
                                                                                                                      上次编辑于: 2022/4/27 15:33:00
                                                                                                                      贡献者: clay-wangzhi
                                                                                                                      上一页
                                                                                                                      11.2 嵌套循环
                                                                                                                      下一页
                                                                                                                      11.4 测试与分支
                                                                                                                      备案号:冀ICP备2021007336号
                                                                                                                      Copyright © 2023 LinuxStory