第十二章 命令替换

命令替换重新指定一个[^1]或多个命令的输出。其实就是将命令的输出导到另外一个地方^2。

命令替换的通常形式是（`...` ），即用反引号引用命令。

1. script_name=`basename $0`
2. echo "The name of this script is $scirpt_name."

命令的输出可以作为另一个命令的参数，也可以赋值给一个变量。甚至在 for 循环中可以用输出产生参数表。

1. rm `cat filename`   # "filename" 中包含了一系列需要被删除的文件名。
2. #
3. # S.C. 指出这样写可能会导致出现 "arg list too long" 的错误。
4. # 更好的写法应该是 xargs rm -- < filename
5. # （ -- 可以在 "filename" 文件名以 "-" 为开头时仍旧正常执行 ）

7. textfile_listing=`ls *.txt`
8. # 变量中包含了当前工作目录下所有的名为 *.txt 的文件。
9. echo $textfile_listing

11. textfile_listing2=$(ls *.txt)   # 命令替换的另一种形式。
12. echo $textfile_listing2
13. # 结果相同。

15. # 这样将一系列文件名赋值给一个单一字符串可能会出现换行。
16. #
17. # 而更加安全的方式是将这一系列文件存入数组。
18. #      shopt -s nullglob    # 设置后，如果没有匹配到文件，那么变量会被赋值为空。
19. #      textfile_listing=( *.txt )
20. #
21. # 感谢 S.C.

命令替换本质上是调用了一个 子进程 来执行。

命令替换有可能会出现 字符分割 的情况。

`` 1. COMMANDecho a b` # 2个参数：a和b

1. COMMAND "echo a b" # 1个参数："a b"

2. COMMAND echo # 没有参数

3. COMMAND "echo" # 一个空参数

4. 感谢 S.C.

   ```

但即使不存在字符分割的情况，使用命令替换也会出现丢失尾部换行符的情况。

`` 1. # cd "pwd`" # 你是不是认为这条语句在任何情况下都不会出现错误？ 2. # 但事实却不是这样的。

1. mkdir 'dir with trailing newline

2. '

3. cd 'dir with trailing newline

4. '

5. cd "pwd" # Bash 会出现如下错误提示：

6. bash: cd: /tmp/file with trailing newline: No such file or directory

7. cd "$PWD" # 这样写是对的。

8. old_tty_setting=$(stty -g) # 保存旧的设置。

9. echo "Hit a key "
10. stty -icanon -echo # 禁用终端的 canonical 模式。

11. 同时禁用 echo。

12. key=$(dd bs=1 count=1 2> /dev/null) # 使用 'dd' 获得键值。
13. stty "$old_tty_setting" # 恢复旧的设置。
14. echo "You hit ${#key} key." # ${#variable} 表示 $variable 中的字符个数。

16. 除了按下回车键外，其余情况都会输出 "You hit 1 key."

17. 按下回车键会输出 "You hit 0 key."

18. 因为唯一的换行符在命令替换中被丢失了。

19. 这段代码摘自 Stéphane Chazelas。

    ```

使用 echo 输出未被引用的命令代换的变量时会删掉尾部的换行。这可能会导致非常不好的情况出现。

`` 1. dir_listing=ls -l` 2. echo $dir_listing # 未被引用

1. 你希望会出现按行显示出文件列表。

2. 但是，你却看到了：

3. total 3 -rw-rw-r-- 1 bozo bozo 30 May 13 17:15 1.txt -rw-rw-r-- 1 bozo

4. bozo 51 May 15 20:57 t2.sh -rwxr-xr-x 1 bozo bozo 217 Mar 5 21:13 wi.sh

5. 所有换行都消失了。

6. echo "$dir_listing" # 被引用

7. -rw-rw-r-- 1 bozo 30 May 13 17:15 1.txt

8. -rw-rw-r-- 1 bozo 51 May 15 20:57 t2.sh

9. -rwxr-xr-x 1 bozo 217 Mar 5 21:13 wi.sh

   ```

你甚至可以使用 重定向 或者 cat 命令把一个文件的内容通过命令代换赋值给一个变量。

1. variable1=`<file1`      # 将 "file1" 的内容赋值给 variable1。
2. variable2=`cat file2`   # 将 "file2" 的内容赋值给 variable2。
3. # 使用 cat 命令会开一个新进程，因此执行速度会比重定向慢。

5. # 需要注意的是，这些变量中可能包含一些空格或者控制字符。

7. # 无需显示的赋值给一个变量。
8. echo "` <$0`"           # 输出脚本自身。

1. #  摘录自系统文件 /etc/rc.d/rc.sysinit
2. #+ （Red Hat Linux 发行版）

5. if [ -f /fsckoptions ]; then
6. fsckoptions=`cat /fsckoptions`
7. ...
8. fi
9. #
10. #
11. if [ -e "/proc/ide/${disk[$device]}/media" ] ; then
12. hdmedia=`cat /proc/ide/${disk[$device]}/media`
13. ...
14. fi
15. #
16. #
17. if [ ! -n "`uname -r | grep -- "-"`" ]; then
18. ktag="`cat /proc/version`"
19. ...
20. fi
21. #
22. #
23. if [ $usb = "1" ]; then
24. sleep 5
25. mouseoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=02"`
26. kbdoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=01"`
27. ...
28. fi

尽量不要将一大段文字赋值给一个变量，除非你有足够的理由。也绝不要将一个二进制文件的内容赋值给一个变量。

样例 12-1. 蠢蠢的脚本

``` 1. #!/bin/bash 2. # stupid-script-tricks.sh: 不要在自己的电脑上尝试。 3. # 摘自 "Stupid Script Tricks" 卷一。

1. exit 99 ### 如果你有胆，就注释掉这行。:)

2. dangerous_variable=cat /boot/vmlinuz # 压缩的 Linux 内核。

3. echo "string-length of \$dangerous_variable = ${#dangerous_variable}"

4. $dangerous_variable 的长度为 794151

5. （更新版本的内核可能更大。）

6. 与 'wc -c /boot/vmlinuz' 的结果不同。

7. echo "$dangerous_variable"

8. 不要作死。否则脚本会挂起。

9. 将二进制文件的内容赋值给一个变量没有任何意义。

10. exit 0 ```

尽管脚本会挂起，但并不会出现缓存溢出的情况。而这正是像 Bash 这样的解释型语言相比起编译型语言能够提供更多保护的一个例子。

命令替换允许将 循环 的输出结果赋值给一个变量。这其中的关键在于循环内部的 echo 命令。

样例 12-2. 将循环的输出结果赋值给变量

1. #!/bin/bash
2. # csubloop.sh: 将循环的输出结果赋值给变量。

4. variable1=`for i in 1 2 3 4 5
5. do
6. echo -n "$i"                 #  在这里，'echo' 命令非常关键。
7. done`

9. echo "variable1 = $variable1"  # variable1 = 12345

12. i=0
13. variable2=`while [ "$i" -lt 10 ]
14. do
15. echo -n "$i"                 # 很关键的 'echo'。
16. let "i += 1"                 # i 自增。
17. done`

19. echo "variable2 = $variable2"  # variable2 = 0123456789

21. # 这个例子表明可以在变量声明时嵌入循环。

23. exit 0

命令替换能够让 Bash 做更多的事情。而这仅仅需要在书写程序或者脚本时将结果输出到标准输出 stdout 中，然后将这些输出结果赋值给变量即可。

``` 1. #include

1. / "Hello, world." C program /

2. int main()

3. {
4. printf( "Hello, world.\n" );
5. return (0);
6. } ```

1. bash$ gcc -0 hello hello.c

``` 1. #!/bin/bash 2. # hello.sh

1. greeting=./hello
2. echo $greeting ```

1. bash$ sh hello.sh 2. Hello, world.

在命令替换中，你可以使用 $(...) 来替代反引号。

``` 1. output=$(sed -n /"$1"/p $file) # 摘自 "grp.sh"。

1. 将文本文件的内容赋值给一个变量。

2. File_contents1=$(cat $file1)
3. File_contents2=$(<$file2) # 这么做也是可以的。 ```

$(...) 和反引号在处理双反斜杠上有所不同。

`` 1. bash$ echoecho \`

1. bash$ echo $(echo \)
2. \ ```

$(...) 允许嵌套。[^3]

1. word_count=$( wc -w $(echo * | awk '{print $8}') )

样例 12-3. 寻找变位词（anagram）

``` 1. #!/bin/bash 2. # agram2.sh 3. # 嵌套命令替换的例子。

1. 其中使用了作者写的工具包 "yawl" 中的 "anagram" 工具。

2. http://ibiblio.org/pub/Linux/libs/yawl-0.3.2.tar.gz

3. http://bash.deta.in/yawl-0.3.2.tar.gz

4. E_NOARGS=86

5. E_BADARG=87

6. MINLEN=7

7. if [ -z "$1" ]

8. then
9. echo "Usage $0 LETTERSET"
10. exit $E_NOARGS # 脚本需要命令行参数。
11. elif [ ${#1} -lt $MINLEN ]
12. then
13. echo "Argument must have at least $MINLEN letters."
14. exit $E_BADARG

15. fi

16. FILTER='.......' # 至少需要7个字符。

17. 1234567

18. Anagrams=( $(echo $(anagram $1 | grep $FILTER) ) )

19. $( $( 嵌套命令集 ) )

20. ( 赋值给数组 )

21. echo

22. echo "${#Anagrams[*]} 7+ letter anagrams found"
23. echo
24. echo ${Anagrams[0]} # 第一个变位词。
25. echo ${Anagrams[1]} # 第二个变位词。

26. 以此类推。

27. echo "${Anagrams[*]}" # 将所有变位词在一行里面输出。

28. 可以配合后面的数组章节来理解上面的代码。

29. 建议同时查看另一个寻找变位词的脚本 agram.sh。

30. exit $? ```

以下是包含命令替换的样例：

1. 样例 11-8
2. 样例 11-27
3. 样例 9-16
4. 样例 16-3
5. 样例 16-22
6. 样例 16-17
7. 样例 16-54
8. 样例 11-14
9. 样例 11-11
10. 样例 16-32
11. 样例 20-8
12. 样例 A-16
13. 样例 29-3
14. 样例 16-47
15. 样例 16-48
16. 样例 16-49

[^1]: 在命令替换中可以使用外部系统命令，内建命令 甚至是 脚本函数。

[^3]: 事实上，使用反引号进行嵌套也是可行的。但是 John Default 提醒到需要将内部的反引号进行转义。

1. word_count=` wc -w \`echo * | awk ‘{print $8}’\` `