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 其他比较操作
                                    • 整数比较
                                      • -eq
                                        • -ne
                                          • -gt
                                            • -ge
                                              • -lt
                                                • -le
                                                  • <
                                                    • <=
                                                      • >
                                                        • >=
                                                        • 字符串比较
                                                          • =
                                                            • ==
                                                              • !=
                                                                • <
                                                                  • >
                                                                    • -z
                                                                      • -n
                                                                      • 复合比较
                                                                        • -a
                                                                          • -o
                                                                        • 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 风格指南
                                                                                                                                                        • 前端学习笔记

                                                                                                                                                          7.3 其他比较操作

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

                                                                                                                                                          此页内容
                                                                                                                                                          • 整数比较
                                                                                                                                                            • -eq
                                                                                                                                                            • -ne
                                                                                                                                                            • -gt
                                                                                                                                                            • -ge
                                                                                                                                                            • -lt
                                                                                                                                                            • -le
                                                                                                                                                            • <
                                                                                                                                                            • <=
                                                                                                                                                            • >
                                                                                                                                                            • >=
                                                                                                                                                          • 字符串比较
                                                                                                                                                            • =
                                                                                                                                                            • ==
                                                                                                                                                            • !=
                                                                                                                                                            • <
                                                                                                                                                            • >
                                                                                                                                                            • -z
                                                                                                                                                            • -n
                                                                                                                                                          • 复合比较
                                                                                                                                                            • -a
                                                                                                                                                            • -o

                                                                                                                                                          # 7.3 其他比较操作

                                                                                                                                                          二元比较操作比较变量或者数量。注意整数和字符串比较使用的是两套运算符。

                                                                                                                                                          # 整数比较

                                                                                                                                                          # -eq

                                                                                                                                                          等于

                                                                                                                                                          if [ "$a" -eq "$b" ]

                                                                                                                                                          # -ne

                                                                                                                                                          不等于

                                                                                                                                                          if [ "$a" -ne "$b" ]

                                                                                                                                                          # -gt

                                                                                                                                                          大于

                                                                                                                                                          if [ "$a" -gt "$b" ]

                                                                                                                                                          # -ge

                                                                                                                                                          大于等于

                                                                                                                                                          if [ "$a" -ge "$b" ]

                                                                                                                                                          # -lt

                                                                                                                                                          小于

                                                                                                                                                          if [ "$a" -lt "$b" ]

                                                                                                                                                          # -le

                                                                                                                                                          小于等于

                                                                                                                                                          if [ "$a" -le "$b" ]

                                                                                                                                                          # <

                                                                                                                                                          小于(使用 双圆括号open in new window)

                                                                                                                                                          (("$a" < "$b"))

                                                                                                                                                          # <=

                                                                                                                                                          小于等于(使用双圆括号)

                                                                                                                                                          (("$a" <= "$b"))

                                                                                                                                                          # >

                                                                                                                                                          大于(使用双圆括号)

                                                                                                                                                          (("$a" > "$b"))

                                                                                                                                                          # >=

                                                                                                                                                          大于等于(使用双圆括号)

                                                                                                                                                          (("$a" >= "$b"))

                                                                                                                                                          # 字符串比较

                                                                                                                                                          # =

                                                                                                                                                          等于

                                                                                                                                                          if [ "$a" = "$b" ]

                                                                                                                                                          caution 注意在=前后要加上空格open in new window

                                                                                                                                                          if [ "$a"="$b" ] 和上面不等价。

                                                                                                                                                          # ==

                                                                                                                                                          等于

                                                                                                                                                          if [ "$a" == "$b" ]

                                                                                                                                                          和 = 同义

                                                                                                                                                          note == 运算符在 双方括号open in new window 和单方括号里表现不同。

                                                                                                                                                          [[ $a == z* ]]   # $a 以 "z" 开头时为真(模式匹配)
                                                                                                                                                          [[ $a == "z*" ]] # $a 等于 z* 时为真(字符匹配)
                                                                                                                                                          
                                                                                                                                                          [ $a == z* ]     # 发生文件匹配和字符分割。
                                                                                                                                                          [ "$a" == "z*" ] # $a 等于 z* 时为真(字符匹配)
                                                                                                                                                          
                                                                                                                                                          # 感谢 Stéphane Chazelas
                                                                                                                                                          
                                                                                                                                                          1
                                                                                                                                                          2
                                                                                                                                                          3
                                                                                                                                                          4
                                                                                                                                                          5
                                                                                                                                                          6
                                                                                                                                                          7

                                                                                                                                                          # !=

                                                                                                                                                          不等于

                                                                                                                                                          if [ "$a" != "$b" ]

                                                                                                                                                          在 [[ ... ]]open in new window 结构中会进行模式匹配。

                                                                                                                                                          # <

                                                                                                                                                          小于,按照 ASCII码open in new window 排序。

                                                                                                                                                          if [[ "$a" < "$b" ]]

                                                                                                                                                          if [ "$a" \< "$b" ]

                                                                                                                                                          注意在 [] 结构里 < 需要被 转义open in new window。

                                                                                                                                                          # >

                                                                                                                                                          大于,按照 ASCII 码排序。

                                                                                                                                                          if [[ "$a" > "$b" ]]

                                                                                                                                                          if [ "$a" \> "$b" ]

                                                                                                                                                          注意在 [] 结构里 > 需要被转义。

                                                                                                                                                          样例 27-11open in new window 包含了比较运算符。

                                                                                                                                                          # -z

                                                                                                                                                          字符串为空,即字符串长度为0。

                                                                                                                                                          String=''   # 长度为0的字符串变量。
                                                                                                                                                          
                                                                                                                                                          if [ -z "$String" ]
                                                                                                                                                          then
                                                                                                                                                            echo "\$String is null."
                                                                                                                                                          else
                                                                                                                                                            echo "\$String is NOT null."
                                                                                                                                                          fi     # $String is null.
                                                                                                                                                          
                                                                                                                                                          1
                                                                                                                                                          2
                                                                                                                                                          3
                                                                                                                                                          4
                                                                                                                                                          5
                                                                                                                                                          6
                                                                                                                                                          7
                                                                                                                                                          8

                                                                                                                                                          # -n

                                                                                                                                                          字符串非空(null)。

                                                                                                                                                          caution 使用 -n 时字符串必须是在括号中且被引用的。使用 ! -z 判断未引用的字符串或者直接判断(样例 7-6open in new window)通常可行,但是非常危险。判断字符串时一定要引用[1]。

                                                                                                                                                          样例 7-5. 算术比较和字符串比较

                                                                                                                                                          #!/bin/bash
                                                                                                                                                          
                                                                                                                                                          a=4
                                                                                                                                                          b=5
                                                                                                                                                          
                                                                                                                                                          # 这里的 "a" 和 "b" 可以是整数也可以是字符串。
                                                                                                                                                          # 因为 Bash 的变量是弱类型的,因此字符串和整数比较有很多相同之处。
                                                                                                                                                          
                                                                                                                                                          # 在 Bash 中可以用处理整数的方式来处理全是数字的字符串。
                                                                                                                                                          # 但是谨慎使用。
                                                                                                                                                          
                                                                                                                                                          echo
                                                                                                                                                          
                                                                                                                                                          if [ "$a" -ne "$b" ]
                                                                                                                                                          then
                                                                                                                                                            echo "$a is not equal to $b"
                                                                                                                                                            echo "(arithmetic comparison)"
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          echo
                                                                                                                                                          
                                                                                                                                                          if [ "$a" != "$b" ]
                                                                                                                                                          then
                                                                                                                                                            echo "$a is not equal to $b."
                                                                                                                                                            echo "(string comparison)"
                                                                                                                                                            #     "4"  != "5"
                                                                                                                                                            # ASCII 52 != ASCIII 53
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          # 在这个例子里 "-ne" 和 "!=" 都可以。
                                                                                                                                                          
                                                                                                                                                          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

                                                                                                                                                          样例 7-6. 测试字符串是否为空(null)

                                                                                                                                                          #!/bin/bash
                                                                                                                                                          # str-test.sh: 测试是否为空字符串或是未引用的字符串。
                                                                                                                                                          
                                                                                                                                                          # 使用 if [ ... ] 结构
                                                                                                                                                          
                                                                                                                                                          # 如果字符串未被初始化,则其值是未定义的。
                                                                                                                                                          # 这种状态就是空 "null"(并不是 0)。
                                                                                                                                                          
                                                                                                                                                          if [ -n $string1 ]    # 并未声明或是初始化 string1。
                                                                                                                                                          then
                                                                                                                                                            echo "String \"string1\" is not null."
                                                                                                                                                          else
                                                                                                                                                            echo "String \"string1\" is null."
                                                                                                                                                          fi
                                                                                                                                                          # 尽管没有初始化 string1,但是结果显示其非空。
                                                                                                                                                          
                                                                                                                                                          echo
                                                                                                                                                          
                                                                                                                                                          # 再试一次。
                                                                                                                                                          
                                                                                                                                                          if [ -n "$string1" ]   # 这次引用了 $string1。
                                                                                                                                                          then
                                                                                                                                                            echo "String \"string1\" is not null."
                                                                                                                                                          else
                                                                                                                                                            echo "String \"string1\" is null."
                                                                                                                                                          fi                    # 在测试括号内引用字符串得到了正确的结果。
                                                                                                                                                          
                                                                                                                                                          echo
                                                                                                                                                          
                                                                                                                                                          if [ $string1 ]       # 这次只有一个 $string1。
                                                                                                                                                          then
                                                                                                                                                            echo "String \"string1\" is not null."
                                                                                                                                                          else
                                                                                                                                                            echo "String \"string1\" is null."
                                                                                                                                                          fi                    # 结果正确。
                                                                                                                                                          # 独立的 [ ... ] 测试运算符可以用来检测字符串是否为空。
                                                                                                                                                          # 但是最好将字符串进行引用(if [ "$string1" ])。
                                                                                                                                                          #
                                                                                                                                                          # Stephane Chazelas 指出:
                                                                                                                                                          #    if [ $string1 ]    只有一个参数 "]"
                                                                                                                                                          #    if [ "$string1" ]  则有两个参数,空的 "$string1" 和 "]"
                                                                                                                                                          
                                                                                                                                                          
                                                                                                                                                          echo
                                                                                                                                                          
                                                                                                                                                          
                                                                                                                                                          string1=initialized
                                                                                                                                                          
                                                                                                                                                          if [ $string1 ]       # $string1 这次仍然没有被引用。
                                                                                                                                                          then
                                                                                                                                                            echo "String \"string1\" is not null."
                                                                                                                                                          else
                                                                                                                                                            echo "String \"string1\" is null."
                                                                                                                                                          fi                    # 这次的结果仍然是正确的。
                                                                                                                                                          # 最好将字符串引用("$string1")
                                                                                                                                                          
                                                                                                                                                          
                                                                                                                                                          string1="a = b"
                                                                                                                                                          
                                                                                                                                                          if [ $string1 ]       # $string1 这次仍然没有被引用。
                                                                                                                                                          then
                                                                                                                                                            echo "String \"string1\" is not null."
                                                                                                                                                          else
                                                                                                                                                            echo "String \"string1\" is null."
                                                                                                                                                          fi                    # 这次没有引用就错了。
                                                                                                                                                          
                                                                                                                                                          exit 0   # 同时感谢 Florian Wisser 的提示。
                                                                                                                                                          
                                                                                                                                                          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
                                                                                                                                                          50
                                                                                                                                                          51
                                                                                                                                                          52
                                                                                                                                                          53
                                                                                                                                                          54
                                                                                                                                                          55
                                                                                                                                                          56
                                                                                                                                                          57
                                                                                                                                                          58
                                                                                                                                                          59
                                                                                                                                                          60
                                                                                                                                                          61
                                                                                                                                                          62
                                                                                                                                                          63
                                                                                                                                                          64
                                                                                                                                                          65
                                                                                                                                                          66
                                                                                                                                                          67

                                                                                                                                                          样例 7-7. zmore

                                                                                                                                                          #!/bin/bash
                                                                                                                                                          # zmore
                                                                                                                                                          
                                                                                                                                                          # 使用筛选器 'more' 查看 gzipped 文件。
                                                                                                                                                          
                                                                                                                                                          E_NOARGS=85
                                                                                                                                                          E_NOTFOUND=86
                                                                                                                                                          E_NOTGZIP=87
                                                                                                                                                          
                                                                                                                                                          if [ $# -eq 0 ] # 作用和 if [ -z "$1" ] 相同。
                                                                                                                                                          # $1 可以为空: zmore "" arg2 arg3
                                                                                                                                                          then
                                                                                                                                                            echo "Usage: `basename $0` filename" >&2
                                                                                                                                                            # 将错误信息通过标准错误 stderr 进行输出。
                                                                                                                                                            exit $E_NOARGS
                                                                                                                                                            # 脚本的退出状态为 85.
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          filename=$1
                                                                                                                                                          
                                                                                                                                                          if [ ! -f "$filename" ]   # 引用字符串以防字符串中带有空格。
                                                                                                                                                          then
                                                                                                                                                            echo "File $filename not found!" >&2   # 通过标准错误 stderr 进行输出。
                                                                                                                                                            exit $E_NOTFOUND
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          if [ ${filename##*.} != "gz" ]
                                                                                                                                                          # 在括号内使用变量代换。
                                                                                                                                                          then
                                                                                                                                                            echo "File $1 is not a gzipped file!"
                                                                                                                                                            exit $E_NOTGZIP
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          zcat $1 | more
                                                                                                                                                          
                                                                                                                                                          # 使用筛选器 'more'
                                                                                                                                                          # 也可以用 'less' 替代
                                                                                                                                                          
                                                                                                                                                          exit $?   # 脚本的退出状态由管道 pipe 的退出状态决定。
                                                                                                                                                          #  实际上 "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
                                                                                                                                                          38
                                                                                                                                                          39
                                                                                                                                                          40
                                                                                                                                                          41

                                                                                                                                                          # 复合比较

                                                                                                                                                          # -a

                                                                                                                                                          逻辑与

                                                                                                                                                          exp1 -a exp2 返回真当且仅当 exp1 和 exp2 均为真。

                                                                                                                                                          # -o

                                                                                                                                                          逻辑或

                                                                                                                                                          如果 exp1 或 exp2 为真,则 exp1 -o exp2 返回真。

                                                                                                                                                          以上两个操作和 双方括号open in new window 结构中的 Bash 比较运算符号 && 和 || 类似。

                                                                                                                                                          [[ condition1 && condition2 ]]
                                                                                                                                                          
                                                                                                                                                          1

                                                                                                                                                          测试操作 -o 和 -a 可以在 testopen in new window 命令或在测试括号中进行。

                                                                                                                                                          if [ "$expr1" -a "$expr2" ]
                                                                                                                                                          then
                                                                                                                                                            echo "Both expr1 and expr2 are true."
                                                                                                                                                          else
                                                                                                                                                            echo "Either expr1 or expr2 is false."
                                                                                                                                                          fi
                                                                                                                                                          
                                                                                                                                                          1
                                                                                                                                                          2
                                                                                                                                                          3
                                                                                                                                                          4
                                                                                                                                                          5
                                                                                                                                                          6

                                                                                                                                                          caution rihad 指出:

                                                                                                                                                          [ 1 -eq 1 ] && [ -n "`echo true 1>&2`" ]   # 真
                                                                                                                                                          [ 1 -eq 2 ] && [ -n "`echo true 1>&2`" ]   # 没有输出
                                                                                                                                                          # ^^^^^^^ 条件为假。到这里为止,一切都按预期执行。
                                                                                                                                                          
                                                                                                                                                          # 但是
                                                                                                                                                          [ 1 -eq 2 -a -n "`echo true 1>&2`" ]       # 真
                                                                                                                                                          # ^^^^^^^ 条件为假。但是为什么结果为真?
                                                                                                                                                          
                                                                                                                                                          # 是因为括号内的两个条件子句都执行了么?
                                                                                                                                                          [[ 1 -eq 2 && -n "`echo true 1>&2`" ]]     # 没有输出
                                                                                                                                                          # 并不是。
                                                                                                                                                          
                                                                                                                                                          #  所以显然 && 和 || 具备“短路”机制,
                                                                                                                                                          #+ 例如对于 &&,若第一个表达式为假,则不执行第二个表达式直接返回假,
                                                                                                                                                          #+ 而 -a 和 -o 则不是。
                                                                                                                                                          
                                                                                                                                                          1
                                                                                                                                                          2
                                                                                                                                                          3
                                                                                                                                                          4
                                                                                                                                                          5
                                                                                                                                                          6
                                                                                                                                                          7
                                                                                                                                                          8
                                                                                                                                                          9
                                                                                                                                                          10
                                                                                                                                                          11
                                                                                                                                                          12
                                                                                                                                                          13
                                                                                                                                                          14
                                                                                                                                                          15

                                                                                                                                                          复合比较操作的例子可以参考 样例 8-3open in new window,样例 27-17open in new window 和 样例 A-29open in new window。


                                                                                                                                                          1. S.C. 指出在复合测试中,仅仅引用字符串可能还不够。比如表达式 [ -n "$string" -o "$a" = "$b" ] 在某些 Bash 版本下,如果 $string 为空可能会出错。更加安全的方式是,对于可能为空的字符串,添加一个额外的字符,例如 [ "x$string" != x -o "x$a" = "x$b" ](其中的 x 互相抵消)。 ↩︎

                                                                                                                                                          edit icon编辑此页open in new window
                                                                                                                                                          上次编辑于: 2022/4/27 15:33:00
                                                                                                                                                          贡献者: clay-wangzhi
                                                                                                                                                          上一页
                                                                                                                                                          7.2 文件测试操作
                                                                                                                                                          下一页
                                                                                                                                                          7.4 嵌套 if/then 条件测试
                                                                                                                                                          备案号:冀ICP备2021007336号
                                                                                                                                                          Copyright © 2023 LinuxStory