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 循环控制
                                                                      • 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 风格指南
                                                                                                                    • 前端学习笔记

                                                                                                                      26. 列表结构

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

                                                                                                                      此页内容
                                                                                                                      • 链接多个命令

                                                                                                                      # 26. 列表结构

                                                                                                                      and 列表 和 or 列表 结构提供了连续执行若干命令的方法,可以有效地替换复杂的嵌套 if/thenopen in new window ,甚至 caseopen in new window 语句。

                                                                                                                      # 链接多个命令

                                                                                                                      and 列表

                                                                                                                      command-1 && command-2 && command-3 && ... command-n

                                                                                                                      只要前一个命令返回 true(即 0),每一个命令就依次执行。当第一个 false(即 非0)返回时,命令链条即终止(第一个返回 false 的命令是最后一个执行的)。

                                                                                                                      在YongYeopen in new window早期版本的俄罗斯方块游戏open in new window脚本里,一个有趣的双条件 and 列表 用法:

                                                                                                                      equation()
                                                                                                                      
                                                                                                                      {  # core algorithm used for doubling and halving the coordinates
                                                                                                                         [[ ${cdx} ]] && ((y=cy+(ccy-cdy)${2}2))
                                                                                                                         eval ${1}+=\"${x} ${y} \"
                                                                                                                      }
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6

                                                                                                                      例 26-1. 使用 and 列表 来测试命令行参数

                                                                                                                      #!/bin/bash
                                                                                                                      # and list
                                                                                                                      
                                                                                                                      if [ ! -z "$1" ] && echo "Argument #1 = $1" && [ ! -z "$2" ] && \
                                                                                                                      #                ^^                         ^^               ^^
                                                                                                                      echo "Argument #2 = $2"
                                                                                                                      then
                                                                                                                        echo "At least 2 arguments passed to script."
                                                                                                                        # 链条内的所有命令都返回 true。
                                                                                                                      else
                                                                                                                        echo "Fewer than 2 arguments passed to script."
                                                                                                                        # 链条内至少有一个命令返回 false。
                                                                                                                      fi  
                                                                                                                      # 注意: "if [ ! -z $1 ]" 是好用的,但是宣传与之等同的
                                                                                                                      #   "if [ -n $1 ]" 并不好用。
                                                                                                                      #  不过,用引号就能解决问题,
                                                                                                                      #   "if [ -n "$1" ]" 好用(译者注:原文本行内第一个引号位置错了)。
                                                                                                                      #           ^  ^    小心!
                                                                                                                      # 被测试的变量放在引号内总是最好的选择。
                                                                                                                      
                                                                                                                      
                                                                                                                      # 下面的代码功能一样,用的是“纯粹”的 if/then 语句。
                                                                                                                      if [ ! -z "$1" ]
                                                                                                                      then
                                                                                                                        echo "Argument #1 = $1"
                                                                                                                      fi
                                                                                                                      if [ ! -z "$2" ]
                                                                                                                      then
                                                                                                                        echo "Argument #2 = $2"
                                                                                                                        echo "At least 2 arguments passed to script."
                                                                                                                      else
                                                                                                                        echo "Fewer than 2 arguments passed to script."
                                                                                                                      fi
                                                                                                                      # 比起用“and 列表”要更长、更笨重。
                                                                                                                      
                                                                                                                      
                                                                                                                      exit $?
                                                                                                                      
                                                                                                                      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

                                                                                                                      例 26-2. 使用 and 列表 来测试命令行参数2

                                                                                                                      #!/bin/bash
                                                                                                                      
                                                                                                                      ARGS=1        # 预期的参数数量。
                                                                                                                      E_BADARGS=85  # 参数数量错误时返回的值。
                                                                                                                      
                                                                                                                      test $# -ne $ARGS && \
                                                                                                                      #    ^^^^^^^^^^^^ 条件 #1
                                                                                                                      echo "Usage: `basename $0` $ARGS argument(s)" && exit $E_BADARGS
                                                                                                                      #                                             ^^
                                                                                                                      #  如果条件 #1 结果为 true (传递给脚本的参数数量错误),
                                                                                                                      #+ 那么执行本行剩余的命令,脚本终止。
                                                                                                                      
                                                                                                                      # 下面的代码行只有在上面的测试失败时才执行。
                                                                                                                      echo "Correct number of arguments passed to this script."
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      #  如果要检查退出值,脚本终止后运行 "echo $?"。
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18

                                                                                                                      当然,and 列表 也可以给变量设置默认值。

                                                                                                                      arg1=$@ && [ -z "$arg1" ] && arg1=DEFAULT
                                                                                                                      
                                                                                                                                    # 如果有命令行参数,则把参数值赋给 $arg1 。
                                                                                                                                    # 但是... 如果没有参数,则使用DEFAULT给 $arg1 赋值。
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4

                                                                                                                      or 列表

                                                                                                                      command-1 || command-2 || command-3 || ... command-n
                                                                                                                      
                                                                                                                      1

                                                                                                                      只要前一个命令返回_false_,每一个命令就依次执行。当第一个_true_ 返回时,命令链条即终止(第一个返回_true_ 的命令是最后一个执行的)。很明显它与“and 列表”相反。

                                                                                                                      例 26-3. or 列表 与 and 列表 结合使用

                                                                                                                      #!/bin/bash
                                                                                                                      
                                                                                                                      #  delete.sh, 不那么巧妙的文件删除工具。
                                                                                                                      #  用法: delete 文件名
                                                                                                                      
                                                                                                                      E_BADARGS=85
                                                                                                                      
                                                                                                                      if [ -z "$1" ]
                                                                                                                      then
                                                                                                                        echo "Usage: `basename $0` filename"
                                                                                                                        exit $E_BADARGS  # No arg? Bail out.
                                                                                                                      else  
                                                                                                                        file=$1          # Set filename.
                                                                                                                      fi  
                                                                                                                      
                                                                                                                      
                                                                                                                      [ ! -f "$file" ] && echo "File \"$file\" not found. \
                                                                                                                      Cowardly refusing to delete a nonexistent file."
                                                                                                                      # AND 列表,如果文件不存在则显示出错信息。
                                                                                                                      # 注意,echo 消息内容分成了两行,中间通过转义符(\)连接。
                                                                                                                      
                                                                                                                      [ ! -f "$file" ] || (rm -f $file; echo "File \"$file\" deleted.")
                                                                                                                      # OR 列表,删除存在的文件。
                                                                                                                      
                                                                                                                      # 注意上面的逻辑颠倒。 Note logic inversion above.
                                                                                                                      # “AND 列表” 在得到 true 时执行, “OR 列表”在得到 false 时执行。
                                                                                                                      
                                                                                                                      exit $?
                                                                                                                      
                                                                                                                      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

                                                                                                                      如果 or 列表 第一个命令返回 true,它会执行。

                                                                                                                      # ==> 下面的代码段来自 /etc/rc.d/init.d/single
                                                                                                                      #+==> 作者 Miquel van Smoorenburg
                                                                                                                      #+==> 说明了 "and" 和 "or" 列表。
                                                                                                                      # ==> 带箭头的注释是本文作者添加的。
                                                                                                                      
                                                                                                                      [ -x /usr/bin/clear ] && /usr/bin/clear
                                                                                                                        # ==> 如果 /usr/bin/clear 存在, 则调用它。
                                                                                                                        # ==> 调用命令之前检查它是否存在,
                                                                                                                        #+==> 可以避免出错消息和其他怪异的结果。
                                                                                                                      
                                                                                                                        # ==> . . .
                                                                                                                      
                                                                                                                      #  If they want to run something in single user mode, might as well run it...
                                                                                                                      for i in /etc/rc1.d/S[0-9][0-9]* ; do
                                                                                                                              # 检查脚本是否存在。
                                                                                                                              [ -x "$i" ] || continue
                                                                                                                        # ==> 如果对应的文件在 $PWD 里*没有*找到,
                                                                                                                        #+==> 则跳回到循环顶端“继续运行”。
                                                                                                                      
                                                                                                                              # 丢弃备份文件和 rpm 生成的文件。
                                                                                                                              case "$1" in
                                                                                                                                      *.rpmsave|*.rpmorig|*.rpmnew|*~|*.orig)
                                                                                                                                              continue;;
                                                                                                                              esac
                                                                                                                              [ "$i" = "/etc/rc1.d/S00single" ] && continue
                                                                                                                        # ==> 设置脚本名,但先不要执行
                                                                                                                              $i start
                                                                                                                      done
                                                                                                                      
                                                                                                                        # ==> . . .
                                                                                                                      
                                                                                                                      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
                                                                                                                      _and 列表_ 或 _or 列表_ 的[退出状态](http://tldp.org/LDP/abs/html/exit-status.html#EXITSTATUSREF)就是最后一个执行的命令的退出状态。

                                                                                                                      聪明地结合 and 列表 和 or 列表 是可能的,但是程序逻辑会很容易地变得令人费解,需要密切注意操作符优先规则open in new window,而且,会带来大量的调试工作。

                                                                                                                      false && true || echo false         # false
                                                                                                                      
                                                                                                                      # 下面的代码结果相同
                                                                                                                      ( false && true ) || echo false     # false
                                                                                                                      # 但这个就不同了
                                                                                                                      false && ( true || echo false )     # (什么都不显示)
                                                                                                                      
                                                                                                                      #  注意语句是从左到右组合和解释的。
                                                                                                                      
                                                                                                                      #  通常情况下最好避免这种复杂性。
                                                                                                                      
                                                                                                                      #  感谢, S.C.
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12

                                                                                                                      例 A-7open in new window 和 例 7-4open in new window 解释了用 and 列表 / or 列表 来测试变量。

                                                                                                                      edit icon编辑此页open in new window
                                                                                                                      上次编辑于: 2022/4/27 15:33:00
                                                                                                                      贡献者: clay-wangzhi
                                                                                                                      上一页
                                                                                                                      25. 别名
                                                                                                                      下一页
                                                                                                                      27 数组
                                                                                                                      备案号:冀ICP备2021007336号
                                                                                                                      Copyright © 2023 LinuxStory