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

                                                                                                                      8.4 运算符优先级

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

                                                                                                                      # 8.4 运算符优先级

                                                                                                                      在脚本中,运算执行的顺序被称为优先级: 高优先级的操作会比低优先级的操作先执行。[1]

                                                                                                                      表 8-1. 运算符优先级(从高到低)

                                                                                                                      运算符含义注解
                                                                                                                      var++ var--后缀自增/自减C风格运算符
                                                                                                                      ++var --var前缀自增/自减
                                                                                                                      ! ~按位取反/逻辑取反对每一比特位取反/对逻辑判断的结果取反
                                                                                                                      **幂运算算数运算符
                                                                                                                      * / %乘, 除, 取余算数运算符
                                                                                                                      + -加, 减算数运算符
                                                                                                                      << >>左移, 右移比特位运算符
                                                                                                                      -z -n一元比较字符串是/否为空
                                                                                                                      -e -f -t -x, etc一元比较文件测试
                                                                                                                      -lt -gt -le -ge <= >=复合比较字符串/整数比较
                                                                                                                      -nt -ot -ef复合比较文件测试
                                                                                                                      &AND(按位与)按位与操作
                                                                                                                      ^XOR(按位异或)按位异或操作
                                                                                                                      |OR(按位或)按位或操作
                                                                                                                      && -aAND(逻辑与)逻辑与, 复合比较
                                                                                                                      || -oOR(逻辑或)逻辑或, 复合比较
                                                                                                                      ? :if/else三目运算符C风格运算符
                                                                                                                      =赋值不要与test中的等号混淆
                                                                                                                      *= /= %= += -= <<= >>= &=赋值运算先运算后赋值
                                                                                                                      ,逗号运算符连接一系列语句

                                                                                                                      实际上,你只需要记住以下规则就可以了:

                                                                                                                      • 先乘除取余,后加减,与算数运算相似
                                                                                                                      • 复合逻辑运算符,&&, ||, -a, -o 优先级较低
                                                                                                                      • 优先级相同的操作按从左至右顺序求值

                                                                                                                      现在,让我们利用运算符优先级的知识来分析一下Fedora Core Linux中的/etc/init.d/functions文件。

                                                                                                                      while [ -n "$remaining" -a "$retry" -gt 0 ]; do
                                                                                                                      
                                                                                                                      # 初看之下很恐怖...
                                                                                                                      
                                                                                                                      
                                                                                                                      # 分开来分析
                                                                                                                      while [ -n "$remaining" -a "$retry" -gt 0 ]; do
                                                                                                                      #       --condition 1-- ^^ --condition 2-
                                                                                                                      
                                                                                                                      #  如果变量"$remaining" 长度不为0
                                                                                                                      #+      并且AND (-a)
                                                                                                                      #+ 变量 "$retry" 大于0
                                                                                                                      #+ 那么
                                                                                                                      #+ [ 方括号表达式 ] 返回成功(0)
                                                                                                                      #+ while-loop 开始迭代执行语句。
                                                                                                                      #  ==============================================================
                                                                                                                      #  "condition 1" 和 "condition 2" 在 AND之前执行,为什么?
                                                                                                                      #  因为AND(-a)优先级比-n,-gt来得低,逻辑与会在最后求值。
                                                                                                                      #################################################################
                                                                                                                      
                                                                                                                      if [ -f /etc/sysconfig/i18n -a -z "${NOLOCALE:-}" ] ; then
                                                                                                                      
                                                                                                                      
                                                                                                                      # 同样,分开来分析
                                                                                                                      if [ -f /etc/sysconfig/i18n -a -z "${NOLOCALE:-}" ] ; then
                                                                                                                      #    --condition 1--------- ^^ --condition 2-----
                                                                                                                      
                                                                                                                      #  如果文件"/etc/sysconfig/i18n" 存在
                                                                                                                      #+      并且AND (-a)
                                                                                                                      #+ 变量 $NOLOCALE 长度不为0
                                                                                                                      #+ 那么
                                                                                                                      #+ [ 方括号表达式 ] 返回成功(0)
                                                                                                                      #+ 执行接下来的语句。
                                                                                                                      #
                                                                                                                      #  和之前的情况一样,逻辑与AND(-a)最后求值。
                                                                                                                      #  因为在方括号测试结构中,逻辑运算的优先级是最低的。
                                                                                                                      #  ==============================================================
                                                                                                                      #  注意:
                                                                                                                      #  ${NOLOCALE:-} 是一个参数扩展式,看起来有点多余。
                                                                                                                      #  但是, 如果 $NOLOCALE 没有提前声明, 它会被设成null,
                                                                                                                      #  在某些情况下,这会有点问题。
                                                                                                                      
                                                                                                                      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

                                                                                                                      tip为了避免在复杂比较运算中的错误,可以把运算分散到几个括号结构中。

                                                                                                                      if [ "$v1" -gt "$v2"  -o  "$v1" -lt "$v2"  -a  -e "$filename" ]
                                                                                                                      # 这样写不清晰...
                                                                                                                      
                                                                                                                      if [[ "$v1" -gt "$v2" ]] || [[ "$v1" -lt "$v2" ]] && [[ -e "$filename" ]]
                                                                                                                      # 好多了 -- 把逻辑判断分散到多个组之中
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5

                                                                                                                      1. Precedence(优先级),根据上下文,与priority含义相近。 ↩︎

                                                                                                                      edit icon编辑此页open in new window
                                                                                                                      上次编辑于: 2022/4/27 15:33:00
                                                                                                                      贡献者: clay-wangzhi
                                                                                                                      上一页
                                                                                                                      8.3 双圆括号结构
                                                                                                                      备案号:冀ICP备2021007336号
                                                                                                                      Copyright © 2023 LinuxStory