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

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

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

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

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

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

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

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

                                              • 第九章 换个角度看变量

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

                                                        • 10.1 字符串处理
                                                          • 10.1.1 使用 awk 处理字符串
                                                            • 10.1.2 参考资料
                                                              • 10.2 参数替换
                                                                • ${parameter}
                                                                  • ${parameter-default}, ${parameter:-default}
                                                                    • ${parameter=default}, ${parameter:=default}
                                                                      • ${parameter+alt_value}, ${parameter:+alt_value}
                                                                        • ${parameter?err_msg}, ${parameter:?err_msg}
                                                                          • 变量长度 / 删除子串
                                                                            • 变量扩展 / 替换子串
                                                                          • 第十一章 循环与分支

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

                                                                                                                                  10.2 参数替换

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

                                                                                                                                  此页内容
                                                                                                                                  • ${parameter}
                                                                                                                                  • ${parameter-default}, ${parameter:-default}
                                                                                                                                  • ${parameter=default}, ${parameter:=default}
                                                                                                                                  • ${parameter+alt_value}, ${parameter:+alt_value}
                                                                                                                                  • ${parameter?err_msg}, ${parameter:?err_msg}
                                                                                                                                  • 变量长度 / 删除子串
                                                                                                                                  • 变量扩展 / 替换子串

                                                                                                                                  # 10.2 参数替换

                                                                                                                                  参数替换用来处理或扩展变量。

                                                                                                                                  # ${parameter}

                                                                                                                                  等同于 $parameter,是变量 parameter 的值。在一些特定的环境下,只允许使用不易混淆的 ${parameter} 形式。

                                                                                                                                  可以用于连接变量与字符串。

                                                                                                                                  your_id=${USER}-on-${HOSTNAME}
                                                                                                                                  echo "$your_id"
                                                                                                                                  # 
                                                                                                                                  echo "Old \$PATH = $PATH"
                                                                                                                                  PATH=${PATH}:/opt/bin  # 在脚本执行过程中临时在 $PATH 中加入 /opt/bin。
                                                                                                                                  echo "New \$PATH = $PATH"
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6

                                                                                                                                  # ${parameter-default}, ${parameter:-default}

                                                                                                                                  在没有设置变量的情况下使用缺省值。

                                                                                                                                  var1=1
                                                                                                                                  var2=2
                                                                                                                                  # 没有设置 var3。
                                                                                                                                  
                                                                                                                                  echo ${var1-$var2}   # 1
                                                                                                                                  echo ${var3-$var2}   # 2
                                                                                                                                  #           ^          注意前面的 $ 前缀。
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  echo ${username-`whoami`}
                                                                                                                                  # 如果变量 $username 没有被设置,输出 `whoami` 的结果。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12

                                                                                                                                  note ${parameter-default} 与 ${parameter:-default} 的作用几乎相同,唯一不同的情况就是当变量 parameter 已经被声明但值为空时。

                                                                                                                                  #!/bin/bash
                                                                                                                                  # param-sub.sh
                                                                                                                                  
                                                                                                                                  # 无论变量的值是否为空,其是否已被声明决定了缺省设置的触发。
                                                                                                                                  
                                                                                                                                  username0=
                                                                                                                                  echo "username0 has been declared, but is set to null."
                                                                                                                                  echo "username0 = ${username0-`whoami`}"
                                                                                                                                  # 将不会输出 `whoami` 的结果。
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  echo username1 has not been declared.
                                                                                                                                  echo "username1 = ${username1-`whoami`}"
                                                                                                                                  # 将会输出 `whoami` 的结果。
                                                                                                                                  
                                                                                                                                  username2=
                                                                                                                                  echo "username2 has been declared, but is set to null."
                                                                                                                                  echo "username2 = ${username2:-`whoami`}"
                                                                                                                                  #                            ^
                                                                                                                                  # 因为这里是 :- 而不是 -,所以将会输出 `whoami` 的结果。
                                                                                                                                  # 与上面的 username0 比较。
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  # 
                                                                                                                                  
                                                                                                                                  # 再来一次:
                                                                                                                                  
                                                                                                                                  variable=
                                                                                                                                  # 变量已被声明,但其值为空。
                                                                                                                                  
                                                                                                                                  echo "${varibale-0}"    # 没有输出。
                                                                                                                                  echo "${variable:-1}"   # 1
                                                                                                                                  #               ^
                                                                                                                                  
                                                                                                                                  unser variable
                                                                                                                                  
                                                                                                                                  echo "${variable-2}"    # 2
                                                                                                                                  echo "${variable:-3}"   # 3
                                                                                                                                  
                                                                                                                                  exit 0
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15
                                                                                                                                  16
                                                                                                                                  17
                                                                                                                                  18
                                                                                                                                  19
                                                                                                                                  20
                                                                                                                                  21
                                                                                                                                  22
                                                                                                                                  23
                                                                                                                                  24
                                                                                                                                  25
                                                                                                                                  26
                                                                                                                                  27
                                                                                                                                  28
                                                                                                                                  29
                                                                                                                                  30
                                                                                                                                  31
                                                                                                                                  32
                                                                                                                                  33
                                                                                                                                  34
                                                                                                                                  35
                                                                                                                                  36
                                                                                                                                  37
                                                                                                                                  38
                                                                                                                                  39
                                                                                                                                  40
                                                                                                                                  41

                                                                                                                                  当传入的命令行参数的数量不足时,可以使用这种缺省参数结构。

                                                                                                                                  DEFAULT_FILENAME=generic.data
                                                                                                                                  filename=${1:-$DEFAULT_FILENAME}
                                                                                                                                  # 如果没有其他特殊情况,下面的代码块将会操作文件 "generic.data"。
                                                                                                                                  # 代码块开始
                                                                                                                                  # ...
                                                                                                                                  # ...
                                                                                                                                  # ...
                                                                                                                                  # 代码块结束
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  # 摘自样例 "hanoi2.bash":
                                                                                                                                  DISKS=${1:-E_NOPARAM}   # 必须指定碟子的个数。
                                                                                                                                  #  将 $DISKS 设置为传入的第一个命令行参数,
                                                                                                                                  #+ 如果没有传入第一个参数,则设置为 $E_NOPARAM。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15

                                                                                                                                  可以查看 样例 3-4open in new window,样例 31-2open in new window 和 样例 A-6open in new window。

                                                                                                                                  可以同 使用与链设置缺省命令行参数open in new window 做比较。

                                                                                                                                  # ${parameter=default}, ${parameter:=default}

                                                                                                                                  在没有设置变量的情况下,将其设置为缺省值。

                                                                                                                                  两种形式的作用几乎相同,唯一不同的情况与上面类似,就是当变量 parameter 已经被声明但值为空时。[1]

                                                                                                                                  echo ${var=abc}   # abc
                                                                                                                                  echo ${vat=xyz}   # abc
                                                                                                                                  # $var 已经在第一条语句中被赋值为 abc,因此第二条语句将不会改变它的值。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3

                                                                                                                                  # ${parameter+alt_value}, ${parameter:+alt_value}

                                                                                                                                  如果变量已被设置,使用 alt_value,否则使用空值。

                                                                                                                                  两种形式的作用几乎相同,唯一不同的情况就是当变量 parameter 已经被声明但值为空时,看下面的例子。

                                                                                                                                  echo "###### \${parameter+alt_value} ########"
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  a=${param1+xyz}
                                                                                                                                  echo "a = $a"      # a =
                                                                                                                                  
                                                                                                                                  param2=
                                                                                                                                  a=${param2+xyz}
                                                                                                                                  echo "a = $a"      # a = xyz
                                                                                                                                  
                                                                                                                                  param3=123
                                                                                                                                  a=${param3+xyz}
                                                                                                                                  echo "a = $a"      # a = xyz
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  echo "###### \${parameter:+alt_value} ########"
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  a=${param4:+xyz}
                                                                                                                                  echo "a = $a"      # a =
                                                                                                                                  
                                                                                                                                  param5=
                                                                                                                                  a=${param5:+xyz}
                                                                                                                                  echo "a = $a"      # a =
                                                                                                                                  # 不同于 a=${param5+xyz}
                                                                                                                                  
                                                                                                                                  param6=123
                                                                                                                                  a=${param6:+xyz}
                                                                                                                                  echo "a = $a"      # a = xyz
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  # ${parameter?err_msg}, ${parameter:?err_msg}

                                                                                                                                  如果变量已被设置,那么使用原值,否则输出 err_msg 并且终止脚本,返回 错误码open in new window 1。

                                                                                                                                  两种形式的作用几乎相同,唯一不同的情况与上面类似,就是当变量 parameter 已经被声明但值为空时。

                                                                                                                                  样例 10-7. 如何使用变量替换和错误信息

                                                                                                                                  #!/bin/bash
                                                                                                                                  
                                                                                                                                  # 检查系统环境变量。
                                                                                                                                  # 这是一种良好的预防性维护措施。
                                                                                                                                  # 如果控制台用户的名称 $USER 没有被设置,那么主机将不能够识别用户。
                                                                                                                                  
                                                                                                                                  : ${HOSTNAME?} ${USER?} ${HOME?} ${MAIL?}
                                                                                                                                    echo
                                                                                                                                    echo "Name of the machine is $HOSTNAME."
                                                                                                                                    echo "You are $USER."
                                                                                                                                    echo "Your home directory is $HOME."
                                                                                                                                    echo "Your mail INBOX is located in $MAIL."
                                                                                                                                    echo
                                                                                                                                    echo "If you are reading this message,"
                                                                                                                                    echo "critcial environmental variables have been set."
                                                                                                                                    echo
                                                                                                                                    echo
                                                                                                                                    
                                                                                                                                  # ------------------------------------------------------
                                                                                                                                  
                                                                                                                                  # ${variablename?} 结构统一可以检查脚本中的变量是否被设置。
                                                                                                                                  
                                                                                                                                  ThisVariable=Value-of-ThisVariable
                                                                                                                                  # 顺带一提,这个字符串的值可以被设置成名称中不可以使用的禁用字符。
                                                                                                                                  : ${ThisVariable?}
                                                                                                                                  echo "Value of ThisVariable is $ThisVariable."
                                                                                                                                  
                                                                                                                                  echo; echo
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  : ${ZZXy23AB?"ZZXy23AB has not been set."}
                                                                                                                                  # 因为 ZZXy23AB 没有被设置,所以脚本会终止同时显示错误消息。
                                                                                                                                  
                                                                                                                                  # 你可以指定错误消息。
                                                                                                                                  # : ${variablename?"ERROR MESSAGE"}
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  # 与这些结果相同:  dummy_variable=${ZZXy23AB?}
                                                                                                                                  #                 dummy_variable=${ZZXy23AB?"ZZXy23AB has not been set."}
                                                                                                                                  #
                                                                                                                                  #                 echo ${ZZXy23AB?} >/dev/null
                                                                                                                                  
                                                                                                                                  # 将上面这些检查变量是否被设置的方法同 "set -u" 作比较。
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  echo "You will not see this message, because script already terminated."
                                                                                                                                  
                                                                                                                                  HERE=0
                                                                                                                                  exit $HERE   # 将不会从这里退出。
                                                                                                                                  
                                                                                                                                  #  事实上,这个脚本将会返回退出码(echo $?)1。
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  样例 10-8. 参数替换与 "usage" 消息

                                                                                                                                  #!/bin/bash
                                                                                                                                  # usage-message.sh
                                                                                                                                  
                                                                                                                                  : ${1?"Usage: $0 ARGUMENT"}
                                                                                                                                  # 如果命令行参数缺失,脚本将会在这里结束,并且返回下面的错误信息。
                                                                                                                                  #    usage-message.sh: 1: Usage: usage-message.sh ARGUMENT
                                                                                                                                  
                                                                                                                                  echo "These two lines echo only if command-line parameter given."
                                                                                                                                  echo "command-line parameter = \"$1\""
                                                                                                                                  
                                                                                                                                  exit 0  # 仅当命令行参数存在是才会从这里退出。
                                                                                                                                  
                                                                                                                                  # 在传入和未传入命令行参数的情况下查看退出状态。
                                                                                                                                  # 如果传入了命令行参数,那么 "$?" 的结果是0。
                                                                                                                                  # 如果没有,那么 "$?" 的结果是1。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15

                                                                                                                                  参数替换用来处理或扩展变量。下面的表达式是对 expr 处理字符串的操作的补足(查看样例 16-9)。这些特殊的表达式通常养来解析文件的路径名。

                                                                                                                                  # 变量长度 / 删除子串

                                                                                                                                  # ${#var}

                                                                                                                                  字符串的长度($var 中字符的个数)。对任意 数组open in new window array,${#array} 返回数组中第一个元素的长度。

                                                                                                                                  note 以下情况例外:

                                                                                                                                  • ${#*} 和 ${#@} 返回位置参数的个数。
                                                                                                                                  • 任意数组 array,${#array[*]} 和 ${#array[@]} 返回数组中元素的个数。

                                                                                                                                  样例 10-9. 变量长度

                                                                                                                                  #!/bin/bash
                                                                                                                                  # length.sh
                                                                                                                                  
                                                                                                                                  E_NO_ARGS=65
                                                                                                                                  
                                                                                                                                  if [ $# -eq 0 ]  # 脚本必须传入参数。
                                                                                                                                  then
                                                                                                                                    echo "Please invoke this script with one or more command-line arguments."
                                                                                                                                    exit $E_NO_ARGS
                                                                                                                                  fi
                                                                                                                                  
                                                                                                                                  var01=abcdEFGH28ij
                                                                                                                                  echo "var01 = ${var01}"
                                                                                                                                  echo "Length of var01 = ${#var01}"
                                                                                                                                  # 现在我们尝试加入空格。
                                                                                                                                  var02="abcd EFGH28ij"
                                                                                                                                  echo "var02 = ${var02}"
                                                                                                                                  echo "Length of var02 = ${#var02}"
                                                                                                                                  
                                                                                                                                  echo "Number of command-line arguments passed to script = ${#@}"
                                                                                                                                  echo "Number of command-line arguments passed to script = ${#*}"
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  # ${var#Pattern}, ${var##Pattern}

                                                                                                                                  ${var#Pattern} 删除 $var 前缀部分匹配到的最短长度的 $Pattern。

                                                                                                                                  ${var##Pattern} 删除 $var 前缀部分匹配到的最长长度的 $Pattern。

                                                                                                                                  摘自 样例 A-7open in new window 的例子:

                                                                                                                                  # 函数摘自样例 "day-between.sh"。
                                                                                                                                  # 删除传入的参数中的前缀0。
                                                                                                                                  
                                                                                                                                  strip_leading_zero () #  删除传入参数中可能存在的
                                                                                                                                  {                     #+ 前缀0。
                                                                                                                                    return=${1#0}       #  "1" 代表 "$1",即传入的参数。
                                                                                                                                  }                     #  从 "$1" 中删除 "0"。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7

                                                                                                                                  下面是由 Manfred Schwarb 提供的上述函数的改进版本:

                                                                                                                                  strip_leading_zero2 () # 删除前缀0,
                                                                                                                                  {                      # 否则 Bash 会将其解释为8进制数。
                                                                                                                                    shopt -s extglob     # 启用扩展通配特性。
                                                                                                                                    local val=${1##+(0)} # 使用本地变量,匹配前缀中所有的0。
                                                                                                                                    shopt -u extglob     # 禁用扩展通配特性。
                                                                                                                                    _strip_leading_zero2=${var:-0}
                                                                                                                                                         # 如果输入的为0,那么返回 0 而不是 ""。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7

                                                                                                                                  另外一个样例:

                                                                                                                                  echo `basename $PWD`        # 当前工作目录的目录名。
                                                                                                                                  echo "${PWD##*/}"           # 当前工作目录的目录名。
                                                                                                                                  echo
                                                                                                                                  echo `basename $0`          # 脚本名。
                                                                                                                                  echo $0                     # 脚本名。
                                                                                                                                  echo "${0##*/}"             # 脚本名。
                                                                                                                                  echo
                                                                                                                                  filename=test.data
                                                                                                                                  echo "${filename##*.}"      # data
                                                                                                                                                              # 文件扩展名。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10

                                                                                                                                  # ${var%Pattern}, ${var%%Pattern}

                                                                                                                                  ${var%Pattern} 删除 $var 后缀部分匹配到的最短长度的 $Pattern。

                                                                                                                                  ${var%%Pattern} 删除 $var 后缀部分匹配到的最长长度的 $Pattern。

                                                                                                                                  在 Bash 的 第二个版本open in new window 中增加了一些额外的选择。

                                                                                                                                  样例 10-10. 参数替换中的模式匹配

                                                                                                                                  #!/bin/bash
                                                                                                                                  # patt-matching.sh
                                                                                                                                  
                                                                                                                                  # 使用 # ## % %% 参数替换操作符进行模式匹配
                                                                                                                                  
                                                                                                                                  var1=abcd12345abc6789
                                                                                                                                  pattern1=a*c  # 通配符 * 可以匹配 a 与 c 之间的任意字符
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  echo "var1 = $var1"           # abcd12345abc6789
                                                                                                                                  echo "var1 = ${var1}"         # abcd12345abc6789
                                                                                                                                                                # (另一种形式)
                                                                                                                                  echo "Number of characters in ${var1} = ${#var1}"
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  echo "pattern1 = $pattern1"   # a*c  (匹配 'a' 与 'c' 之间的一切)
                                                                                                                                  echo "--------------"
                                                                                                                                  echo '${var1#$pattern1}  =' "${var1#$pattern1}"    #         d12345abc6789
                                                                                                                                  # 匹配到首部最短的3个字符                                   abcd12345abc6789
                                                                                                                                  #             ^                                           |-|
                                                                                                                                  echo '${var1##$pattern1} =' "${var1##$pattern1}"   #                  6789
                                                                                                                                  # 匹配到首部最长的12个字符                                  abcd12345abc6789
                                                                                                                                  #             ^                                           |----------|
                                                                                                                                  
                                                                                                                                  echo; echo; echo
                                                                                                                                  
                                                                                                                                  pattern2=b*9            # 匹配 'b' 与 '9' 之间的任意字符
                                                                                                                                  echo "var1 = $var1"     # 仍旧是 abcd12345abc6789
                                                                                                                                  echo
                                                                                                                                  echo "pattern2 = $pattern2"
                                                                                                                                  echo "--------------"
                                                                                                                                  echo '${var1%pattern2}  =' "${var1%$pattern2}"     #     abcd12345a
                                                                                                                                  # 匹配到尾部最短的6个字符                                  abcd12345abc6789
                                                                                                                                  #             ^                                                    |----|
                                                                                                                                  echo '${var1%%pattern2} =' "${var1%%$pattern2}"    #     a
                                                                                                                                  # 匹配到尾部最长的12个字符                                 abcd12345abc6789
                                                                                                                                  #             ^                                           |-------------|
                                                                                                                                  
                                                                                                                                  # 牢记 # 与 ## 是从字符串左侧开始,
                                                                                                                                  #      % 与 %% 是从右侧开始。
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  exit 0
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15
                                                                                                                                  16
                                                                                                                                  17
                                                                                                                                  18
                                                                                                                                  19
                                                                                                                                  20
                                                                                                                                  21
                                                                                                                                  22
                                                                                                                                  23
                                                                                                                                  24
                                                                                                                                  25
                                                                                                                                  26
                                                                                                                                  27
                                                                                                                                  28
                                                                                                                                  29
                                                                                                                                  30
                                                                                                                                  31
                                                                                                                                  32
                                                                                                                                  33
                                                                                                                                  34
                                                                                                                                  35
                                                                                                                                  36
                                                                                                                                  37
                                                                                                                                  38
                                                                                                                                  39
                                                                                                                                  40
                                                                                                                                  41
                                                                                                                                  42
                                                                                                                                  43
                                                                                                                                  44

                                                                                                                                  样例 10-11. 更改文件扩展名:

                                                                                                                                  #!/bin/bash
                                                                                                                                  # rfe.sh: 更改文件扩展名。
                                                                                                                                  #
                                                                                                                                  #         rfe old_extension new_extension
                                                                                                                                  #
                                                                                                                                  # 如:
                                                                                                                                  # 将当前目录下所有 *.gif 文件重命名为 *.jpg,
                                                                                                                                  #         rfe gif jpg
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  E_BADARGS=65
                                                                                                                                  
                                                                                                                                  case $# in
                                                                                                                                    0|1)             # 竖线 | 在这里表示逻辑或关系。
                                                                                                                                    echo "Usage: `basename $0` old_file_suffix new_file_suffix"
                                                                                                                                    exit $E_BADARGS  # 如果只有0个或1个参数,那么退出脚本。
                                                                                                                                    ;;
                                                                                                                                  esac
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  for filename in *.$1
                                                                                                                                  # 遍历以第一个参数作为后缀名的文件列表。
                                                                                                                                  do
                                                                                                                                    mv $filename ${filename%$1}$2
                                                                                                                                    # 删除文件后缀名,增加第二个参数作为后缀名。
                                                                                                                                  done
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  # 变量扩展 / 替换子串

                                                                                                                                  下面这些结构采用自 ksh。

                                                                                                                                  # ${var:pos}

                                                                                                                                  扩展为从偏移量 pos 处截取的变量 var。

                                                                                                                                  # ${var:pos:len}

                                                                                                                                  扩展为从偏移量 pos 处截取变量 var 最大长度为 len 的字符串。

                                                                                                                                  # ${var/Pattern/Replacement}

                                                                                                                                  替换 var 中第一个匹配到的 Pattern 为 Replacement。

                                                                                                                                  如果 Replacement 被省略,那么匹配到的第一个 Pattern 将被替换为空,即删除。

                                                                                                                                  # ${var//Pattern/Replacement}

                                                                                                                                  全局替换。替换 var 中所有匹配到的 Pattern 为 Replacement。

                                                                                                                                  跟上面一样,如果 Replacement 被省略,那么匹配到的所有 Pattern 将被替换为空,即删除。

                                                                                                                                  样例 10-12. 使用模式匹配解析任意字符串

                                                                                                                                  #!/bin/bash
                                                                                                                                  
                                                                                                                                  var1=abcd-1234-defg
                                                                                                                                  echo "var1 = $var1"
                                                                                                                                  
                                                                                                                                  t=${var1#*-*}
                                                                                                                                  echo "var1 (with everything, up to and including first - stripped out) = $t"
                                                                                                                                  #  t=${var1#*-} 效果相同,
                                                                                                                                  #+ 因为 # 只匹配最短的字符串,
                                                                                                                                  #+ 并且 * 可以任意匹配,其中也包括空字符串。
                                                                                                                                  # (感谢 Stephane Chazelas 指出这一点。)
                                                                                                                                  
                                                                                                                                  t=${var##*-*}
                                                                                                                                  echo "If var1 contains a \"-\", returns empty string...   var1 = $t"
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  t=${var1%*-*}
                                                                                                                                  echo "var1 (with everything from the last - on stripped out) = $t"
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  # -------------------------------------------
                                                                                                                                  path_name=/home/bozo/ideas/thoughts/for.today
                                                                                                                                  # -------------------------------------------
                                                                                                                                  echo "path_name = $path_name"
                                                                                                                                  t=${path_name##/*/}
                                                                                                                                  echo "path_name, stripped of prefixes = $t"
                                                                                                                                  # 在这里与 t=`basename $path_name` 效果相同。
                                                                                                                                  #  t=${path_name%/}; t=${t##*/}  是更加通用的方法,
                                                                                                                                  #+ 但有时仍旧也会出现问题。
                                                                                                                                  #  如果 $path_name 以换行结束,那么 `basename $path_name` 将会失效,
                                                                                                                                  #+ 但是上面这种表达式却可以。
                                                                                                                                  # (感谢 S.C.)
                                                                                                                                  
                                                                                                                                  t=${path_name%/*.*}
                                                                                                                                  # 同 t=`dirname $path_name` 效果相同。
                                                                                                                                  echo "path_name, stripped of suffixes = $t"
                                                                                                                                  # 在一些情况下会失效,比如 "../", "/foo////", # "foo/", "/"。
                                                                                                                                  #  在删除后缀时,尤其是当文件名没有后缀,目录名却有后缀时,
                                                                                                                                  #+ 事情会变的非常复杂。
                                                                                                                                  # (感谢 S.C.)
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  t=${path_name:11}
                                                                                                                                  echo "$path_name, with first 11 chars stripped off = $t"
                                                                                                                                  t=${path_name:11:5}
                                                                                                                                  echo "$path_name, with first 11 chars stripped off, length 5 = $t"
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  t=${path_name/bozo/clown}
                                                                                                                                  echo "$path_name with \"bozo\" replaced by \"clown\" = $t"
                                                                                                                                  t=${path_name/today/}
                                                                                                                                  echo "$path_name with \"today\" deleted = $t"
                                                                                                                                  t=${path_name//o/O}
                                                                                                                                  echo "$path_name with all o's capitalized = $t"
                                                                                                                                  t=${path_name//o/}
                                                                                                                                  echo "$path_name with all o's deleted = $t"
                                                                                                                                  
                                                                                                                                  exit 0
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15
                                                                                                                                  16
                                                                                                                                  17
                                                                                                                                  18
                                                                                                                                  19
                                                                                                                                  20
                                                                                                                                  21
                                                                                                                                  22
                                                                                                                                  23
                                                                                                                                  24
                                                                                                                                  25
                                                                                                                                  26
                                                                                                                                  27
                                                                                                                                  28
                                                                                                                                  29
                                                                                                                                  30
                                                                                                                                  31
                                                                                                                                  32
                                                                                                                                  33
                                                                                                                                  34
                                                                                                                                  35
                                                                                                                                  36
                                                                                                                                  37
                                                                                                                                  38
                                                                                                                                  39
                                                                                                                                  40
                                                                                                                                  41
                                                                                                                                  42
                                                                                                                                  43
                                                                                                                                  44
                                                                                                                                  45
                                                                                                                                  46
                                                                                                                                  47
                                                                                                                                  48
                                                                                                                                  49
                                                                                                                                  50
                                                                                                                                  51
                                                                                                                                  52
                                                                                                                                  53
                                                                                                                                  54
                                                                                                                                  55
                                                                                                                                  56
                                                                                                                                  57
                                                                                                                                  58
                                                                                                                                  59
                                                                                                                                  60
                                                                                                                                  61

                                                                                                                                  # ${var/#Pattern/Replacement}

                                                                                                                                  替换 var 前缀部分匹配到的 Pattern 为 Replacement。

                                                                                                                                  # ${var/%Pattern/Replacement}

                                                                                                                                  替换 var 后缀部分匹配到的 Pattern 为 Replacement。

                                                                                                                                  样例 10-13. 在字符串首部或尾部进行模式匹配

                                                                                                                                  #!/bin/bash
                                                                                                                                  # var-match.sh:
                                                                                                                                  # 演示在字符串首部或尾部进行模式替换。
                                                                                                                                  
                                                                                                                                  v0=abc1234zip1234abc    # 初始值。
                                                                                                                                  echo "v0 = $v0"         # abc1234zip1234abc
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  # 在字符串首部进行匹配
                                                                                                                                  v1=${v0/#abc/ABCDEF}    # abc1234zip123abc
                                                                                                                                                          # |-|
                                                                                                                                  echo "v1 = $v1"         # ABCDEF1234zip1234abc
                                                                                                                                                          # |----|
                                                                                                                                                          
                                                                                                                                  # 在字符串尾部进行匹配
                                                                                                                                  v2=${v0/%abc/ABCDEF}    # abc1234zip123abc
                                                                                                                                                          #              |-|
                                                                                                                                  echo "v2 = $v2"         # abc1234zip1234ABCDEF
                                                                                                                                                          #               |----|
                                                                                                                                                          
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  #  --------------------------------------------
                                                                                                                                  #  必须在字符串的最开始或者最末尾的地方进行匹配,
                                                                                                                                  #+ 否则将不会发生替换。
                                                                                                                                  #  --------------------------------------------
                                                                                                                                  v3=${v0/#123/000}       # 虽然匹配到了,但是不在最开始的地方。
                                                                                                                                  echo "v3 = $v3"         # abc1234zip1234abc
                                                                                                                                                          # 没有替换。
                                                                                                                                  v4=${v0/%123/000}       # 虽然匹配到了,但是不在最末尾的地方。
                                                                                                                                  echo "v4 = $v4"         # abc1234zip1234abc
                                                                                                                                                          # 没有替换。
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  # ${!varprefix*}, ${!varprefix@}

                                                                                                                                  匹配先前声明过所有以 varprefix 作为变量名前缀的变量。

                                                                                                                                  # 这是带 * 或 @ 的间接引用的一种变换形式。
                                                                                                                                  # 在 Bash 2.04 版本中加入了这个特性。
                                                                                                                                  
                                                                                                                                  xyz23=whatever
                                                                                                                                  xyz23=
                                                                                                                                  
                                                                                                                                  a=${!xyz*}         #  扩展为声明变量中以 "xyz"
                                                                                                                                  # ^ ^   ^           + 开头变量名。
                                                                                                                                  echo "a = $a"      #  a = xyz23 xyz24
                                                                                                                                  a=${!xyz@}         #  同上。
                                                                                                                                  echo "a = $a"      #  a = xyz23 xyz24
                                                                                                                                  
                                                                                                                                  echo "---"
                                                                                                                                  
                                                                                                                                  abc23=something_else
                                                                                                                                  b=${!abc*}
                                                                                                                                  echo "b = $b"      #  b = abc23
                                                                                                                                  c=${!b}            #  这是我们熟悉的间接引用的形式。
                                                                                                                                  echo $c            #  something_else
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14
                                                                                                                                  15
                                                                                                                                  16
                                                                                                                                  17
                                                                                                                                  18
                                                                                                                                  19

                                                                                                                                  1. 如果在非交互的脚本中,$parameter 为空,那么程序将会终止,并且返回 错误码 127open in new window(意为“找不到命令”)。 ↩︎

                                                                                                                                  edit icon编辑此页open in new window
                                                                                                                                  上次编辑于: 2022/4/27 15:33:00
                                                                                                                                  贡献者: clay-wangzhi
                                                                                                                                  上一页
                                                                                                                                  10.1.2 参考资料
                                                                                                                                  备案号:冀ICP备2021007336号
                                                                                                                                  Copyright © 2023 LinuxStory