10.2 参数替换

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

${parameter}

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

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

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

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

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

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

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

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

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

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

可以查看 样例 3-4，样例 31-2 和 样例 A-6。

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

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

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

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

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

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

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

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

  1. echo "###### \${parameter+alt_value} ########"
  2. echo
  4. a=${param1+xyz}
  5. echo "a = $a"      # a =
  7. param2=
  8. a=${param2+xyz}
  9. echo "a = $a"      # a = xyz
  11. param3=123
  12. a=${param3+xyz}
  13. echo "a = $a"      # a = xyz
  15. echo
  16. echo "###### \${parameter:+alt_value} ########"
  17. echo
  19. a=${param4:+xyz}
  20. echo "a = $a"      # a =
  22. param5=
  23. a=${param5:+xyz}
  24. echo "a = $a"      # a =
  25. # 不同于 a=${param5+xyz}
  27. param6=123
  28. a=${param6:+xyz}
  29. echo "a = $a"      # a = xyz

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

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

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

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

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

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

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

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

变量长度 / 删除子串

${#var}

字符串的长度（$var 中字符的个数）。对任意 数组 array，${#array} 返回数组中第一个元素的长度。

note 以下情况例外：

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

样例 10-9. 变量长度

  1. #!/bin/bash
  2. # length.sh
  4. E_NO_ARGS=65
  6. if [ $# -eq 0 ]  # 脚本必须传入参数。
  7. then
  8.   echo "Please invoke this script with one or more command-line arguments."
  9.   exit $E_NO_ARGS
  10. fi
  12. var01=abcdEFGH28ij
  13. echo "var01 = ${var01}"
  14. echo "Length of var01 = ${#var01}"
  15. # 现在我们尝试加入空格。
  16. var02="abcd EFGH28ij"
  17. echo "var02 = ${var02}"
  18. echo "Length of var02 = ${#var02}"
  20. echo "Number of command-line arguments passed to script = ${#@}"
  21. echo "Number of command-line arguments passed to script = ${#*}"
  23. exit 0

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

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

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

摘自 样例 A-7 的例子：

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

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

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

另外一个样例：

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

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

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

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

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

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

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

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

  1. #!/bin/bash
  2. # rfe.sh: 更改文件扩展名。
  3. #
  4. #         rfe old_extension new_extension
  5. #
  6. # 如：
  7. # 将当前目录下所有 *.gif 文件重命名为 *.jpg，
  8. #         rfe gif jpg
  11. E_BADARGS=65
  13. case $# in
  14.   0|1)             # 竖线 | 在这里表示逻辑或关系。
  15.   echo "Usage: `basename $0` old_file_suffix new_file_suffix"
  16.   exit $E_BADARGS  # 如果只有0个或1个参数，那么退出脚本。
  17.   ;;
  18. esac
  21. for filename in *.$1
  22. # 遍历以第一个参数作为后缀名的文件列表。
  23. do
  24.   mv $filename ${filename%$1}$2
  25.   # 删除文件后缀名，增加第二个参数作为后缀名。
  26. done
  28. exit 0

变量扩展 / 替换子串

下面这些结构采用自 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. 使用模式匹配解析任意字符串

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

${var/#Pattern/Replacement}

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

${var/%Pattern/Replacement}

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

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

  1. #!/bin/bash
  2. # var-match.sh:
  3. # 演示在字符串首部或尾部进行模式替换。
  5. v0=abc1234zip1234abc    # 初始值。
  6. echo "v0 = $v0"         # abc1234zip1234abc
  7. echo
  9. # 在字符串首部进行匹配
  10. v1=${v0/#abc/ABCDEF}    # abc1234zip123abc
  11.                         # |-|
  12. echo "v1 = $v1"         # ABCDEF1234zip1234abc
  13.                         # |----|
  15. # 在字符串尾部进行匹配
  16. v2=${v0/%abc/ABCDEF}    # abc1234zip123abc
  17.                         #              |-|
  18. echo "v2 = $v2"         # abc1234zip1234ABCDEF
  19.                         #               |----|
  21. echo
  23. #  --------------------------------------------
  24. #  必须在字符串的最开始或者最末尾的地方进行匹配，
  25. #+ 否则将不会发生替换。
  26. #  --------------------------------------------
  27. v3=${v0/#123/000}       # 虽然匹配到了，但是不在最开始的地方。
  28. echo "v3 = $v3"         # abc1234zip1234abc
  29.                         # 没有替换。
  30. v4=${v0/%123/000}       # 虽然匹配到了，但是不在最末尾的地方。
  31. echo "v4 = $v4"         # abc1234zip1234abc
  32.                         # 没有替换。
  34. exit 0

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

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

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

[^1]: 如果在非交互的脚本中，$parameter 为空，那么程序将会终止，并且返回 错误码 127（意为“找不到命令”）。