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 参数替换
                                                              • 第十一章 循环与分支

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

                                                                                                                      第十二章 命令替换

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

                                                                                                                      # 第十二章 命令替换

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

                                                                                                                      命令替换的通常形式是(`...`),即用反引号引用命令。

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

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

                                                                                                                      rm `cat filename`   # "filename" 中包含了一系列需要被删除的文件名。
                                                                                                                      #
                                                                                                                      # S.C. 指出这样写可能会导致出现 "arg list too long" 的错误。
                                                                                                                      # 更好的写法应该是 xargs rm -- < filename
                                                                                                                      # ( -- 可以在 "filename" 文件名以 "-" 为开头时仍旧正常执行 )
                                                                                                                      
                                                                                                                      textfile_listing=`ls *.txt`
                                                                                                                      # 变量中包含了当前工作目录下所有的名为 *.txt 的文件。
                                                                                                                      echo $textfile_listing
                                                                                                                      
                                                                                                                      textfile_listing2=$(ls *.txt)   # 命令替换的另一种形式。
                                                                                                                      echo $textfile_listing2
                                                                                                                      # 结果相同。
                                                                                                                      
                                                                                                                      # 这样将一系列文件名赋值给一个单一字符串可能会出现换行。
                                                                                                                      #
                                                                                                                      # 而更加安全的方式是将这一系列文件存入数组。
                                                                                                                      #      shopt -s nullglob    # 设置后,如果没有匹配到文件,那么变量会被赋值为空。
                                                                                                                      #      textfile_listing=( *.txt )
                                                                                                                      #
                                                                                                                      # 感谢 S.C.
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21

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

                                                                                                                      caution 命令替换有可能会出现 字符分割open in new window 的情况。

                                                                                                                      COMMAND `echo a b`     # 2个参数:a和b
                                                                                                                      
                                                                                                                      COMMAND "`echo a b`"   # 1个参数:"a b"
                                                                                                                      
                                                                                                                      COMMAND `echo`         # 没有参数
                                                                                                                      
                                                                                                                      COMMAND "`echo`"       # 一个空参数
                                                                                                                      
                                                                                                                      
                                                                                                                      # 感谢 S.C.
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10

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

                                                                                                                      # cd "`pwd`"  # 你是不是认为这条语句在任何情况下都不会出现错误?
                                                                                                                      # 但事实却不是这样的。
                                                                                                                      
                                                                                                                      mkdir 'dir with trailing newline
                                                                                                                      '
                                                                                                                      
                                                                                                                      cd 'dir with trailing newline
                                                                                                                      '
                                                                                                                      
                                                                                                                      cd "`pwd`"  # Bash 会出现如下错误提示:
                                                                                                                      # bash: cd: /tmp/file with trailing newline: No such file or directory
                                                                                                                      
                                                                                                                      cd "$PWD"   # 这样写是对的。
                                                                                                                      
                                                                                                                      
                                                                                                                      
                                                                                                                      
                                                                                                                      
                                                                                                                      old_tty_setting=$(stty -g)   # 保存旧的设置。
                                                                                                                      echo "Hit a key "
                                                                                                                      stty -icanon -echo           # 禁用终端的 canonical 模式。
                                                                                                                                                   # 同时禁用 echo。
                                                                                                                      key=$(dd bs=1 count=1 2> /dev/null)   # 使用 'dd' 获得键值。
                                                                                                                      stty "$old_tty_setting"      # 恢复旧的设置。
                                                                                                                      echo "You hit ${#key} key."  # ${#variable} 表示 $variable 中的字符个数。
                                                                                                                      #
                                                                                                                      # 除了按下回车键外,其余情况都会输出 "You hit 1 key."
                                                                                                                      # 按下回车键会输出 "You hit 0 key."
                                                                                                                      # 因为唯一的换行符在命令替换中被丢失了。
                                                                                                                      
                                                                                                                      # 这段代码摘自 Stéphane Chazelas。
                                                                                                                      
                                                                                                                      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

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

                                                                                                                      dir_listing=`ls -l`
                                                                                                                      echo $dir_listing     # 未被引用
                                                                                                                      
                                                                                                                      # 你希望会出现按行显示出文件列表。
                                                                                                                      
                                                                                                                      # 但是,你却看到了:
                                                                                                                      # total 3 -rw-rw-r-- 1 bozo bozo 30 May 13 17:15 1.txt -rw-rw-r-- 1 bozo
                                                                                                                      # bozo 51 May 15 20:57 t2.sh -rwxr-xr-x 1 bozo bozo 217 Mar 5 21:13 wi.sh
                                                                                                                      
                                                                                                                      # 所有换行都消失了。
                                                                                                                      
                                                                                                                      
                                                                                                                      echo "$dir_listing"   # 被引用
                                                                                                                      # -rw-rw-r--    1 bozo       30 May 13 17:15 1.txt
                                                                                                                      # -rw-rw-r--    1 bozo       51 May 15 20:57 t2.sh
                                                                                                                      # -rwxr-xr-x    1 bozo      217 Mar  5 21:13 wi.sh
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16

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

                                                                                                                      variable1=`<file1`      # 将 "file1" 的内容赋值给 variable1。
                                                                                                                      variable2=`cat file2`   # 将 "file2" 的内容赋值给 variable2。
                                                                                                                                              # 使用 cat 命令会开一个新进程,因此执行速度会比重定向慢。
                                                                                                                      
                                                                                                                      # 需要注意的是,这些变量中可能包含一些空格或者控制字符。
                                                                                                                      
                                                                                                                      # 无需显示的赋值给一个变量。
                                                                                                                      echo "` <$0`"           # 输出脚本自身。
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      #  摘录自系统文件 /etc/rc.d/rc.sysinit
                                                                                                                      #+ (Red Hat Linux 发行版)
                                                                                                                      
                                                                                                                      
                                                                                                                      if [ -f /fsckoptions ]; then
                                                                                                                              fsckoptions=`cat /fsckoptions`
                                                                                                                      ...
                                                                                                                      fi
                                                                                                                      #
                                                                                                                      #
                                                                                                                      if [ -e "/proc/ide/${disk[$device]}/media" ] ; then
                                                                                                                                   hdmedia=`cat /proc/ide/${disk[$device]}/media`
                                                                                                                      ...
                                                                                                                      fi
                                                                                                                      #
                                                                                                                      #
                                                                                                                      if [ ! -n "`uname -r | grep -- "-"`" ]; then
                                                                                                                             ktag="`cat /proc/version`"
                                                                                                                      ...
                                                                                                                      fi
                                                                                                                      #
                                                                                                                      #
                                                                                                                      if [ $usb = "1" ]; then
                                                                                                                          sleep 5
                                                                                                                          mouseoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=02"`
                                                                                                                          kbdoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=01"`
                                                                                                                      ...
                                                                                                                      fi
                                                                                                                      
                                                                                                                      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

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

                                                                                                                      样例 12-1. 蠢蠢的脚本

                                                                                                                      #!/bin/bash
                                                                                                                      # stupid-script-tricks.sh: 不要在自己的电脑上尝试。
                                                                                                                      # 摘自 "Stupid Script Tricks" 卷一。
                                                                                                                      
                                                                                                                      exit 99  ### 如果你有胆,就注释掉这行。:)
                                                                                                                      
                                                                                                                      dangerous_variable=`cat /boot/vmlinuz`   # 压缩的 Linux 内核。
                                                                                                                      
                                                                                                                      echo "string-length of \$dangerous_variable = ${#dangerous_variable}"
                                                                                                                      # $dangerous_variable 的长度为 794151
                                                                                                                      # (更新版本的内核可能更大。)
                                                                                                                      # 与 'wc -c /boot/vmlinuz' 的结果不同。
                                                                                                                      
                                                                                                                      # echo "$dangerous_variable"
                                                                                                                      # 不要作死。否则脚本会挂起。
                                                                                                                      
                                                                                                                      
                                                                                                                      
                                                                                                                      # 将二进制文件的内容赋值给一个变量没有任何意义。
                                                                                                                      
                                                                                                                      exit 0
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21

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

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

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

                                                                                                                      #!/bin/bash
                                                                                                                      # csubloop.sh: 将循环的输出结果赋值给变量。
                                                                                                                      
                                                                                                                      variable1=`for i in 1 2 3 4 5
                                                                                                                      do
                                                                                                                        echo -n "$i"                 #  在这里,'echo' 命令非常关键。
                                                                                                                      done`
                                                                                                                      
                                                                                                                      echo "variable1 = $variable1"  # variable1 = 12345
                                                                                                                      
                                                                                                                      
                                                                                                                      i=0
                                                                                                                      variable2=`while [ "$i" -lt 10 ]
                                                                                                                      do
                                                                                                                        echo -n "$i"                 # 很关键的 'echo'。
                                                                                                                        let "i += 1"                 # i 自增。
                                                                                                                      done`
                                                                                                                      
                                                                                                                      echo "variable2 = $variable2"  # variable2 = 0123456789
                                                                                                                      
                                                                                                                      # 这个例子表明可以在变量声明时嵌入循环。
                                                                                                                      
                                                                                                                      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

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

                                                                                                                      #include <stdio.h>
                                                                                                                      
                                                                                                                      /*  "Hello, world." C program  */
                                                                                                                      
                                                                                                                      int main()
                                                                                                                      {
                                                                                                                        printf( "Hello, world.\n" );
                                                                                                                        return (0);
                                                                                                                      }
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      bash$ gcc -0 hello hello.c
                                                                                                                      
                                                                                                                      1
                                                                                                                      #!/bin/bash
                                                                                                                      # hello.sh
                                                                                                                      
                                                                                                                      greeting=`./hello`
                                                                                                                      echo $greeting
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      bash$ sh hello.sh
                                                                                                                      Hello, world.
                                                                                                                      
                                                                                                                      1
                                                                                                                      2

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

                                                                                                                      output=$(sed -n /"$1"/p $file)   # 摘自 "grp.sh"。
                                                                                                                      
                                                                                                                      # 将文本文件的内容赋值给一个变量。
                                                                                                                      File_contents1=$(cat $file1)
                                                                                                                      File_contents2=$(<$file2)        # 这么做也是可以的。
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5

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

                                                                                                                      bash$ echo `echo \\`
                                                                                                                      
                                                                                                                      
                                                                                                                      bash$ echo $(echo \\)
                                                                                                                      \
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5

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

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

                                                                                                                      样例 12-3. 寻找变位词(anagram)

                                                                                                                      #!/bin/bash
                                                                                                                      # agram2.sh
                                                                                                                      # 嵌套命令替换的例子。
                                                                                                                      
                                                                                                                      # 其中使用了作者写的工具包 "yawl" 中的 "anagram" 工具。
                                                                                                                      # http://ibiblio.org/pub/Linux/libs/yawl-0.3.2.tar.gz
                                                                                                                      # http://bash.deta.in/yawl-0.3.2.tar.gz
                                                                                                                      
                                                                                                                      E_NOARGS=86
                                                                                                                      E_BADARG=87
                                                                                                                      MINLEN=7
                                                                                                                      
                                                                                                                      if [ -z "$1" ]
                                                                                                                      then
                                                                                                                        echo "Usage $0 LETTERSET"
                                                                                                                        exit $E_NOARGS         # 脚本需要命令行参数。
                                                                                                                      elif [ ${#1} -lt $MINLEN ]
                                                                                                                      then
                                                                                                                        echo "Argument must have at least $MINLEN letters."
                                                                                                                        exit $E_BADARG
                                                                                                                      fi
                                                                                                                      
                                                                                                                      
                                                                                                                      
                                                                                                                      FILTER='.......'         # 至少需要7个字符。
                                                                                                                      #       1234567
                                                                                                                      Anagrams=( $(echo $(anagram $1 | grep $FILTER) ) )
                                                                                                                      #          $(     $(        嵌套命令集        ) )
                                                                                                                      #        (              赋值给数组                )
                                                                                                                      
                                                                                                                      echo
                                                                                                                      echo "${#Anagrams[*]}  7+ letter anagrams found"
                                                                                                                      echo
                                                                                                                      echo ${Anagrams[0]}      # 第一个变位词。
                                                                                                                      echo ${Anagrams[1]}      # 第二个变位词。
                                                                                                                                               # 以此类推。
                                                                                                                      
                                                                                                                      # echo "${Anagrams[*]}"  # 将所有变位词在一行里面输出。
                                                                                                                      
                                                                                                                      # 可以配合后面的数组章节来理解上面的代码。
                                                                                                                      
                                                                                                                      # 建议同时查看另一个寻找变位词的脚本 agram.sh。
                                                                                                                      
                                                                                                                      exit $?
                                                                                                                      
                                                                                                                      1
                                                                                                                      2
                                                                                                                      3
                                                                                                                      4
                                                                                                                      5
                                                                                                                      6
                                                                                                                      7
                                                                                                                      8
                                                                                                                      9
                                                                                                                      10
                                                                                                                      11
                                                                                                                      12
                                                                                                                      13
                                                                                                                      14
                                                                                                                      15
                                                                                                                      16
                                                                                                                      17
                                                                                                                      18
                                                                                                                      19
                                                                                                                      20
                                                                                                                      21
                                                                                                                      22
                                                                                                                      23
                                                                                                                      24
                                                                                                                      25
                                                                                                                      26
                                                                                                                      27
                                                                                                                      28
                                                                                                                      29
                                                                                                                      30
                                                                                                                      31
                                                                                                                      32
                                                                                                                      33
                                                                                                                      34
                                                                                                                      35
                                                                                                                      36
                                                                                                                      37
                                                                                                                      38
                                                                                                                      39
                                                                                                                      40
                                                                                                                      41
                                                                                                                      42
                                                                                                                      43
                                                                                                                      44

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

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

                                                                                                                      1. 在命令替换中可以使用外部系统命令,内建命令open in new window 甚至是 脚本函数open in new window。 ↩︎

                                                                                                                      2. 从技术的角度来讲,命令替换实际上是获得了命令输出到标准输出的结果,然后通过赋值号将结果赋值给一个变量。 ↩︎

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

                                                                                                                        word_count=` wc -w \`echo * | awk '{print $8}'\` `
                                                                                                                        ↩︎

                                                                                                                      edit icon编辑此页open in new window
                                                                                                                      上次编辑于: 2022/4/27 15:33:00
                                                                                                                      贡献者: clay-wangzhi
                                                                                                                      上一页
                                                                                                                      第十一章 循环与分支
                                                                                                                      下一页
                                                                                                                      第十三章 算术扩展
                                                                                                                      备案号:冀ICP备2021007336号
                                                                                                                      Copyright © 2023 LinuxStory