Linux工作原理11 Shell脚本
11 shell脚本
如果你能在 shell 中输入命令，你就能编写 shell 脚本。shell 脚本（也称为 Bourne shell 脚本）是写在文件中的一系列命令；shell 会从文件中读取这些命令，就像在终端中输入命令一样。
11.1 shell脚本基础
Bourne shell 脚本一般以下面一行开始，表示 /bin/sh 程序应执行脚本文件中的命令。(确保脚本文件开头没有空白）。
#！/bin/sh
在本书的其他脚本中，你会看到#!你可以在#/bin/sh行后列出任何希望shell执行的命令。例如
#!/bin/sh
#
# Print something, then run ls
echo About to run the ls command.
ls
shell 会忽略 # 字符之后一行的任何内容。使用注释来解释脚本中其他人阅读代码时可能难以理解的部分，或在日后重温代码时唤起自己的记忆。
与 Unix 系统上的任何程序一样，您需要为 shell 脚本文件设置可执行位，但同时也必须设置读取位，以便 shell 能够读取文件。最简单的方法如下：
$ chmod +rx script
这条 chmod 命令允许其他用户读取和执行脚本。如果不想这样，请使用绝对模式 700（有关权限的复习，请参阅第 2.17 节）。
创建 shell 脚本并设置读取和执行权限后，可以将脚本文件放在命令路径中的某个目录下，然后在命令行上运行脚本名称即可。如果脚本位于当前工作目录中，也可以运行 ./script，或者使用完整路径名。
例如，运行名为 myscript 的脚本会导致内核运行 /bin/sh myscript。
了解了基础知识后，让我们来看看 shell 脚本的一些限制。
Shebang，也称为 Hashbang 或 Hash-bang，是一种特殊的语法，通常出现在文本文件的第一行的前两个字符：#!。它的作用是指定脚本应该由哪个解释器来执行。用途如下：
- 明确指定解释器： 不同的脚本语言有不同的解释器（比如 Bash、Python、Perl 等）。Shebang 告诉操作系统，应该使用哪个解释器来运行这个脚本，避免了歧义。
- 直接执行脚本： 有了 Shebang，你就可以直接运行脚本文件，而不需要每次都指定解释器。
- 跨平台兼容性： 不同的系统可能默认的 shell 或解释器不同，Shebang 确保了脚本在不同系统上的可移植性。
Shebang 不一定是 #!/bin/sh；它可以构建为运行系统中任何接受脚本输入的程序，例如 #!/usr/bin/python，以运行 Python 程序。此外，你可能会遇到包含 /usr/bin/env 的不同模式的脚本。例如，你可能会在第一行看到类似 #!/usr/bin/env python 的内容。这会指示env工具运行 python。这样做的原因很简单：env 会在当前的命令路径中查找要运行的命令，因此不需要为可执行文件指定一个标准位置。缺点是命令路径中第一个匹配的可执行文件可能不是你想要的。
11.1.1 Shell 脚本的局限性
Bourne shell 可以相对轻松地操作命令和文件。在第 2.14 节中，我们了解了 shell 重定向输出的方法，这也是 shell 脚本编程的重要元素之一。然而，shell 脚本只是 Unix 编程的一种工具，虽然脚本具有相当强大的功能，但也有其局限性。
shell 脚本的主要优势之一是可以简化和自动执行原本可以在 shell 提示符下执行的任务，例如处理成批文件。但是，如果你想剔除字符串、执行重复的算术计算或访问复杂的数据库，或者如果你想使用函数和复杂的控制结构，你最好使用 Python或awk这样的脚本语言，甚至可能使用 C 这样的编译语言（这一点很重要，所以你会在本章中看到）。
最后，要注意 shell 脚本的大小。shell 脚本要简短。Bourne shell 脚本并不意味着要很大，尽管你无疑会遇到一些庞然大物。
11.2 引用和字面量
在使用 shell 和脚本的过程中，最令人困惑的一点就是不知道什么时候以及为什么要使用引号（quotes）和其他标点符号。假设您想打印 $100 字符串，请执行以下操作：
$ echo $100
00
$ echo "$100"
00
$ echo '$100'
$100
11.2.1 字面量
当你使用引号时，通常是要创建一个字面形式，即 shell 在将其传递到命令行之前不应分析（或试图更改）的字符串。除了刚才例子中的 $ 之外，当你想将 * 字符传递给 grep 等命令而不是让 shell 展开它，以及当你需要在命令中使用分号 (😉 时，也经常会遇到这种情况。
- 在运行命令之前，shell 会查找变量、globs 和其他替换，如果出现这些变量、globs 和其他替换，shell 就会执行这些替换。
- shell 会将替换结果传递给命令。
涉及文字的问题可能很微妙。比方说，你要查找 /etc/passwd 中与正则表达式 r.*t 相匹配的所有条目（也就是说，一行中包含一个r，后面跟着一个 t，这样就能搜索到 root、ruth 和 robot 等用户名）。你可以运行这条命令
$ grep r.*t /etc/passwd
大多数时候都能正常运行，但有时会莫名其妙地失败。如果该目录包含名称为 r.input 和 r.output 的文件，那么 shell 会将 r.*t 扩展为 r.input r.output，并创建此命令：
$ grep r.input r.output /etc/passwd
避免类似问题的关键在于，首先要识别可能给你带来麻烦的字符，然后使用正确的引号来保护这些字符。
11.2.2 单引号
创建字面量并使shell不干扰字符串的最简单方法是用单引号，例如本例中的 grep 和 * 字符：
$ grep 'r.*t' /etc/passwd
两个单引号之间的所有字符，包括空格，都是一个参数。因此，以下命令不起作用，因为它要求 grep 命令在标准输入中搜索字符串 r.*t /etc/passwd（因为 grep 只有一个参数）：
$ grep 'r.*t /etc/passwd'
当需要使用字面意义时，应首先使用单引号，因为这样可以保证 shell 不会尝试任何替换。因此，这通常是一种简洁的语法。不过，有时您需要更大的灵活性，因此可以使用双引号。
11.2.3 双引号
双引号（"）的作用与单引号相同，但 shell 会展开双引号内的变量。运行下面的命令，然后用单引号替换双引号并再次运行，就能看出其中的区别。
$ echo "There is no * in my path: $PATH"
There is no * in my path: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
运行该命令时，请注意 shell 会替换 $PATH，但不会替换 *。
如果在处理大量文本时使用双引号，请考虑使用 here 文档，如第 11.9 节所述。
11.2.4 文字单引号
在 Bourne shell 中使用字面单引号可能会比较麻烦，因为你需要给命令传递一个字面单引号。一种方法是在单引号前加上反斜杠：
$ echo I don\'t like contractions inside shell scripts.
反斜杠和引号必须出现在任何一对单引号之外。像 'don't 这样的字符串会导致语法错误。奇怪的是，你可以将单引号括在双引号内，如下例所示（输出结果与前面的命令相同）：
$ echo "I don't like contractions inside shell scripts."
如果您遇到困难，需要一个不带替换的引用整个字符串的通用规则，请按照以下步骤操作：
- 将'（单引号）改为'''（单引号、反斜杠、单引号、单引号）。
- 用单引号括起整个字符串。
- 因此，你可以引用一个别扭的字符串，如 this isn't a forward slash： \ 这样的字符串：
this isn't a forward slash: \
注意事项：值得重复的是，当你引用一个字符串时，shell 会将引号内的所有内容视为一个参数。因此，a b c 算作三个参数，但 “b c ”只是两个参数。
11.3 特殊变量
大多数shell脚本都能理解命令行参数，并与运行的命令交互。要使您的脚本从简单的命令列表变成更灵活的 shell 脚本程序，您需要知道如何使用特殊的 Bourne shell 变量。这些特殊变量与第 2.8 节中描述的其他 shell 变量一样，只是不能更改某些变量的值。
注意：读完下面几节，你就会明白为什么 shell 脚本在编写过程中会积累许多特殊字符。如果你在试图理解 shell 脚本时，遇到一行看起来完全无法理解的字符，请将其逐个拆开。
11.3.1 位置参数$1, $2
$1、$2 以及所有以非零正整数命名的变量都包含脚本参数或参数值。例如，下面脚本的名称是 pshow：
#!/bin/sh
echo First argument: $1
echo Third argument: $3
试着运行脚本，看看它是如何打印参数的：
$ ./pshow one two three
First argument: one
Third argument: three
shell 内置命令 shift 可以用于参数变量，移除第一个参数（1 美元），并将其余参数向前推进，这样 2 美元就变成了 1 美元，3 美元变成了 2 美元，依此类推。例如，假设下面的脚本名为 shiftex：
#!/bin/sh
echo Argument: $1
shift
echo Argument: $1
shift
echo Argument: $1
像这样运行它，看看它能不能运行：
$ ./shiftex one two three
Argument: one
Argument: two
Argument: three
正如您所看到的，shiftex 通过打印第一个参数、移动其余参数并重复执行，来打印所有三个参数。
11.3.2 参数个数： $#
$# 变量用于保存传递给脚本的参数个数，在循环运行 shift 以选择参数时尤为重要。当 $# 为 0 时，没有参数，因此 $1 为空（有关循环的描述，请参见第 11.6 节）。
11.3.3 所有参数： $@
$@ 变量代表脚本的所有参数，对于将参数传递给脚本内部的命令非常有用。例如，Ghostscript 命令 (gs) 通常又长又复杂。假如你想使用标准输出流，以 150 dpi 的分辨率光栅化 PostScript 文件，同时也为向 gs 传递其他选项留出余地。您可以编写这样的脚本，以允许其他命令行选项：
#!/bin/sh
gs -q -dBATCH -dNOPAUSE -dSAFER -sOutputFile=- -sDEVICE=pnmraw $@
如果 shell 脚本中的某一行过长，导致文本编辑器难以阅读和操作，可以用反斜杠 ( ) 将其分割开来。例如，您可以将前面的脚本修改如下：
#!/bin/sh
gs -q -dBATCH -dNOPAUSE -dSAFER \
-sOutputFile=- -sDEVICE=pnmraw $@
11.3.4 脚本名称： $0
$0 变量用于保存脚本名称，在生成诊断信息时非常有用。例如，脚本需要报告一个存储在 $BADPARM 变量中的无效参数。你可以用下面一行打印诊断信息，这样脚本名称就会出现在错误信息中：
echo $0: bad option $BADPARM
所有诊断性错误信息都应进入标准错误。如第 2.14.1 节所述，2>&1 会将标准错误重定向到标准输出。如果要写入标准错误，可以使用 1>&2 反向操作。在前面的示例中，可以这样做
$ ls / > /dev/null
$ echo $?
0
$ ls /asdfasdf > /dev/null
ls: /asdfasdf: No such file or directory
$ echo $?
1
11.3.5 进程 ID： $$
$$ 变量表示 shell 的进程 ID。
11.3.6 退出代码 $?
$? 变量保存 shell 执行的最后一条命令的退出代码。退出代码是掌握 shell 脚本的关键，将在下面讨论。
11.4 退出代码
当一个 Unix 程序结束时，它会为启动该程序的父进程留下一个退出代码，这是一个数值，也称为错误代码或退出值。当退出代码为零（0）时，通常表示程序运行正常。不过，如果程序出错，它的退出值通常不是 0（但也不总是 0，接下来你会看到）。
shell 会将最后一条命令的退出代码保存在特殊变量 $?中，因此你可以在 shell 提示下查看：
$ ls / > /dev/null
$ echo $?
0
$ ls /asdfasdf > /dev/null
ls: /asdfasdf: No such file or directory
$ echo $?
1
可以看到，成功的命令返回 0，失败的命令返回 1（当然，前提是系统中没有名为 /asdfasdf 的目录）。
如果要使用命令的退出代码，必须在运行命令后立即使用或存储该代码（因为下一条命令会覆盖前一条代码）。例如，如果连续运行两次 echo $?，第二条命令的输出总是 0，因为第一条 echo 命令已成功执行。
在编写 shell 代码时，可能会遇到脚本因错误（如文件名错误）而需要停止的情况。在脚本中使用 exit 1 来终止脚本，并将退出代码 1 传递回运行脚本的父进程。(如果脚本有各种异常退出条件，可以使用不同的非零数字）。
请注意，有些程序（如 diff 和 grep）使用非零退出代码来表示正常情况。例如，grep 在找到与模式匹配的内容时返回 0，找不到时返回 1。对于这些程序来说，退出代码为 1 并不是错误，因此 grep 和 diff 在遇到实际问题时会使用退出代码 2。如果你认为某个程序可能使用非零的退出代码来表示成功，请阅读其手册页面。退出代码通常会在 EXIT VALUE 或 DIAGNOSTICS 部分进行解释。
参考资料
- 软件测试精品书籍文档下载持续更新 https://github.com/china-testing/python-testing-examples 请点赞，谢谢！
- 本文涉及的python测试开发库 谢谢点赞！ https://github.com/china-testing/python_cn_resouce
- python精品书籍下载 https://github.com/china-testing/python_cn_resouce/blob/main/python_good_books.md
- Linux精品书籍下载 https://www.cnblogs.com/testing-/p/17438558.html
11.5 条件
Bourne shell 有特殊的条件结构，包括 if/then/else 和 case 语句。例如，这个带有 if 条件的简单脚本会检查脚本的第一个参数是否为 hi：
#!/bin/sh
if [ $1 = hi ]; then
echo 'The first argument was "hi"'
else
echo -n 'The first argument was not "hi" -- '
echo It was '"'$1'"'
fi
前面脚本中的 if、then、else 和 fi 是 shell 关键字，其他都是命令。这种区别极为重要，因为人们很容易将条件 [ $1 = “hi” ] 误认为是特殊的 shell 语法。事实上，[ 字符是 Unix 系统中的一个实际程序。所有 Unix 系统都有一个名为 [ 的命令，用于对 shell 脚本条件进行测试。这个程序也被称为 test；test 和 [ 的手册页面是一样的。(你很快就会知道 shell 并不总是运行 [ 命令，但现在你可以把它当作一个单独的命令）。
在这里，理解第 11.4 节中解释的退出代码至关重要。让我们看看前面的脚本实际上是如何运行的：
- shell 运行 if 关键字后的命令，并收集该命令的退出代码。
- 如果退出代码为 0，shell 会执行 then 关键字后面的命令，在执行到 else 或 fi 关键字时停止。
- 如果退出代码不是 0，并且有 else 子句，shell 就会执行 else 关键字后面的命令。
- 条件在 fi 处结束。
我们已经确定 if 后面的测试是一条命令，下面来看看分号（;）。它只是 shell 中表示命令结束的常规标记，之所以存在是因为我们把 then 关键字放在了同一行。如果没有分号，shell 会将 then 作为参数传递给[]命令，这往往会导致不易追踪的错误。如果将 then 关键字放在单独一行，就可以避免使用分号，如下所示：
if [ $1 = hi ]
then
echo 'The first argument was "hi"'
fi
11.5.1 空参数列表的解决方法
前面示例中的条件有一个潜在问题，这是由于一个通常被忽视的情况：$1可能是空的，因为用户可能不带参数运行脚本。如果 $1 为空，则测试读数为 [ = hi ]，[ 命令将出错终止。可以用两种常用方法之一将参数用引号括起来来解决这个问题：
if [ "$1" = hi ]; then
if [ x"$1" = x"hi" ]; then
11.5.2 其他测试命令
在测试中使用[]以外的命令有很多可能性。下面是一个使用 grep 的示例：
#!/bin/sh
if grep -q daemon /etc/passwd; then
echo The daemon user is in the passwd file.
else
echo There is a big problem. daemon is not in the passwd file.
fi
11.5.3 elif
还有一个 elif 关键字，可以将 if 条件串联起来，如图所示：
#!/bin/sh
if [ "$1" = "hi" ]; then
echo 'The first argument was "hi"'
elif [ "$2" = "bye" ]; then
echo 'The second argument was "bye"'
else
echo -n 'The first argument was not "hi" and the second was not "bye"-- '
echo They were '"'$1'"' and '"'$2'"'
fi
请记住，控制流只流经第一个成功的条件，因此，如果以参数 hi bye 运行此脚本，只会得到对参数 hi 的确认。
注意：不要过于迷恋 elif，因为 case 结构（将在第 11.5.6 节中介绍）通常更为合适。
11.5.4 逻辑结构体
有两种快速的单行条件结构，你可能会经常看到，它们使用的是 && （“和”）和 || （“或”）语法。&& 结构的工作原理如下
command1 && command2
在这里，shell 运行命令 1，如果退出代码为 0，则同时运行命令 2。
|| 结构类似；如果 || 前的命令返回非零退出代码，shell 就会运行第二条命令。
结构体 && 和 || 经常在 if 测试中使用，在这两种情况下，最后运行的命令的退出代码决定了 shell 如何处理条件。在 && 结构的情况下，如果第一条命令失败，shell 会使用其退出代码来处理 if 语句，但如果第一条命令成功，shell 会使用第二条命令的退出代码来处理条件。在 || 结构的情况下，如果第一条命令成功，shell 会使用第一条命令的退出代码；如果第一条命令失败，shell 会使用第二条命令的退出代码。
例如
#!/bin/sh
if [ "$1" = hi ] || [ "$1" = bye ]; then
echo 'The first argument was "'$1'"'
fi
如果您的条件包括测试命令 ([) （如图所示），您可以使用 -a 和 -o 代替 && 和 || 等命令：
#!/bin/sh
if [ "$1" = hi -o "$1" = bye ]; then
echo 'The first argument was "'$1'"'
fi
将 ! 运算符放在测试之前，可以反转测试（即逻辑 not）。例如
#!/bin/sh
if [ ! "$1" = hi ]; then
echo 'The first argument was not hi'
fi
在这种特殊的比较情况下，你可能会看到 != 作为一种选择，但 ! 可以用于下一节中描述的任何条件测试。
11.5.5 条件测试
我们已经了解了 [ 的工作原理：如果测试为真，则退出代码为 0；如果测试失败，则退出代码为非 0。您还知道如何使用 [ str1 = str2 ] 测试字符串是否相等。不过，请记住 shell 脚本非常适合对整个文件进行操作，因为许多有用的 [ 测试涉及文件属性。例如，下面一行检查 file 是否是普通文件（而不是目录或特殊文件）：
[ -f file ]
在脚本中，你可能会在类似这个循环中看到 -f 测试，它测试当前工作目录中的所有项目（你将在第 11.6 节中了解更多关于循环的内容）：
for filename in *; do
if [ -f $filename ]; then
ls -l $filename
file $filename
else
echo $filename is not a regular file.
fi
done
注意：由于测试命令在脚本中的使用非常广泛，因此许多版本的 Bourne shell（包括 bash）都内置了该命令。这可以加快脚本的运行速度，因为 shell 不必为每个测试运行单独的命令。
测试操作有几十种，一般分为三类：文件测试、字符串测试和算术测试。info 手册包含完整的在线文档，但 test(1) 手册页面是快速参考。以下章节概述了主要测试。(我省略了一些不太常见的测试）。
11.5.5.1文件测试
大多数文件测试，如 -f，都被称为一元操作，因为它们只需要一个参数：要测试的文件。例如，下面是两个重要的文件测试：
- 如果文件存在，-e 返回 true
- 如果文件不是空的，-s 返回 true
如表 11-1 所列，有几种操作可以检测文件类型，即确定文件是普通文件、目录还是某种特殊设备。表 11-2 中还列出了一些检查文件权限的一元操作。(有关权限的概述，请参见第 2.17 节）。
表 11-1: 文件类型操作符
如果测试命令用于符号链接，它测试的是实际链接对象，而不是链接本身（-h 测试除外）。也就是说，如果 link 是指向普通文件的符号链接，[ -f link ] 返回的退出代码为 true (0)。
表 11-2： 文件权限操作符
最后，文件测试中还使用了三种二进制操作符（需要两个文件作为参数的测试），但它们并不常见。请看这条命令，其中包括 -nt（“比...新”）：
[ file1 -nt file2 ]
如果文件 1 的修改日期比文件 2 新，则退出为 true。而 -ot（“比......旧”）操作符的作用正好相反。如果需要检测相同的硬链接，-ef 会比较两个文件，如果它们共享 inode 编号和设备，则返回 true。
11.5.5.2字符串测试
二进制字符串运算符 = 如果操作数相等则返回 true，而 != 运算符如果操作数不相等则返回 true。另外还有两个一元字符串操作：
- -z 如果参数为空，则返回 true（[ -z “” ] 返回 0）
- 如果参数不为空，-n 返回 true（[ -n “” ] 返回 1）
11.5.5.3算术测试
请注意，等号（=）是用来检测字符串是否相等，而不是数字是否相等。因此，[ 1 = 1 ] 返回 0（真），但 [ 01 = 1 ] 返回假。处理数字时，使用 -eq 代替等号：[ 01 -eq 1 ] 返回 true。表 11-3 提供了数字比较运算符的完整列表。
表 11-3： 算术比较运算符
11.5.6 case
case 关键字构成另一种条件结构，对于匹配字符串特别有用。它不执行任何测试命令，因此不评估退出代码。不过，它可以进行模式匹配。这个示例说明了大部分问题：
#!/bin/sh
case $1 in
bye)
echo Fine, bye.
;;
hi|hello)
echo Nice to see you.
;;
what*)
echo Whatever.
;;
*)
echo 'Huh?'
;;
esac
shell 的执行过程如下：
- 脚本将$1与用 ) 字符标出的每个大小写值进行匹配。
- 如果某个 case 值与 $1 匹配，shell 会执行该 case 下面的命令，直到遇到 ;; 时跳转到 esac 关键字。
- 条件以 esac 结束。
对于每个 case 值，可以匹配单个字符串（如上例中的 bye），也可以用 | 匹配多个字符串（如果 $1 等于 hi 或 hello，则 hi|hello 返回 true），还可以使用 * 或 ? 模式 (what*)。要创建一个能捕获指定大小写值以外所有可能值的默认大小写，可使用单个 *，如上例中的最后一个大小写所示。
注意:用双分号 (;😉 结束每个 case，以避免可能出现的语法错误。
11.6 循环
Bourne shell 中有两种循环：for 循环和 while 循环。
11.6.1 for 循环
for 循环（即 “for each ”循环）是最常见的循环。下面是一个例子
#!/bin/sh
for str in one two three four; do
echo $str
done
在这个列表中，for、in、do 和 done 都是 shell 的关键字。shell 会执行以下操作
- 将变量 str 设置为 in 关键字后四个空格分隔值中的第一个（one）。
- 在 do 和 done 之间运行 echo 命令。
- 返回 for 行，将 str 设为下一个值（二），运行 do 和 done 之间的命令，并重复该过程，直到完成 in 关键字后面的值。
该脚本的输出如下
one
two
three
four
11.6.2 while 循环
Bourne shell 的 while 循环使用退出代码，就像 if 条件一样。例如，本脚本迭代 10 次：
#!/bin/sh
FILE=/tmp/whiletest.$$;
echo firstline > $FILE
while tail -10 $FILE | grep -q firstline; do
# add lines to $FILE until tail -10 $FILE no longer prints "firstline"
echo -n Number of lines in $FILE:' '
wc -l $FILE | awk '{print $1}'
echo newline >> $FILE
done
rm -f $FILE
这里，grep -q firstline 的退出代码就是测试结果。只要退出代码不为零（在本例中，当字符串 firstline 不再出现在 $FILE 的最后 10 行中），循环就会退出。
你可以用 break 语句中断 while 循环。Bourne shell 也有一个 until 循环，它的工作原理与 while 相同，只是当遇到零退出代码而不是非零退出代码时，它会中断循环。尽管如此，你应该不需要经常使用 while 和 until 循环。事实上，如果您发现需要使用 while，您可能应该使用更适合您任务的语言，如 Python 或 awk。
11.7 命令替换
Bourne shell 可以将命令的标准输出重定向到 shell 自己的命令行。也就是说，你可以使用一条命令的输出作为另一条命令的参数，也可以用 $() 将命令的输出存储在 shell 变量中。
本例将命令输出存储在 FLAGS 变量中。第二行粗体代码显示了命令替换。
#!/bin/sh
FLAGS=$(grep ^flags /proc/cpuinfo | sed 's/.*://' | head -1)
echo Your processor supports:
for f in $FLAGS; do
case $f in
fpu) MSG="floating point unit"
;;
3dnow) MSG="3DNOW graphics extensions"
;;
mtrr) MSG="memory type range register"
;;
*) MSG="unknown"
;;
esac
echo $f: $MSG
done
这个示例有些复杂，因为它演示了在命令替换中既可以使用单引号，也可以使用管道。grep 命令的结果被发送到 sed 命令（有关 sed 的更多信息，请参见第 11.10.3 节），它会删除任何与表达式 .*: 匹配的内容，而 sed 命令的结果则被传给 head。
使用命令替换很容易过量。例如，不要在脚本中使用 $(ls)，因为使用 shell 扩展 * 更快。另外，如果要对查找命令得到的多个文件名调用命令，可以考虑使用 xargs 管道而不是命令替换，或者使用 -exec 选项（第 11.10.4 节将讨论这两个选项）。
注意: 命令替换的传统语法是用反斜线 (``) 将命令括起来，这在许多 shell 脚本中都能看到。$()语法是一种较新的形式，但它是 POSIX 标准，通常更易于读写（对人类而言）。
11.8 临时文件管理
有时需要创建一个临时文件来收集输出信息，供后面的命令使用。创建此类文件时，应确保文件名足够明确，以防其他程序意外写入。有时，在文件名中使用简单的 shell PID ($$) 就能奏效，但当你需要确保不会出现冲突时，mktemp 等实用程序往往是更好的选择。
下面介绍如何使用 mktemp 命令创建临时文件名。该脚本会显示最近两秒内发生的设备中断：
#!/bin/sh
TMPFILE1=$(mktemp /tmp/im1.XXXXXX)
TMPFILE2=$(mktemp /tmp/im2.XXXXXX)
cat /proc/interrupts > $TMPFILE1
sleep 2
cat /proc/interrupts > $TMPFILE2
diff $TMPFILE1 $TMPFILE2
rm -f $TMPFILE1 $TMPFILE2
mktemp 的参数是一个模板。mktemp 命令将 XXXXXX 转换为一组唯一的字符，并以该名称创建一个空文件。请注意，该脚本使用变量名来存储文件名，因此如果要更改文件名，只需更改一行即可。
注意:并非所有 Unix 系统都带有 mktemp。如果遇到移植问题，最好为操作系统安装 GNU coreutils 软件包。
使用临时文件的脚本的一个常见问题是，如果脚本被中止，临时文件可能会被留下。在上例中，在执行第二个 cat 命令前按下 CTRL-C 会在 /tmp 中留下一个临时文件。尽可能避免这种情况。相反，可以使用 trap 命令创建一个信号处理程序，捕捉 CTRL-C 产生的信号，并删除临时文件，如本处理程序：
#!/bin/sh
TMPFILE1=$(mktemp /tmp/im1.XXXXXX)
TMPFILE2=$(mktemp /tmp/im2.XXXXXX)
trap "rm -f $TMPFILE1 $TMPFILE2; exit 1" INT
--snip--
必须在处理程序中使用 exit 来显式结束脚本的执行，否则 shell 将在运行信号处理程序后继续照常运行。
注意:不需要为 mktemp 提供参数；如果不提供参数，模板将以 /tmp/tmp. 前缀开始。
11.9 Here 文档
假设您要打印一大段文本或将大量文本传送给另一条命令。与其使用多个 echo 命令，不如使用 shell 的 here 文档功能，如下脚本所示：
#!/bin/sh
DATE=$(date)
cat <<EOF
Date: $DATE
The output above is from the Unix date command.
It's not a very interesting command.
EOF
<
注意 here 文档中的 shell 变量 $DATE。shell 可以扩展 here 文档中的 shell 变量，这在打印包含许多变量的报告时特别有用。
执行结果：
$ sh test.sh
Date: Sat Jul 27 03:26:58 PM CST 2024
The output above is from the Unix date command.
It's not a very interesting command.
11.10 重要的 shell 脚本实用程序
有几个程序在 shell 脚本中特别有用。某些实用程序，如 basename，只有在与其他程序一起使用时才真正实用，因此在 shell 脚本之外并不常见。不过，awk 等其他工具在命令行中也非常有用。
11.10.1 basename
如果需要去除文件名中的扩展名或删除完整路径名中的目录，请使用 basename 命令。请在命令行中尝试以下示例，了解该命令如何运行：
$ basename example.html .html
$ basename /usr/local/bin/example
在这两种情况下，basename 都会返回 example。第一条命令删除了 example.html 中的 .html 后缀，第二条命令删除了完整路径名中的目录。
本例演示了如何在脚本中使用 basename 将 GIF 图像文件转换为 PNG 格式：
#!/bin/sh
for file in *.gif; do
# exit if there are no files
if [ ! -f $file ]; then
exit
fi
b=$(basename $file .gif)
echo Converting $b.gif to $b.png...
giftopnm $b.gif | pnmtopng > $b.png
done
11.10.2 awk
awk 命令不是一个简单的单一用途命令，它实际上是一种功能强大的编程语言。遗憾的是，由于被 Python 等更大型的语言所取代，awk 的使用已成为一门失传的艺术。
关于 awk 的书有很多，包括 Alfred V. Aho、Brian W. Kernighan 和 Peter J. Weinberger 合著的《AWK 编程语言》（Addison-Wesley，1988 年）。尽管如此，很多很多人使用 awk 只做一件事--从输入流中选取一个字段，就像下面这样：
$ ls -l | awk '{print $5}'
这条命令打印 ls 输出的第五个字段（文件大小）。结果是一个文件大小列表。
11.10.3 sed
sed （“流编辑器 stream editor”）程序是一个自动文本编辑器，它接收输入流（文件或标准输入），根据某些表达式对其进行修改，并将结果打印到标准输出。在许多方面，sed 与最初的 Unix 文本编辑器 ed 相似。它有几十种操作、匹配工具和寻址功能。与 awk 一样，关于 sed 的书已经写了整整一本书，其中包括 Arnold Robbins（O'Reilly，2002 年）所著的《sed & awk Pocket Reference》（第 2 版）这两本书。
虽然 sed 是一个庞大的程序，深入分析超出了本书的范围，但我们还是很容易了解它是如何工作的。一般来说，sed 将地址和操作作为一个参数。地址是一组行，命令决定如何处理这些行。
sed 的一个常见任务是用正则表达式（参见第 2.5.1 节）替换某些文本，如下所示
sed 's/exp/text/'
如果要将 /etc/passwd 每行的第一个冒号替换为 %，并将结果发送到标准输出，可以这样做：
$ sed 's/:/%/' /etc/passwd
要替换 /etc/passwd 中的所有冒号，可在操作末尾添加 g（全局）修饰符，如下所示：
$ sed 's/:/%/g' /etc/passwd
下面是一条按行操作的命令；它读取/etc/passwd，删除第三行至第六行，并将结果发送到标准输出：
$ sed 3,6d /etc/passwd
在这个例子中，3,6 是地址（行的范围），d 是操作（删除）。如果省略地址，sed 将对输入流中的所有行进行操作。最常见的两种 sed 操作可能是 s（搜索和替换）和 d。
也可以使用正则表达式作为地址。这条命令会删除任何与正则表达式 exp 匹配的行：
$ sed '/exp/d'
在所有这些示例中，sed 都会写入标准输出，这也是目前最常见的用法。在没有文件参数的情况下，sed 会从标准输入中读取，这种模式在 shell 管道中经常会遇到。
11.10.4 xargs
当你需要在大量文件上运行一条命令时，命令或 shell 可能会回应说它的缓冲区无法容纳所有参数。使用 xargs 可以解决这个问题，它可以在标准输入流中的每个文件名上运行一条命令。
许多人将 xargs 与查找命令一起使用。例如，下面的脚本可以帮助你确认当前目录树中每个以 .gif 结尾的文件实际上都是 GIF 图像：
$ find . -name '*.gif' -print | xargs file
在这里，xargs 运行的是 file 命令。不过，这种调用方式可能会导致错误，或给系统带来安全问题，因为文件名可能包含空格和换行符。在编写脚本时，请使用以下形式，将 find 输出分隔符和 xargs 参数分隔符从换行符改为 NULL 字符：
$ find . -name '*.gif' -print0 | xargs -0 file
xargs 会启动大量进程，因此如果你有一大串文件，就不要指望它有多好的性能了。
如果目标文件有可能以单破折号 (-) 开头，则可能需要在 xargs 命令末尾添加两个破折号 (--)。双破折号 (--) 会告诉程序，后面的参数是文件名，而不是选项。不过，请记住，并非所有程序都支持使用双破折号。
在使用 find 时，有一个 xargs 的替代选项：-exec 选项。不过，这个选项的语法有点麻烦，因为你需要用括号{}来代替文件名，并用;来表示命令的结束。下面是仅使用 find 执行上述任务的方法：
$ find . -name '*.gif' -exec file {}\；
11.10.5 expr
如果需要在 shell 脚本中使用算术运算，expr 命令可以提供帮助（甚至可以进行一些字符串运算）。例如，命令 expr 1 + 2 可以打印出 3（运行 expr --help 查看全部运算列表）。
expr 命令是一种笨拙、缓慢的数学运算方式。如果你发现自己经常使用它，你可能应该使用像 Python 这样的语言，而不是 shell 脚本。
11.10.6 exec
exec 命令是 shell 的一个内置功能，它可以用你在 exec 后命名的程序替换当前的 shell 进程。它执行第 1 章中描述的 exec() 系统调用。该功能旨在节省系统资源，但请记住，它是没有返回的；当你在 shell 脚本中运行 exec 命令时，脚本和运行脚本的 shell 都会消失，取而代之的是新命令。
要在 shell 窗口测试这一点，请尝试运行 exec cat。按下 CTRL-D 或 CTRL-C 终止 cat 程序后，窗口应该会消失，因为其子进程已不复存在。
11.11 子shell
如果您需要稍微改变一下 shell 中的环境，但又不想永久改变。你可以使用 shell 变量来改变和恢复环境的一部分（如路径或工作目录），但这种方法很笨拙。更简单的方法是使用子壳，这是一个全新的 shell 进程，你可以创建它来运行一两个命令。新 shell 拥有原 shell 环境的副本，当新 shell 退出时，你对其 shell 环境所做的任何更改都会消失，而初始 shell 则可以正常运行。
要使用子 shell，请将子 shell 要执行的命令放在括号中。例如，下面一行会在 uglydir 中执行命令 uglyprogram，并保留原始 shell：
$ (cd uglydir; uglyprogram)
这个例子展示了如何在路径中添加一个可能会引起问题的组件，作为永久性更改：
$ (PATH=/usr/confusing:$PATH; uglyprogram)
使用子壳对环境变量进行一次性修改是一项非常常见的任务，甚至有一种内置语法可以避免使用子壳：
$ PATH=/usr/confusing:$PATH uglyprogram
管道和后台进程也可以使用子壳。下面的示例使用 tar 将 orig 中的整个目录树存档，然后将存档解压到新目录 target 中，这样就有效地复制了 orig 中的文件和文件夹（这很有用，因为它保留了所有权和权限，而且通常比使用 cp -r 等命令更快）：
$ tar cf - orig | (cd target; tar xvf -)
警告:运行此类命令前，请仔细检查目标目录是否存在，是否与 orig 目录完全分开（在脚本中，可以使用 [ -d orig -a ! orig -ef target ] 进行检查）。
11.12 在脚本中包含其他文件
如果需要在 shell 脚本中包含其他文件的代码，请使用点（.）操作符。例如，运行文件 config.sh 中的命令：
. config.sh
这种包含方法也称为源文件，对于读取变量（例如共享配置文件中的变量）和其他类型的定义非常有用。这与执行另一个脚本不同；当你运行一个脚本（作为命令）时，它会在一个新的 shell 中启动，除了输出和退出代码外，你不能得到任何其他信息。
11.13 读取用户输入
读取命令从标准输入中读取一行文本，并将文本存储到变量中。例如，以下命令将输入内容存储在 $var 中：
$ read var
这条内置 shell 命令可以与本书未提及的其他 shell 功能结合使用。使用 read，你可以创建简单的交互，例如提示用户输入，而不是要求他们列出命令行上的所有内容，还可以在危险操作前创建 “你确定吗？”的确认信息。
11.14 何时（不）使用 shell 脚本
shell 的功能非常丰富，很难将其重要元素浓缩到一章中。如果你对 shell 的其他功能感兴趣，可以参考一些有关 shell 编程的书籍，如 Stephen G. Kochan 和 Patrick Wood 合著的《Unix Shell Programming》（第 3 版）（SAMS 出版社，2003 年），或 Brian W. Kernighan 和 Rob Pike 合著的《UNIX 编程环境》（Prentice Hall，1984 年）中有关 shell 脚本的讨论。
不过，到了一定程度（尤其是当你开始过度使用内置读取功能时），你就必须问问自己，你是否还在使用适合这项工作的工具。记住 shell 脚本最擅长做什么：操作简单的文件和命令。如前所述，如果你发现自己写的东西看起来很复杂，尤其是涉及到复杂的字符串或算术运算时，不要害怕，可以参考 Python或awk等脚本语言。
