Bash脚本进阶指南
Repo
  • 正文
    • 第一部分 初见shell
      • 1. 为什么使用shell编程
      • 2. 和Sha-Bang(#!)一起出发
        • 2.1 调用一个脚本
        • 2.2 牛刀小试
    • 第二部分 shell基础
      • 3. 特殊字符
      • 4. 变量与参数
        • 4.1 变量替换
        • 4.2 变量赋值
        • 4.3 Bash弱类型变量
        • 4.4 特殊变量类型
      • 5. 引用
        • 5.1 引用变量
        • 5.2 转义
      • 6. 退出与退出状态
      • 7. 测试
        • 7.1 测试结构
        • 7.2 文件测试操作
        • 7.3 其他比较操作
        • 7.4 嵌套 if/then 条件测试
        • 7.5 牛刀小试
      • 8. 运算符相关话题
        • 8.1 运算符
        • 8.2 数字常量
        • 8.3 双圆括号结构
        • 8.4 运算符优先级
    • 第三部分 shell进阶
      • 9. 换个角度看变量
        • 9.1 内部变量
        • 9.2 变量类型标注:declare 与 typeset
          • 9.2.1 declare 的另类用法
        • 9.3 $RANDOM:生成随机数
      • 10. 变量处理
        • 10.1 字符串处理
          • 10.1.1 使用 awk 处理字符串
          • 10.1.2 参考资料
        • 10.2 参数替换
      • 11. 循环与分支
        • 11.1 循环
        • 11.2 嵌套循环
        • 11.3 循环控制
        • 11.4 测试与分支
      • 12. 命令替换
      • 13. 算术扩展
      • 14. 休息时间
    • 第四部分 命令
      • 15. 内建命令
        • 15.1 任务控制命令
      • 16. 外部筛选器,任务及命令
        • 16.1 基础命令
        • 16.2 复杂命令
        • 16.3 时间/日期命令
        • 16.4 文本处理命令
        • 16.5 文件与归档命令
        • 16.6 通信命令
        • 16.7 终端控制命令
        • 16.8 数学命令
        • 16.9 杂项命令
      • 17. 系统与管理命令
        • 17.1 分析一个系统脚本
    • 第五部分 高级话题
      • 18.正则表达式
        • 18.1正则表达式简介
        • 18.2文件名替换
      • 19. 嵌入文档
      • 20. I/O 重定向
        • 20.1 使用 exec
        • 20.2 重定向代码块
        • 20.3 应用程序
      • 21. 子shell
      • 22. 限制模式的Shell
      • 23. 进程替换
      • 24. 函数
        • 24.1 复杂函数和函数复杂性
        • 24.2 局部变量
        • 24.3 不适用局部变量的递归
      • 25. 别名
      • 26. 列表结构
      • 27. 数组
      • 28. 间接引用
      • 29. /dev 和 /proc
        • 29.1 /dev
        • 29.2 /proc
      • 30. 网络编程
      • 32. 调试
      • 33. 选项
      • 34. 陷阱
      • 36. 杂项
        • 36.1 交互和非交互shell以及脚本
        • 36.2 shell wrappers
        • 36.3 测试和比较的其他方法
        • 36.4 递归:调用自己的脚本
        • 36.5 “彩色”的脚本
        • 36.6 优化
        • 36.7 其他技巧
        • 36.8 安全问题
        • 36.9 可移植性问题
        • 36.10 Windows系统下的脚本
    • 38. 后记
      • 38.1 作者后记
      • 38.2 关于作者
      • 38.3 从哪里可以获得帮助
      • 38.4 用来制作这本书的工具
      • 38.5 致谢
      • 38.6 免责声明
  • 附录及索引
    • 参考文献
    • 附录
    • 索引
由 GitBook 提供支持
在本页

这有帮助吗?

  1. 正文
  2. 第二部分 shell基础
  3. 8. 运算符相关话题

8.4 运算符优先级

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

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

运算符
含义
注解

var++ var--

后缀自增/自减

C风格运算符

++var --var

前缀自增/自减

! ~

按位取反/逻辑取反

对每一比特位取反/对逻辑判断的结果取反

**

幂运算

算数运算符

* / %

乘, 除, 取余

算数运算符

+ -

加, 减

算数运算符

<< >>

左移, 右移

比特位运算符

-z -n

一元比较

字符串是/否为空

-e -f -t -x, etc

一元比较

文件测试

-lt -gt -le -ge <= >=

复合比较

字符串/整数比较

-nt -ot -ef

复合比较

文件测试

&

AND(按位与)

按位与操作

^

XOR(按位异或)

按位异或操作

|

OR(按位或)

按位或操作

&& -a

AND(逻辑与)

逻辑与, 复合比较

|| -o

OR(逻辑或)

逻辑或, 复合比较

? :

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,
#  在某些情况下,这会有点问题。
if [ "$v1" -gt "$v2"  -o  "$v1" -lt "$v2"  -a  -e "$filename" ]
# 这样写不清晰...

if [[ "$v1" -gt "$v2" ]] || [[ "$v1" -lt "$v2" ]] && [[ -e "$filename" ]]
# 好多了 -- 把逻辑判断分散到多个组之中
上一页8.3 双圆括号结构下一页第三部分 shell进阶

最后更新于5年前

这有帮助吗?

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

tip