第六章 Linux文本处理（Linux三剑客grep、sed和awk）
在 Linux 中，文本处理无非是对文本内容做查看、修改等操作。本章将介绍Linux中常用的文本处理命令，以及被称为Linux三剑客的 grep、sed 和 awk 命令。
有读者可能会问，处理文本内容，用 Vim 编辑器不是很好吗？Vim 允许我们使用键盘、鼠标来对文本内容进行交互性地修改，但在某些场景中，我们可能需要实现对文本内容做自动化的处理，而不是手工处理。
因此，了解一些常用的 Linux 文本处理命令是非常有必要的。
一、Linux 连接合并文件内容（cat命令）
Linux cat命令：连接文件并打印输出到标准输出设备
cat 命令可以用来显示文本文件的内容（类似于 DOS 下的 type 命令），也可以把几个文件内容附加到另一个文件中，即连接合并文件。
关于此命令，有人认为写 cat 命令的人是因为喜欢猫，因此给此命令起名为"cat"，其实不然，cat 是 concatenate（连接、连续）的简写。
cat 命令的基本格式如下：
[root@localhost ~]# cat [选项] 文件名
或者
[root@localhost ~]# cat 文件1 文件2 > 文件3
这两种格式中，前者用于显示文件的内容，常用选项及各自的含义如表 1 所示；而后者用于连接合并文件。
| 选项 | 含义 |
|---|---|
| -A | 相当于 -vET 选项的整合，用于列出所有隐藏符号； |
| -E | 列出每行结尾的回车符 $； |
| -n | 对输出的所有行进行编号； |
| -b | 同 -n 不同，此选项表示只对非空行进行编号。 |
| -T | 把 Tab 键 ^I 显示出来； |
| -V | 列出特殊字符； |
| -s | 当遇到有连续 2 行以上的空白行时，就替换为 1 行的空白行。 |
| [表 1 cat 命令常用选项及含义] |
注意，cat 命令用于查看文件内容时，不论文件内容有多少，都会一次性显示。如果文件非常大，那么文件开头的内容就看不到了。不过 Linux 可以使用PgUp+上箭头组合键 向上翻页，但是这种翻页是有极限的，如果文件足够长，那么还是无法看全文件的内容。
**因此，cat 命令适合查看不太大的文件。**当然，在 Linux 中是可以使用其他的命令或方法来查看大文件的，我们以后再来学习。
【例 1】cat 命令本身非常简单，我们可以直接查看文件的内容。例如：
[root@localhost ~]# cat anaconda-ks.cfg
Kickstart file automatically generated by anaconda.
#version=DEVEL
install
cdrom
lang zh一CN.UTF-8
...省略部分内容...
而如果使用**"-n" 选项** ，则会显示行号。例如:
[root@localhost ~]# cat -n anaconda-ks.cfg
1 # Kickstart file automatically generated by anaconda.
2
3
4 #version=DEVEL
5 install
6 cdrom
...省略部分内容...
如果使用**"-A" 选项** ，则相当于使用了**"-vET" 选项** ，**可以查看文本中的所有隐藏符号，包括回车符（$）、Tab 键（^I）等。**例如：
[root@localhost ~]# cat -A anaconda-ks.cfg
Kickstart file automatically generated by anaconda.$
#version=DEVEL$
install**$**
cdrom**$**
...省略部分内容...
【例 2】将文件 file1.txt 和 file2.txt 的内容合并后输出到文件 file3.txt 中。
[root@localhost base]# ls
file1.txt file2.txt
[root@localhost base]# cat file1.txt
http://c.biancheng.net(file1.txt)
[root@localhost base]# cat file2.txt
is great(file2.txt)
[root@localhost base]# cat file1.txt file2.txt > file3.txt
[root@localhost base]# more file3.txt
#more 命令可查看文件中的内容http://c.biancheng.net(file1.txt)
is great(file2.txt)
[root@localhost base]# ls
file1.txt file2.txt file3.txt
二、Linux 分屏显示文件内容（more命令）
Linux more命令：分屏显示文件内容
在讲解 cat 命令时，我们留下了一个疑问，即当使用 cat 命令查看文件内容时，如果文件过大，以至使用PgUp+上箭头组合键 向上翻页也无法看全文件中的内容，该怎么办呢？这就需要使用 more 命令。
more 命令可以分页显示文本文件的内容，使用者可以逐页阅读文件中内容，此命令的基本格式如下：
[root@localhost ~]# more [选项] 文件名
more 命令比较简单，一般不用什么选项，对于表 1 中所列的选项，读者只需看到认识即可。
| 选项 | 含义 |
|---|---|
| -f | 计算行数时，以实际的行数，而不是自动换行过后的行数。 |
| -p | 不以卷动的方式显示每一页，而是先清除屏幕后再显示内容。 |
| -c | 跟 -p 选项相似，不同的是先显示内容再清除其他旧资料。 |
| -s | 当遇到有连续两行以上的空白行时，就替换为一行的空白行。 |
| -u | 不显示下引号（根据环境变量 TERM 指定的终端而有所不同）。 |
| +n | 从第 n 行开始显示文件内容，n 代表数字。 |
| -n | 一次显示的行数，n 代表数字。 |
| [表 1 more 命令选项及含义] |
more 命令的执行会打开一个交互界面，因此读者有必要了解一些交互命令，常用的交互命令如表 2 所示。
| 交互指令 | 功能 |
|---|---|
| h 或 ？ | 显示 more 命令交互命令帮助。 |
| q 或 Q | 退出 more。 |
| v | 在当前行启动一个编辑器。 |
| :f | 显示当前文件的文件名和行号。 |
| !<命令> 或 :!<命令> | 在子Shell中执行指定命令。 |
| 回车键 | 向下移动一行。 |
| 空格键 | 向下移动一页。 |
| Ctrl+l | 刷新屏幕。 |
| = | 显示当前行的行号。 |
| ' | 转到上一次搜索开始的地方。 |
| Ctrf+f | 向下滚动一页。 |
| . | 重复上次输入的命令。 |
| / 字符串 | 搜索指定的字符串。 |
| d | 向下移动半页。 |
| b | 向上移动一页。 |
| [表 2 more 命令交互指令及功能] |
【例 1】用分页的方式显示 anaconda-ks.cfg 文件的内容。
[root@localhost ~]# more anaconda-ks.cfg
Kickstart file automatically generated by anaconda.
#version=DEVEL
install
cdrom
...省略部分内容...
--More--(69%)
#在这里执行交互命令即可
【例 2】显示文件 anaconda-ks.cfg 的内容，每 10 行显示一屏，同时清除屏幕，使用以下命令：
[root@localhost ~]# more**-c -10** anaconda-ks.cfg
#省略输出内容。
三、Linux 显示文件内容（head命令）
Linux head命令：显示文件开头的内容
head 命令可以显示指定文件前若干行的文件内容，其基本格式如下：
[root@localhost ~]# head [选项] 文件名
该命令常用选项以及各自的含义，如表 1 所示。
| 选项 | 含义 |
|---|---|
| -n K | 这里的 K 表示行数，该选项用来显示文件前 K 行的内容；如果使用 "-K" 作为参数，则表示除了文件最后 K 行外，显示剩余的全部内容。 |
| -c K | 这里的 K 表示字节数，该选项用来显示文件前 K 个字节的内容；如果使用 "-K"，则表示除了文件最后 K 字节的内容，显示剩余全部内容。 |
| -v | 显示文件名； |
| [表 1 head 命令常用选项及含义] |
注意，如不设置显示的具体行数，则默认显示 10 行的文本数据 。
【例 1】基本用法。
[root@localhost ~]# head anaconda-ks.cfg
head 命令默认显示文件的开头 10 行内容。如果想显示指定的行数，则只需使用 "-n" 选项即可，例如：
[root@localhost ~]# head -n 20 anaconda-ks.cfg
这是显示文件的开头 20 行内容，也可以直接写 "-行数"，例如：
[root@localhost ~]# head -20 anaconda-ks.cfg
四、Linux 查看文件内容（less命令）
Linux less命令：查看文件内容
less 命令的作用和 more 十分类似，都用来浏览文本文件中的内容，不同之处在于，使用 more 命令浏览文件内容时，只能不断向后翻看，而使用 less 命令浏览，既可以向后翻看，也可以向前翻看。
不仅如此，为了方面用户浏览文本内容，less 命令还提供了以下几个功能：
- 使用光标键可以在文本文件中前后（左后）滚屏；
- 用行号或百分比作为书签浏览文件；
- 提供更加友好的检索、高亮显示等操作；
- 兼容常用的字处理程序（如 Vim、Emacs）的键盘操作；
- 阅读到文件结束时，less 命令不会退出；
- 屏幕底部的信息提示更容易控制使用，而且提供了更多的信息。
less 命令的基本格式如下：
[root@localhost ~]# less [选项] 文件名
此命令可用的选项以及各自的含义如表 1 所示。
| 选项 | 选项含义 |
|---|---|
| -N | 显示每行的行号。 |
| -S | 行过长时将超出部分舍弃。 |
| -e | 当文件显示结束后，自动离开。 |
| -g | 只标志最后搜索到的关键同。 |
| -Q | 不使用警告音。 |
| -i | 忽略搜索时的大小写。 |
| -m | 显示类似 more 命令的百分比。 |
| -f | 强迫打开特殊文件，比如外围设备代号、目录和二进制文件。 |
| -s | 显示连续空行为一行。 |
| -b <缓冲区大小> | 设置缓冲区的大小。 |
| -o <文件名> | 将 less 输出的内容保存到指定文件中。 |
| -x <数字> | 将【Tab】键显示为规定的数字空格。 |
| [表 1 less 命令选项及含义] |
在使用 less 命令查看文件内容的过程中，和 more 命令一样，也会进入交互界面，因此需要读者掌握一些常用的交互指令，如表 2 所示。
| 交互指令 | 功能 |
|---|---|
| /字符串 | 向下搜索"字符串"的功能。 |
| ?字符串 | 向上搜索"字符串"的功能。 |
| n | 重复*前一个搜索（与 / 成 ? 有关）。 |
| N | 反向重复前一个搜索（与 / 或 ? 有关）。 |
| b | 向上移动一页。 |
| d | 向下移动半页。 |
| h 或 H | 显示帮助界面。 |
| q 或 Q | 退出 less 命令。 |
| y | 向上移动一行。 |
| 空格键 | 向下移动一页。 |
| 回车键 | 向下移动一行。 |
| 【PgDn】键 | 向下移动一页。 |
| 【PgUp】键 | 向上移动一页。 |
| Ctrl+f | 向下移动一页。 |
| Ctrl+b | 向上移动一页。 |
| Ctrl+d | 向下移动一页。 |
| Ctrl+u | 向上移动半页。 |
| j | 向下移动一行。 |
| k | 向上移动一行。 |
| G | 移动至最后一行。 |
| g | 移动到第一行。 |
| ZZ | 退出 less 命令。 |
| v | 使用配置的编辑器编辑当前文件。 |
| [ | 移动到本文档的上一个节点。 |
| ] | 移动到本文档的下一个节点。 |
| p | 移动到同级的上一个节点。 |
| u | 向上移动半页。 |
| [表 2 less 交互指令及功能] |
【例 1】使用 less 命令查看 /boot/grub/grub.cfg 文件中的内容。
[root@localhost ~]# less /boot/grub/grub.cfg
#DO NOT EDIT THIS FILE
#It is automatically generated by grub-mkconfig using templates from /etc/grub.d and settings from /etc/default/grub
BEGIN /etc/grub.d/00_header
if [ -s $prefix/grubenv ]; then
set have_grubenv=true
load_env
fi
set default="0"
if [ "$ {prev_saved_entry}" ]; then
set saved_entry="${prev_saved_entry}"
save_env saved_entry
set prev_saved_entry= save_env prev_saved_entry
set boot_once=true
fi
function savedefault {
if [ -z "${boot_once}" ]; then
:
可以看到，less 在屏幕底部显示一个冒号（：），等待用户输入命令，比如说，用户想向下翻一页，可以按空格键；如果想向上翻一页，可以按 b 键。
五、Linux 显示文件结尾内容（tail命令）
Linux tail命令：显示文件结尾的内容
tail 命令和 head 命令正好相反，它用来查看文件末尾的数据，其基本格式如下：
[root@localhost ~]# tail [选项] 文件名
此命令常用的选项及含义如表 1 所示。
| 选项 | 含义 |
|---|---|
| -n K | 这里的 K 指的是行数，该选项表示输出最后 K 行，在此基础上，如果使用 -n +K，则表示从文件的第 K 行开始输出。 |
| -c K | 这里的 K 指的是字节数，该选项表示输出文件最后 K 个字节的内容，在此基础上，使用 -c +K 则表示从文件第 K 个字节开始输出。 |
| -f | 输出文件变化后新增加的数据。 |
| [表 1 tail 命令选项及含义] |
【例 1】查看 /etc/passwd 文件最后 3 行的数据内容。
[root@localhost ~]# tail**-n 3** /etc/passwd
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
oprofile:x:16:16:Special user account to be used by OProfile:/var/lib/oprofile:/sbin/nologin
tcpdump:x:72:72::/:/sbin/nologin
除此之外，还可以采用如下这种形式：
[root@localhost ~]# tail -3 /etc/passwd
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
oprofile:x:16:16:Special user account to be used by OProfile:/var/lib/oprofile:/sbin/nologin
tcpdump:x:72:72::/:/sbin/nologin
可以看到，使用 tail -n 3 /etc/passwd 命令和 tail -3 /etc/passwd 的效果是一样的。
【例 2】查看 /etc/passwd 文件末尾 100 个字节的数据内容。
[root@localhost ~]# tail -c 100 /etc/passwd
cpdump:x:72:72::/:/sbin/nologin
【例 3】 监听文件的新増内容。tail 命令有一种比较有趣的用法，可以使用 "-f" 选项来监听文件的新増内容，例如：
[root@localhost ~]#tail -f anaconda-ks.cfg
@server-platform
@server-policy
pax
oddjob
sgpio
certmonger
pam_krb5
krb5-workstation
perl-DBD-SQLite
%end
#光标不会退出文件，而会一直监听在文件的结尾处
这条命令会显示文件的最后 10 行内容，而且光标不会退出命令，每隔一秒会检查一下文件是否增加新的内容，如果增加就追加到原来的输出结果后面并显示。因此，这时如果向文件中追加一些数据（需要开启一个新终端）：
[root@localhost ~]# echo 2222222222 >> anaconda-ks.cfg
[root@localhost ~]# echo 3333333333 >> anaconda-ks.cfg
#在新终端中通过echo命令向文件中追加数据
那么，在原始的正在监听的终端中，会看到如下信息：
[root@localhost ~]# tail -f anaconda-ks.cfg @server-platforin
@server-policy
pax
oddjob
sgpio
certmonger
pam_krb5
krb5-workstation
perl-DBD-SQLite
%end2222222222
33333333333
#在文件的结尾处监听到了新増数据
如果想终止输出，按【Ctrl+c】键中断 tail 命令即可。
六、Linux重定向（输入输出重定向）
我们知道，Linux 中标准的输入设备默认指的是键盘，标准的输出设备默认指的是显示器。而本节所要介绍的输入、输出重定向，完全可以从字面意思去理解，也就是：
- 输入重定向：指的是重新指定设备来代替键盘作为新的输入设备；
- 输出重定向：指的是重新指定设备来代替显示器作为新的输出设备。
通常是用文件或命令的执行结果来代替键盘作为新的输入设备，而新的输出设备通常指的就是文件。
1、Linux输入重定向
对于输入重定向来说，其需要用到的符号以及作用如表 1 所示。
| 命令符号格式 | 作用 |
|---|---|
| 命令 < 文件 | 将指定文件作为命令的输入设备 |
| 命令 << 分界符 | 表示从标准输入设备（键盘）中读入，直到遇到分界符才停止（读入的数据不包括分界符），这里的分界符其实就是自定义的字符串 |
| 命令 < 文件 1 > 文件 2 | 将文件 1 作为命令的输入设备，该命令的执行结果输出到文件 2 中。 |
| [表 1 输入重定向中用到的符号及作用] |
【例 1】
默认情况下，cat 命令会接受标准输入设备（键盘）的输入，并显示到控制台，但如果用文件代替键盘作为输入设备，那么该命令会以指定的文件作为输入设备，并将文件中的内容读取并显示到控制台。
以 /etc/passwd 文件（存储了系统中所有用户的基本信息）为例，执行如下命令：
[root@localhost ~]# cat /etc/passwd
#这里省略输出信息，读者可自行查看
[root@localhost ~]# cat < /etc/passwd
#输出结果同上面命令相同
注意，虽然执行结果相同，但第一行代表是以键盘作为输入设备，而第二行代码是以 /etc/passwd 文件作为输入设备。
【例 2】
[root@localhost ~]# cat << 0
>c.biancheng.net
>Linux
>0
Linux
可以看到，当指定了 0 作为分界符之后，只要不输入 0，就可以一直输入数据。
【例 3】
首先，新建文本文件 a.tx，然后执行如下命令：
[root@localhost ~]# cat a.txt
[root@localhost ~]# cat < /etc/passwd > a.txt
[root@localhost ~]# cat a.txt
#输出了和 /etc/passwd 文件内容相同的数据
可以看到，通过重定向 /etc/passwd 作为输入设备，并输出重定向到 a.txt，最终实现了将 /etc/passwd 文件中内容复制到 a.txt 中。
2、Linux输出重定向
相较于输入重定向，我们使用输出重定向的频率更高。并且，和输入重定向不同的是，输出重定向还可以细分为标准输出重定向和错误输出重定向两种技术。
例如，使用 ls 命令分别查看两个文件的属性信息，但其中一个文件是不存在的，如下所示：
[root@localhost ~]# touch demo1.txt
[root@localhost ~]# ls -l demo1.txt
-rw-rw-r--. 1 root root 0 Oct 12 15:02 demo1.txt
[root@localhost ~]# ls -l demo2.txt <-- 不存在的文件
ls: cannot access demo2.txt: No such file or directory
上述命令中，demo1.txt 是存在的，因此正确输出了该文件的一些属性信息，这也是该命令执行的标准输出信息；而 demo2.txt 是不存在的，因此执行 ls 命令之后显示的报错信息，是该命令的错误输出信息。
再次强调，要想把原本输出到屏幕上的数据转而写入到文件中，这两种输出信息就要区别对待。
在此基础上，**标准输出重定向和错误输出重定向又分别包含清空写入和追加写入两种模式。**因此，对于输出重定向来说，其需要用到的符号以及作用如表 2 所示。
| 命令符号格式 | 作用 |
|---|---|
| 命令 > 文件 | 将命令执行的标准输出结果重定向输出到指定的文件中，如果该文件已包含数据，会清空原有数据，再写入新数据。 |
| 命令 2> 文件 | 将命令执行的错误输出结果重定向到指定的文件中，如果该文件中已包含数据，会清空原有数据，再写入新数据。 |
| 命令 >> 文件 | 将命令执行的标准输出结果重定向输出到指定的文件中，如果该文件已包含数据，新数据将写入到原有内容的后面。 |
| 命令 2>> 文件 | 将命令执行的错误输出结果重定向到指定的文件中，如果该文件中已包含数据，新数据将写入到原有内容的后面。 |
| 命令 >> 文件 2>&1 或者 命令 &>> 文件 | 将标准输出或者错误输出写入到指定文件，如果该文件中已包含数据，新数据将写入到原有内容的后面。注意，第一种格式中，最后的 2>&1 是一体的，可以认为是固定写法。 |
| [表 2 输出重定向用到的符号及作用] |
【例 4】新建一个包含有 "Linux" 字符串的文本文件 Linux.txt，以及空文本文件 demo.txt，然后执行如下命令：
[root@localhost ~]# cat Linux.txt > demo.txt
[root@localhost ~]# cat demo.txt
Linux
[root@localhost ~]# cat Linux.txt > demo.txt
[root@localhost ~]# cat demo.txt
Linux <--这里的 Linux 是清空原有的 Linux 之后，写入的新的 Linux
[root@localhost ~]# cat Linux.txt >> demo.txt
[root@localhost ~]# cat demo.txt
Linux
Linux <--以追加的方式，新数据写入到原有数据之后
[root@localhost ~]# cat b.txt > demo.txt
cat: b.txt: No such file or directory <-- 错误输出信息依然输出到了显示器中
[root@localhost ~]# cat b.txt 2> demo.txt
[root@localhost ~]# cat demo.txt
cat: b.txt: No such file or directory <--清空文件，再将错误输出信息写入到该文件中
[root@localhost ~]# cat b.txt 2>> demo.txt
[root@localhost ~]# cat demo.txt
cat: b.txt: No such file or directory
cat: b.txt: No such file or directory <--追加写入错误输出信息
七、Linux grep（Linux 三剑客之一）
Linux grep命令详解：查找文件内容
很多时候，我们并不需要列出文件的全部内容，而是从文件中找到包含指定信息的那些行，要实现这个目的，可以使用 grep 命令。
grep 命令作为 Linux 文本处理三剑客的一员，另外两个是 sed 和 awk，它们会在后续详细介绍。
grep 命令的由来可以追溯到 UNIX 诞生的早期，在 UNIX 系统中，搜索的模式（patterns）被称为正则表达式（regular expressions），为了要彻底搜索一个文件，有的用户在要搜索的字符串前加上前缀 global（全面的），一旦找到相匹配的内容，用户就像将其输出（print）到屏幕上，而将这一系列的操作整合到一起就是global regular expressions print，而这也就是 grep 命令的全称。
grep命令能够在一个或多个文件中，搜索某一特定的字符模式（也就是正则表达式），此模式可以是单一的字符、字符串、单词或句子。
正则表达式是描述一组字符串的一个模式，正则表达式的构成模仿了数学表达式，通过使用操作符将较小的表达式组合成一个新的表达式。正则表达式可以是一些纯文本文字，也可以是用来产生模式的一些特殊字符。为了进一步定义一个搜索模式，grep 命令支持如表 1 所示的这几种正则表达式的元字符（也就是通配符）。
| 通配符 | 功能 |
|---|---|
| c* | 将匹配 0 个（即空白）或多个字符 c（c 为任一字符）。 |
| . | 将匹配任何一个字符，且只能是一个字符。 |
| [xyz] | 匹配方括号中的任意一个字符。 |
| [^xyz] | 匹配除方括号中字符外的所有字符。 |
| ^ | 锁定行的开头。 |
| $ | 锁定行的结尾。 |
| [表 1 正则表达式的通配符] |
需要注意的是，在基本正则表达式中，如通配符 *、+、{、|、( 和 )等，已经失去了它们原本的含义，而若要恢复它们原本的含义，则要在之前添加反斜杠 \，如 \*、\+、\{、\|、\( 和 \)。
grep 命令是用来在每一个文件或中（或特定输出上）搜索特定的模式，**当使用 grep 时，包含指定字符模式的每一行内容，都会被打印（显示）到屏幕上，**但是使用 grep 命令并不改变文件中的内容。
grep 命令的基本格式如下：
[root@localhost ~]# grep [选项] 模式 文件名
**这里的模式，要么是字符（串），要么是正则表达式。**而此命令常用的选项以及各自的含义如表 2 所示。
| 选项 | 含义 |
|---|---|
| -c | 仅列出文件中包含模式的行数。 |
| -i | 忽略模式中的字母大小写。 |
| -l | 列出带有匹配行的文件名。 |
| -n | 在每一行的最前面列出行号。 |
| -v | 列出没有匹配模式的行。 |
| -w | 把表达式当做一个完整的单字符来搜寻，忽略那些部分匹配的行。 |
| [表 2 grep 命令常用选项及含义] |
注意，如果是搜索多个文件，grep 命令的搜索结果只显示文件中发现匹配模式的文件名；而如果搜索单个文件，grep 命令的结果将显示每一个包含匹配模式的行。
【例 1】假设有一份 emp.data 员工清单，现在要搜索此文件，找出职位为 CLERK 的所有员工，则执行命令如下：
[root@localhost ~]# grep CLERK emp.data
#忽略输出内容
而在此基础上，如果只想知道职位为 CLERK 的员工的人数，可以使用**"-c"选项**，执行命令如下：
[root@localhost ~]# grep -c CLERK emp.data
#忽略输出内容
【例 2】搜索 emp.data 文件，使用正则表达式找出以 78 开头的数据行，执行命令如下：
[root@localhost ~]# grep ^78 emp.data
#忽略输出内容
grep 命令的功能非常强大，通过利用它的不同选项以及变化万千的正则表达式，可以获取任何我们所需要的信息。本节所介绍的 grep 命令，只介绍了它的一部分基础知识，比如说，grep 命令可用的选项还有很多，且用法也五花八门，不过对于初学者来说，本节所介绍的内容已经足以应付多数 Linux 系统的日常工作了。
八、Linux sed（Linux 三剑客之一）
Linux sed命令完全攻略
我们知道，Vim 采用的是交互式文本编辑模式，你可以用键盘命令来交互性地插入、删除或替换数据中的文本。但本节要讲的 sed 命令不同，它采用的是流编辑模式，最明显的特点是，在 sed 处理数据之前，需要预先提供一组规则，sed 会按照此规则来编辑数据。
sed 会根据脚本命令来处理文本文件中的数据，这些命令要么从命令行中输入，要么存储在一个文本文件中，此命令执行数据的顺序如下：
- 每次仅读取一行内容；
- 根据提供的规则命令匹配并修改数据。注意，sed 默认不会直接修改源文件数据，而是会将数据复制到缓冲区中，修改也仅限于缓冲区中的数据；
- 将执行结果输出。
当一行数据匹配完成后，它会继续读取下一行数据，并重复这个过程，直到将文件中所有数据处理完毕。
sed 命令的基本格式如下：
[root@localhost ~]# sed [选项] [脚本命令] 文件名
该命令常用的选项及含义，如表 1 所示。
| 选项 | 含义 |
|---|---|
| -e 脚本命令 | 该选项会将其后跟的脚本命令添加到已有的命令中。 |
| -f 脚本命令文件 | 该选项会将其后文件中的脚本命令添加到已有的命令中。 |
| -n | 默认情况下，sed 会在所有的脚本指定执行完毕后，会自动输出处理后的内容，而该选项会屏蔽启动输出，需使用 print 命令来完成输出。 |
| -i | 此选项会直接修改源文件，要慎用。 |
| [表 1 sed 命令常用选项及含义] |
成功使用 sed 命令的关键在于掌握各式各样的脚本命令及格式，它能帮你定制编辑文件的规则。
1、sed脚本命令
（1）sed s 替换脚本命令
此命令的基本格式为：
[address]s/pattern/replacement/flags
其中，address 表示指定要操作的具体行，pattern 指的是需要替换的内容，replacement 指的是要替换的新内容。
关于指定具体操作行（address）的用法，这里先不做解释，文章后续会对其做详细介绍。
此命令中常用的 flags 标记如表 2 所示。
| flags 标记 | 功能 |
|---|---|
| n | 1~512 之间的数字，表示指定要替换的字符串出现第几次时才进行替换，例如，一行中有 3 个 A，但用户只想替换第二个 A，这是就用到这个标记； |
| g | 对数据中所有匹配到的内容进行替换，如果没有 g，则只会在第一次匹配成功时做替换操作。例如，一行数据中有 3 个 A，则只会替换第一个 A； |
| p | 会打印与替换命令中指定的模式匹配的行。此标记通常与 -n 选项一起使用。 |
| w file | 将缓冲区中的内容写到指定的 file 文件中； |
| & | 用正则表达式匹配的内容进行替换； |
| \n | 匹配第 n 个子串，该子串之前在 pattern 中用 \(\) 指定。 |
| \ | 转义（转义替换部分包含：&、\ 等）。 |
| [表 2 sed s命令flags标记及功能] |
比如，可以指定 sed 用新文本替换第几处模式匹配的地方：
[root@localhost ~]# sed 's /test/trial/2' data4.txt
This is a test of the trial script.
This is the second test of the trial script.
可以看到，使用数字 2 作为标记的结果就是，sed 编辑器只替换每行中第 2 次出现的匹配模式。
如果要用新文件替换所有匹配的字符串，可以使用 g 标记：
[root@localhost ~]# sed 's /test/trial/g' data4.txt
This is a trial of the trial script.
This is the second trial of the trial script.
我们知道，-n 选项 会禁止 sed 输出，但 p 标记会输出修改过的行，将二者匹配使用的效果就是只输出被替换命令修改过的行，例如：
[root@localhost ~]# cat data5.txt
This is a test line.
This is a different line.
[root@localhost ~]#sed -n 's /test/trial/p' data5.txt
This is a trial line.
w 标记会将匹配后的结果保存到指定文件中，比如：
[root@localhost ~]# sed 's /test/trial/w test.txt' data5.txt
This is a trial line.
This is a different line.
[root@localhost ~]#cat test.txt
This is a trial line.
在使用 s 脚本命令时，替换类似文件路径的字符串会比较麻烦，**需要将路径中的正斜线进行转义，**例如：
[root@localhost ~]# sed 's/\/bin\/bash/\/bin\/csh/' /etc/passwd
（2）sed d 替换脚本命令
此命令的基本格式为：
[address]d
如果**需要删除文本中的特定行，可以用 d 脚本命令，它会删除指定行中的所有内容。**但使用该命令时要特别小心，如果你忘记指定具体行的话，文件中的所有内容都会被删除，举个例子：
[root@localhost ~]# cat data1.txt
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy dog
[root@localhost ~]#sed 'd' data1.txt
#什么也不输出，证明成了空文件
当和指定地址一起使用时，删除命令显然能发挥出大的功用。可以从数据流中删除特定的文本行。
address 的具体写法后续会做详细介绍，这里只给大家举几个简单的例子：
- 通过行号指定，比如删除 data6.txt 文件内容中的第 3 行： [root@localhost ~]# cat data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
[root@localhost ~]# sed '3d' data6.txt
This is line number 1.
This is line number 2.
This is line number 4.
- 或者通过特定行区间指定，比如删除 data6.txt 文件内容中的第 2、3行： [root@localhost ~]# sed '2,3d' data6.txt
This is line number 1.
This is line number 4.
- 也可以使用两个文本模式来删除某个区间内的行 ，但这么做时要小心，你指定的第一个模式会"打开"行删除功能，第二个模式会"关闭"行删除功能 ，因此，sed 会删除两个指定行之间的所有行（包括指定的行），例如： [root@localhost ~]#sed '/1/,/3/d' data6.txt
#删除第 1~3 行的文本数据
This is line number 4.
- 或者通过特殊的文件结尾字符，比如删除 data6.txt 文件内容中第 3 行开始的所有的内容： [root@localhost ~]#sed '3,$d' data6.txt
This is line number 1.
This is line number 2.
在此强调，在默认情况下 sed 并不会修改原始文件，这里被删除的行只是从 sed 的输出中消失了，原始文件没做任何改变。
（3）sed a 和 i 脚本命令
**a 命令表示在指定行的后面附加一行，i 命令表示在指定行的前面插入一行，**这里之所以要同时介绍这 2 个脚本命令，因为它们的基本格式完全相同，如下所示：
[address]a（或 i）\新文本内容
下面分别就这 2 个命令，给读者举几个例子。比如说，将一个新行插入到数据流第三行前，执行命令如下：
[root@localhost ~]# sed '3i \
> This is an inserted line.' data6.txt
This is line number 1.
This is line number 2.
This is an inserted line.
This is line number 3.
This is line number 4.
再比如说，将一个新行附加到数据流中第三行后，执行命令如下：
[root@localhost ~]# sed '3a \
> This is an appended line.' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is an appended line.
This is line number 4.
如果你想将一个多行数据添加到数据流中，只需对要插入或附加的文本中的每一行末尾（除最后一行）添加反斜线即可，例如：
[root@localhost ~]# sed '1i \
> This is one line of new text.\
> This is another line of new text.' data6.txt
This is one line of new text.
This is another line of new text.
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
可以看到，指定的两行都会被添加到数据流中。
（4）sed c 替换脚本命令
c 命令表示**将指定行中的所有内容，替换成该选项后面的字符串。**该命令的基本格式为：
[address]c\用于替换的新文本
举个例子：
[root@localhost ~]#sed '3c \
> This is a changed line of text.' data6.txt
This is line number 1.
This is line number 2.
This is a changed line of text.
This is line number 4.
在这个例子中，sed 编辑器会修改第三行中的文本，其实，下面的写法也可以实现此目的：[root@localhost ~]#sed '/number 3/c \
> This is a changed line of text.' data6.txt
This is line number 1.
This is line number 2.
This is a changed line of text.
This is line number 4.
（5）sed y 转换脚本命令
y 转换命令是唯一可以处理单个字符的 sed 脚本命令，其基本格式如下：
[address]y/inchars/outchars/
转换命令会对 inchars 和 outchars 值进行一对一的映射，即 inchars 中的第一个字符会被转换为 outchars 中的第一个字符，第二个字符会被转换成 outchars 中的第二个字符...这个映射过程会一直持续到处理完指定字符。如果 inchars 和 outchars 的长度不同，则 sed 会产生一条错误消息。
举个简单例子：
[root@localhost ~]# sed 'y/123/789/' data8.txt
This is line number 7.
This is line number 8.
This is line number 9.
This is line number 4.
This is line number 7 again.
This is yet another line.
This is the last line in the file.
可以看到，inchars 模式中指定字符的每个实例都会被替换成 outchars 模式中相同位置的那个字符。
**转换命令是一个全局命令，也就是说，它会文本行中找到的所有指定字符自动进行转换，而不会考虑它们出现的位置，**再打个比方：
[root@localhost ~]# echo "This 1 is a test of 1 try." | sed 'y/123/456/'
This 4 is a test of 4 try.
sed 转换了在文本行中匹配到的字符 1 的两个实例，我们无法限定只转换在特定地方出现的字符。
（6）sed p 打印脚本命令
**p 命令表示搜索符号条件的行，并输出该行的内容，**此命令的基本格式为：
[address]p
p 命令常见的用法是打印包含匹配文本模式的行，例如：
[root@localhost ~]# cat data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
[root@localhost ~]# sed -n '/number 3/p' data6.txt
This is line number 3.
可以看到，用 -n 选项和 p 命令 配合使用，我们可以禁止输出其他行，只打印包含匹配文本模式的行。
如果需要在修改之前查看行，也可以使用打印命令，比如与替换或修改命令一起使用。可以创建一个脚本在修改行之前显示该行，如下所示：
[root@localhost ~]#sed -n '/3/{
> p
> s/line/test/p
> }' data6.txt
This is line number 3.
This is test number 3.
sed 命令会查找包含数字 3 的行，然后执行两条命令。首先，脚本用 p 命令来打印出原始行 ；然后它用 s 命令替换文本，并用 p 标记打印出替换结果 。输出同时显示了原来的行文本和新的行文本。
（7）sed w 脚本命令
w 命令用来将文本中指定行的内容写入文件中，此命令的基本格式如下：
[address]w filename
这里的 filename 表示文件名，可以使用相对路径或绝对路径，但不管是哪种，运行 sed 命令的用户都必须有文件的写权限。
下面的例子是将数据流中的前两行打印到一个文本文件中：
[root@localhost ~]# sed '1,2w test.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
[root@localhost ~]# cat test.txt
This is line number 1.
This is line number 2.
当然，如果不想让行直接输出，可以用 -n 选项，再举个例子：
[root@localhost ~]# cat data11.txt
Blum, R Browncoat
McGuiness, A Alliance
Bresnahan, C Browncoat
Harken, C Alliance
[root@localhost ~]# sed -n '/Browncoat/w Browncoats.txt' data11.txt
cat Browncoats.txt
Blum, R Browncoat
Bresnahan, C Browncoat
可以看到，通过使用 w 脚本命令，sed 可以实现将包含文本模式的数据行写入目标文件。
（8）sed r 脚本命令
**r 命令用于将一个独立文件的数据插入到当前数据流的指定位置，**该命令的基本格式为：
[address]r filename
sed 命令会将 filename 文件中的内容插入到 address 指定行的后面，比如说：
[root@localhost ~]# cat data12.txt
This is an added line.
This is the second added line.
[root@localhost ~]#sed '3r data12.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is an added line.
This is the second added line.This is line number 4.
如果你想将指定文件中的数据插入到数据流的末尾，可以使用 $ 地址符，例如：
[root@localhost ~]#sed '$r data12.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
This is an added line.
This is the second added line.
（9）sed q 退出脚本命令
q 命令的作用是使 sed 命令在第一次匹配任务结束后，退出 sed 程序，不再进行对后续数据的处理。
比如：
[root@localhost ~]#sed '2q' test.txt
This is line number 1.
This is line number 2.
可以看到，sed 命令在打印输出第 2 行之后，就停止了，是 q 命令造成的，再比如：
[root@localhost ~]# sed '/number 1/{ s/number 1/number 0/;q; }' test.txt
This is line number 0.
使用 q 命令之后，sed 命令会在匹配到 number 1 时，将其替换成 number 0，然后直接退出。
2、sed 脚本命令的寻址方式
前面在介绍各个脚本命令时，我们一直忽略了对 address 部分的介绍。对各个脚本命令来说，address 用来表明该脚本命令作用到文本中的具体行。
默认情况下，sed 命令会作用于文本数据的所有行。如果只想将命令作用于特定行或某些行，则必须写明 address 部分，表示的方法有以下 2 种：
- 以数字形式指定行区间；
- 用文本模式指定具体行区间。
以上两种形式都可以使用如下这 2 种格式，分别是：
[address]脚本命令
或者
address {
多个脚本命令
}
以上两种形式在前面例子中都有具体实例，因此这里不再做过多赘述。
（1）以数字形式指定行区间
当使用数字方式的行寻址时，可以用行在文本流中的行位置来引用。sed 会将文本流中的第一行编号为 1，然后继续按顺序为接下来的行分配行号。
在脚本命令中，指定的地址可以是单个行号，或是用起始行号、逗号以及结尾行号指定的一定区间范围内的行。这里举一个 sed 命令作用到指定行号的例子：
[root@localhost ~]#sed '2s/dog/cat/' data1.txt
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy catThe quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy dog
可以看到，sed 只修改地址指定的第二行的文本。下面的例子中使用了行地址区间：
[root@localhost ~]# sed '2,3s/dog/cat/' data1.txt
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy cat
The quick brown fox jumps over the lazy catThe quick brown fox jumps over the lazy dog
在此基础上，如果想将命令作用到文本中从某行开始的所有行，可以用特殊地址------美元符（$）：
[root@localhost ~]# sed '2,$s/dog/cat/' data1.txt
The quick brown fox jumps over the lazy dog
The quick brown fox jumps over the lazy cat
The quick brown fox jumps over the lazy cat
The quick brown fox jumps over the lazy cat
（2）用文本模式指定行区间
sed 允许指定文本模式来过滤出命令要作用的行，格式如下：
/pattern/command
注意，必须用正斜线将要指定的 pattern 封起来，sed 会将该命令作用到包含指定文本模式的行上。
举个例子，如果你想只修改用户 demo 的默认 shell，可以使用 sed 命令，执行命令如下：
[root@localhost ~]# grep demo /etc/passwd
demo:x:502:502::/home/Samantha:/bin/bash
[root@localhost ~]# sed '/demo/s/bash/csh/' /etc/passwd
root:x:0:0:root:/root:/bin/bash
...
demo:x:502:502::/home/demo:/bin/csh
...
虽然使用固定文本模式能帮你过滤出特定的值，就跟上面这个用户名的例子一样，但其作用难免有限，因此，sed 允许在文本模式使用正则表达式指明作用的具体行。正则表达式允许创建高级文本模式匹配表达式来匹配各种数据。这些表达式结合了一系列通配符、特殊字符以及固定文本字符来生成能够匹配几乎任何形式文本的简练模式。
关于正则表达式，本节不做过多介绍，有兴趣的读者可阅读正则表达式入门教程-CSDN博客一文，这里仅给读者提供一个简单示例：
[root@localhost ~]#cat test.txt
<html>
<title>First Wed</title>
<body>
h1Helloh1
h2Helloh2
h3Helloh3
</body>
</html>
#使用正则表示式给所有第一个的h1、h2、h3添加<>，给第二个h1、h2、h3添加</>[root@localhost ~]# cat sed.sh
/h[0-9]/{
s//\<&\>/1
s//\<\/&\>/2
}[root@localhost ~]# sed -f sed.sh test.txt
<h1>Hello</h1>
<h2>Hello</h2>
<h3>Hello</h3>
收到篇幅的限制，本节仅介绍了 sed 命令每次只读取一行内容并处理，有关 sed 命令如何一次处理多行文本内容，放到下节继续讲解，读者可点击**《九、Linux sed命令的高级玩法》一节**继续学习。
九、Linux sed命令的高级玩法
《八、Linux sed》一节给大家介绍了如何用 sed 命令的基本功能处理文本中的数据，所涵盖的知识点，可以满足日常大多数文本编辑需求。本节将介绍 sed 提供的一些高级功能，这些功能虽不常用，但知道这些功能的存在以及用法也是有必要的。
1、sed 多行命令
在学习 sed 命令的基础功能时，你可能注意到了一个局限，即所有的 sed 命令都只是针对单行数据执行操作，在 sed 命令读取缓冲区中的文本数据时，它会基于换行符的位置，将数据分成行，sed 会根据定义好的脚本命令一次处理一行数据。
但是，有时我们需要对跨多行的数据执行特定操作。比如说，在文本中查找一串字符串**"http://c.biancheng.net"** ，它很有可能出现在两行中，每行各包含其中一部分。这时，如果用普通的 sed 编辑器命令来处理文本，就不可能发现这种被分开的情况。
幸运的是，sed 命令的设计人员已经考虑到了这种情况，并设计了对应的解决方案。**sed 包含了三个可用来处理多行文本的特殊命令，**分别是：
- Next 命令（N）：将数据流中的下一行加进来创建一个多行组来处理。
- Delete（D）：删除多行组中的一行。
- Print（P）：打印多行组中的一行。
注意，以上命令的缩写，都为大写。
（1）N 多行操作命令
N 命令会将下一行文本内容添加到缓冲区已有数据之后**（之间用换行符分隔），从而使前后两个文本行同时位于缓冲区中，sed 命令会将这两行数据当成一行来处理。**
下面这个例子演示的 N 命令的功能：
[root@localhost ~]# cat data2.txt
This is the header line.
This is the first data line.
This is the second data line.
This is the last line.
[root@localhost ~]# sed '/first/{ N ; s/\n/ / }' data2.txt
This is the header line.
This is the first data line. This is the second data line.This is the last line.
在这个例子中，sed 命令查找含有单词 first 的那行文本。找到该行后，它会用 N 命令将下一行合并到那行，然后用替换命令 s 将换行符替换成空格。结果是，文本文件中的两行在 sed 的输出中成了一行。
如果要在数据文件中查找一个可能会分散在两行中的文本短语，如何实现呢？这里给大家一个实例：
[root@localhost ~]# cat data3.txt
On Tuesday, the Linux System
Administrator's group meeting will be held.
All System Administrators should attend.
Thank you for your attendance.
[root@localhost ~]# sed 'N ; s/System Administrator/Desktop User/' data3.txt
On Tuesday, the Linux Desktop User's group meeting will be held.All Desktop Users should attend.
Thank you for your attendance.
用 N 命令将发现第一个单词的那行和下一行合并后，即使短语内出现了换行，你仍然可以找到它，这是因为，替换命令在 System 和 Administrator之间用了通配符（.）来匹配空格和换行符这两种情况。 但当它匹配了换行符时，它就从字符串中删掉了换行符，导致两行合并成一行。这可能不是你想要的。
要解决这个问题，可以在 sed 脚本中用两个替换命令，一个用来匹配短语出现在多行中的情况，一个用来匹配短语出现在单行中的情况，比如：
[root@localhost ~]# sed 'N
> s/System\nAdministrator/Desktop\nUser/
> s/System Administrator/Desktop User/
> ' data3.txt
On Tuesday, the Linux Desktop
User's group meeting will be held.
All Desktop Users should attend.
Thank you for your attendance.
第一个替换命令专门查找两个单词间的换行符，并将它放在了替换字符串中。这样就能在第一个替换命令专门在两个检索词之间寻找换行符，并将其纳入替换字符串。这样就允许在新文本的同样位置添加换行符了。
但这个脚本中仍有个小问题，即它总是在执行 sed 命令前将下一行文本读入到缓冲区中，当它到了后一行文本时，就没有下一行可读了，此时 N 命令会叫 sed 程序停止，这就导致，如果要匹配的文本正好在最后一行中，sed 命令将不会发现要匹配的数据。
**解决这个 bug 的方法是，将单行命令放到 N 命令前面，将多行命令放到 N 命令后面，**像这样：
[root@localhost ~]# sed '
> s/System\nAdministrator/Desktop\nUser/
> N
> s/System Administrator/Desktop User/
> ' data3.txt
On Tuesday, the Linux Desktop
User's group meeting will be held.
All Desktop Users should attend.
Thank you for your attendance.
现在，查找单行中短语的替换命令在数据流的后一行也能正常工作，多行替换命令则会负责短语出现在数据流中间的情况。
（2）D 多行删除命令
sed 不仅提供了单行删除命令（d），也提供了多行删除命令 D，其作用是只删除缓冲区中的第一行，也就是说，D 命令将缓冲区中第一个换行符（包括换行符）之前的内容删除掉。
比如说：
[root@localhost ~]#cat data4.txt
On Tuesday, the Linux System
Administrator's group meeting will be held.
All System Administrators should attend.
[root@localhost ~]# sed 'N ; /System\nAdministrator/D' data4.txt
Administrator's group meeting will be held.
All System Administrators should attend.
文本的第二行被 N 命令加到了缓冲区，因此 sed 命令第一次匹配就是成功，而 D 命令会将缓冲区中第一个换行符之前（也就是第一行）的数据删除，所以，得到了如上所示的结果。
下面的例子中，它会删除数据流中出现在第一行前的空白行：
[root@localhost ~]# cat data5.txt
This is the header line.
This is a data line.
This is the last line.
[root@localhost ~]# sed '/^$/{N ; /header/D}' data5.txt
This is the header line.
This is a data line.
This is the last line.
sed会查找空白行，然后用 N 命令来将下一文本行添加到缓冲区。此时如果缓冲区的内容中含有单词 header，则 D 命令会删除缓冲区中的第一行。
（3）P 多行打印命令
同 d 和 D 之间的区别一样，P（大写）命令和单行打印命令 p（小写）不同，对于具有多行数据的缓冲区来说，它只会打印缓冲区中的第一行，也就是首个换行符之前的所有内容。
例如，test.txt 文件中的内容如下：
[root@localhost ~]# cat test.txt
aaa
bbb
ccc
ddd
eee
fff
表 1 中是对 test.txt 文件中的内容分别用 p 命令和 P 命令后，产生的输出信息的对比。
| P（大写）命令 | p（小写）命令 |
|---|---|
| [root@localhost ~]# sed '/.*/N;P' aaa aaa bbb ccc ccc ddd eee eee fff | [root@localhost ~]# sed '/.*/N;p' aaa bbb aaa bbb ccc ddd ccc ddd eee fff eee fff |
| [表 1 P 命令和 p 命令的对比] |
第一个 sed 命令，每次都使用 N 将下一行内容追加到缓冲区内容的后面（用换行符间隔），也就是说，第一次时缓冲区中的内容为 aaa\nbbb，但 P（大写） 命令的作用的打印换行符之前的内容，也就是 aaa，之后则是 sed 在自动输出功能输出 aaa 和 bbb（sed 命令会自动将 \n 输出为换行），依次类推，就输出了所看到的结果。
第二个 sed 命令，使用的是 p （小写）单行打印命令，它会将缓冲区中的所有内容全部打印出来（\n 会自动输出为换行），因此，出现了看到的结果。
2、sed 保持空间
前面我们一直说，sed 命令处理的是缓冲区中的内容，其实这里的**缓冲区，应称为模式空间。**值得一提的是，模式空间并不是 sed 命令保存文件的唯一空间。sed 还有另一块称为保持空间的缓冲区域，它可以用来临时存储一些数据。
表 2 列出了 5 条可用来操作保持空间的命令。
| 命令 | 功能 |
|---|---|
| h | 将模式空间中的内容复制到保持空间 |
| H | 将模式空间中的内容附加到保持空间 |
| g | 将保持空间中的内容复制到模式空间 |
| G | 将保持空间中的内容附加到模式空间 |
| x | 交换模式空间和保持空间中的内容 |
| [表 2 sed 保持空间命令] |
通常，在使用h 或 H 命令 将字符串移动到保持空间后，最终还要用g、G 或 x 命令 将保存的字符串移回模式空间。保持空间最直接的作用是，一旦我们将模式空间中所有的文件复制到保持空间中，就可以清空模式空间来加载其他要处理的文本内容。
由于有两个缓冲区域，下面的例子中演示了如何用 h 和 g 命令来将数据在 sed 缓冲区之间移动。
[root@localhost ~]#cat data2.txt
This is the header line.
This is the first data line.
This is the second data line.
This is the last line.
[root@localhost ~]#sed -n '/first/ {h ; p ; n ; p ; g ; p }' data2.txt
This is the first data line.
This is the second data line.
This is the first data line.
这个例子的运行过程是这样的：
- sed脚本命令用正则表达式过滤出含有单词first的行；
- 当含有单词 first 的行出现时，h 命令将该行放到保持空间；
- p 命令打印模式空间也就是第一个数据行的内容；
- n 命令提取数据流中的下一行（This is the second data line），并将它放到模式空间；
- p 命令打印模式空间的内容，现在是第二个数据行；
- g 命令将保持空间的内容（This is the first data line）放回模式空间，替换当前文本；
- p 命令打印模式空间的当前内容，现在变回第一个数据行了。
3、sed改变指定流程
（1）b 分支命令
通常，sed 程序的执行过程会从第一个脚本命令开始，一直执行到最后一个脚本命令（D 命令是个例外，它会强制 sed 返回到脚本的顶部，而不读取新的行）。sed 提供了 b 分支命令来改变命令脚本的执行流程 ，其结果与结构化编程类似。
b 分支命令基本格式为：
[address]b [label]
其中，address 参数决定了哪些行的数据会触发分支命令，label 参数定义了要跳转到的位置。
需要注意的是，如果没有加 label 参数，跳转命令会跳转到脚本的结尾，比如：
[root@localhost ~]# cat data2.txt
This is the header line.
This is the first data line.
This is the second data line.
This is the last line.
[root@localhost ~]# sed '{2,3b ; s/This is/Is this/ ; s/line./test?/}' data2.txt
Is this the header test?
This is the first data line.
This is the second data line.
Is this the last test?
可以看到，因为 b 命令未指定 label 参数，因此数据流中的第2行和第3行并没有执行那两个替换命令。
如果我们不想直接跳到脚本的结尾，可以为 b 命令指定一个标签（也就是格式中的 label，最多为 7 个字符长度）。在使用此该标签时，要**以冒号开始（比如 :label2），并将其放到要跳过的脚本命令之后。**这样，当 sed 命令匹配并处理该行文本时，会跳过标签之前所有的脚本命令，但会执行标签之后的脚本命令。
比如说：
[root@localhost ~]# sed '{/first/b jump1 ; s/This is the/No jump on/
> :jump1
>s/This is the/Jump here on/}' data2.txt
No jump on header line
Jump here on first data line
No jump on second data line
No jump on last line
在这个例子中，如果文本行中出现了 first，程序的执行会直接跳到 jump1 标签之后的脚本行。如果分支命令的模式没有匹配，sed 会继续执行所有的脚本命令。
b 分支命令除了可以向后跳转，还可以向前跳转，例如：
[root@localhost ~]# echo "This, is, a, test, to, remove, commas." | sed -n '{
> :start
> s/,//1p
> /,/b start
> }'
This is, a, test, to, remove, commas.
This is a, test, to, remove, commas.
This is a test, to, remove, commas.
This is a test to, remove, commas.
This is a test to remove, commas.
This is a test to remove commas.
在这个例子中，当缓冲区中的行内容中有逗号时，脚本命令就会一直循环执行，每次迭代都会删除文本中的第一个逗号，并打印字符串，直至内容中没有逗号。
（2）t 测试命令
类似于 b 分支命令，t 命令也可以用来改变 sed 脚本的执行流程。t 测试命令会根据 s 替换命令的结果，如果匹配并替换成功，则脚本的执行会跳转到指定的标签；反之，t 命令无效。
测试命令使用与分支命令相同的格式：
[address]t [label]
跟分支命令一样，在没有指定标签的情况下，如果 s 命令替换成功，sed 会跳转到脚本的结尾（相当于不执行任何脚本命令）。例如：
[root@localhost ~]# sed '{
> s/first/matched/
> t
> s/This is the/No match on/
> }' data2.txt
No match on header line
This is the matched data line
No match on second data line
No match on last line
此例中，第一个替换命令会查找模式文本 first，如果匹配并替换成功，命令会直接跳过后面的替换命令；反之，如果第一个替换命令未能匹配成功，第二个替换命令就会被执行。
再举个例子：
[root@localhost ~]# echo "This, is, a, test, to, remove, commas. " | sed -n '{
> :start
> s/,//1p
> t start
> }'
This is, a, test, to, remove, commas.
This is a, test, to, remove, commas.
This is a test, to, remove, commas.
This is a test to, remove, commas.
This is a test to remove, commas.
This is a test to remove commas.
十、Linux awk（Linux 三剑客之一）
除了使用 sed 命令，Linux 系统中还有一个功能更加强大的文本数据处理工具，就是 awk。它诞生于 20 世纪 70 年代末期，这也许是它影响了众多 Linux 用户的原因之一。
曾有人推测 awk 命令的名字来源于 awkward 这个单词。其实不然，此命令的设计者有 3 位，他们的姓分别是 Aho、Weingberger 和 Kernighan，awk 就取自这 3 为大师姓的首字母。
和 sed 命令类似，awk 命令也是逐行扫描文件（从第 1 行到最后一行），寻找含有目标文本的行，如果匹配成功，则会在该行上执行用户想要的操作；反之，则不对行做任何处理。
awk 命令的基本格式为：
[root@localhost ~]# awk [选项] '脚本命令' 文件名
此命令常用的选项以及各自的含义，如表 1 所示。
| 选项 | 含义 |
|---|---|
| -F fs | 指定以 fs 作为输入行的分隔符，awk 命令默认分隔符为空格或制表符。 |
| -f file | 从脚本文件中读取 awk 脚本指令，以取代直接在命令行中输入指令。 |
| -v var=val | 在执行处理过程之前，设置一个变量 var，并给其设备初始值为 val。 |
| [表 1 awk 命令选项以及含义] |
awk 的强大之处在于脚本命令，它由 2 部分组成，分别为匹配规则和执行命令，如下所示：
'匹配规则{执行命令}'
这里的匹配规则，和 sed 命令中的 address 部分作用相同，用来指定脚本命令可以作用到文本内容中的具体行，可以使用字符串（比如 /demo/，表示查看含有 demo 字符串的行）或者正则表达式指定。另外需要注意的是，整个脚本命令是用单引号（''）括起，而其中的执行命令部分需要用大括号（{}）括起来。
在 awk 程序执行时，如果没有指定执行命令，则默认会把匹配的行输出；如果不指定匹配规则，则默认匹配文本中所有的行。
举个简单的例子：
[root@localhost ~]# awk '/^$/ {print "Blank line"}' test.txt
在此命令中，/^$/ 是一个正则表达式，功能是匹配文本中的空白行，同时可以看到，执行命令使用的是 print 命令，此命令经常会使用，它的作用很简单，就是将指定的文本进行输出。因此，整个命令的功能是，如果 test.txt 有 N 个空白行，那么执行此命令会输出 N 个 Blank line。
1、awk 使用数据字段变量
awk 的主要特性之一是其处理文本文件中数据的能力，它会自动给一行中的每个数据元素分配一个变量。
默认情况下，awk 会将如下变量分配给它在文本行中发现的数据字段：
- $0 代表整个文本行；
- $1 代表文本行中的第 1 个数据字段；
- $2 代表文本行中的第 2 个数据字段；
- $n 代表文本行中的第 n 个数据字段。
前面说过，在 awk 中，默认的字段分隔符是任意的空白字符（例如空格或制表符）。 在文本行中，每个数据字段都是通过字段分隔符划分的。awk 在读取一行文本时，会用预定义的字段分隔符划分每个数据字段。
所以在下面的例子中，awk 程序读取文本文件，只显示第 1 个数据字段的值：
[root@localhost ~]# cat data2.txt
One line of test text.
Two lines of test text.
Three lines of test text.
[root@localhost ~]# awk '{print $1}' data2.txt
One
Two
Three
该程序用 $1 字段变量来表示"仅显示每行文本的第 1 个数据字段"。当然，如果你要读取采用了其他字段分隔符的文件，可以用 -F 选项手动指定。
2、awk 脚本命令使用多个命令
awk 允许将多条命令组合成一个正常的程序。要在命令行上的程序脚本中使用多条命令，只要在命令之间放个分号即可，例如：
[root@localhost ~]# echo "My name is Rich" | awk '{$4="Christine"; print $0}'
My name is Christine
第一条命令会给字段变量 $4 赋值。第二条命令会打印整个数据字段。可以看到，awk 程序在输出中已经将原文本中的第四个数据字段替换成了新值。
除此之外，也可以一次一行地输入程序脚本命令，比如说：
[root@localhost ~]# awk '{
> $4="Christine"
> print $0}'
My name is Rich
My name is Christine
在你用了表示起始的单引号后，bash shell 会使用**> 来提示输入更多数据**，我们可以每次在每行加一条命令，直到输入了结尾的单引号。
注意，此例中因为没有在命令行中指定文件名，awk 程序需要用户输入获得数据，因此当运行这个程序的时候，它会一直等着用户输入文本，此时如果要退出程序，只需按下 Ctrl+D 组合键即可。
3、awk从文件中读取程序
跟 sed 一样，awk 允许将脚本命令存储到文件中，然后再在命令行中引用，比如：
[root@localhost ~]# cat awk.sh
{print $1 "'s home directory is " $6 }
[root@localhost ~]# awk -F: -f awk.sh /etc/passwd
root's home directory is /root
bin's home directory is /bin
daemon's home directory is /sbin
adm's home directory is /var/adm
lp's home directory is /var/spool/lpd
...
Christine's home directory is /home/Christine
Samantha's home directory is /home/Samantha
Timothy's home directory is /home/Timothy
awk.sh 脚本文件会使用 print 命令打印 /etc/passwd 文件的主目录数据字段（字段变量 $6），以及 userid 数据字段（字段变量 $1）。注意，在程序文件中，也可以指定多条命令，只要一条命令放一行即可，之间不需要用分号。
4、awk BEGIN关键字
awk 中还可以指定脚本命令的运行时机。默认情况下，awk 会从输入中读取一行文本，然后针对该行的数据执行程序脚本，但有时可能需要在处理数据前运行一些脚本命令，这就需要使用 BEGIN 关键字。
BEGIN 会强制 awk 在读取数据前执行该关键字后指定的脚本命令，例如：
[root@localhost ~]# cat data3.txt
Line 1
Line 2
Line 3
[root@localhost ~]# awk 'BEGIN {print "The data3 File Contents:"}
> {print $0}' data3.txt
The data3 File Contents:
Line 1
Line 2
Line 3
可以看到，这里的脚本命令中分为 2 部分，BEGIN 部分的脚本指令会在 awk 命令处理数据前运行，而真正用来处理数据的是第二段脚本命令。
5、awk END关键字
和 BEGIN 关键字相对应，END 关键字允许我们指定一些脚本命令，awk 会在读完数据后执行它们，例如：
[root@localhost ~]# awk 'BEGIN {print "The data3 File Contents:"}
> {print $0}
> END {print "End of File"}' data3.txt
The data3 File Contents:
Line 1
Line 2
Line 3
End of File
可以看到，当 awk 程序打印完文件内容后，才会执行 END 中的脚本命令。
本节仅介绍了 awk 程序的基本用法，更高级的用法会在下节继续介绍。
十一、Linux awk命令的高级玩法
前面一节已经介绍了 awk 的基本用法，其实在 awk 脚本程序中，还支持使用一些编程语言，比如变量、数组、分支结构（if-then-else）、循环结构（while）、函数等，下面一一给大家介绍。
1、awk 使用变量
在 awk 的脚本程序中，支持使用变量来存取值。awk 支持两种不同类型的变量：
- 内建变量：awk 本身就创建好，用户可以直接拿来用的变量，这些变量用来存放处理数据文件中的某些字段和记录的信息。
- 自定义变量：awk 支持用户自己创建变量。
（1）内建变量
awk 程序使用内建变量来引用程序数据里的一些特殊功能。常见的一些内建变量，包括上一节介绍的数据字段变量（$0、$1、2...n）以及表 1 、表 2 中所示的这些变量。
| 变量 | 功能 |
|---|---|
| FIELDWIDTHS | 由空格分隔的一列数字，定义了每个数据字段的确切宽度。 |
| FNR | 当前输入文档的记录编号，常在有多个输入文档时使用。 |
| NR | 输入流的当前记录编号。 |
| FS | 输入字段分隔符 |
| RS | 输入记录分隔符，默认为换行符 \n。 |
| OFS | 输出字段分隔符，默认为空格。 |
| ORS | 输出记录分隔符，默认为换行符 \n。 |
| [表 1 字段和记录分隔符变量] |
在表 1 中，变量 FS 和 OFS 定义了 awk 如何处理数据流中的数据字段。我们已经知道了如何使用变量 FS 来定义记录中的字段分隔符，变量 OFS 具备相同的功能，只不过是用在 print 命令的输出上，例如：
[root@localhost ~]# cat data1
data11,data12,data13,data14,data15
data21,data22,data23,data24,data25
data31,data32,data33,data34,data35
[root@localhost ~]# awk 'BEGIN{FS=","; OFS="-"} {print $1,$2,$3}' data1
data11-data12-data13
data21-data22-data23
data31-data32-data33
[root@localhost ~]# awk 'BEGIN{FS=","; OFS="--"} {print $1,$2,$3}' data1
data11--data12--data13
data21--data22--data23
data31--data32--data33
可以看到，print 命令会自动将 OFS 变量的值放置在输出中的每个字段间。通过设置 OFS 变量，可以在输出中使用任意字符串来分隔字段。
FIELDWIDTHS 变量允许用户不依靠字段分隔符来读取记录。在一些应用程序中，数据并没有使用字段分隔符，而是被放置在了记录中的特定列，这种情况下，必须设定 FIELDWIDTHS 变量来匹配数据在记录中的位置。
一旦设置了 FIELDWIDTH 变量，awk 就会忽略 FS 变量，并根据提供的字段宽度来计算字段，下面是个采用字段宽度而非字段分隔符的例子：
[root@localhost ~]# cat data1b
1005.3247596.37
115-2.349194.00
05810.1298100.1
[root@localhost ~]# awk 'BEGIN{FIELDWIDTHS="3 5 2 5"}{print $1,$2,$3,$4}' data1b
100 5.324 75 96.37
115 -2.34 91 94.00
058 10.12 98 100.1
注意，一旦设定了 FIELDWIDTHS 变量的值，就不能再改变了，因此，这种方法并不适用于变长的字段。
变量 RS 和 ORS 定义了 awk 程序如何处理数据流中的字段，默认情况下，awk 将 RS 和 ORS 设为换行符。默认的 RS 值表明，输入数据流中的每行新文本就是一条新纪录。 有时，你会在数据流中碰到占据多行的字段。典型的例子是包含地址和电话号码的数据，其中地址和电话号码各占一行，例如：
Riley Mullen
123 Main Street
Chicago, IL 60601
(312)555-1234
如果你用默认的 FS 和 RS 变量值来读取这组数据，awk 就会把每行作为一条单独的记录来读取，并将记录中的空格当作字段分隔符，这并不是用户想要的。
要解决这个问题，**只需把 FS 变量设置成换行符，这就表明数据流中的每行都是一个单独的字段，每行上的所有数据都属于同一个字段；与此同时，把 RS 变量设置成空字符串，然后在数据记录间留一个空白行，awk 会把每个空白行当作一个记录分隔符。**例如：
[root@localhost ~]# cat data2
Riley Mullen
123 Main Street
Chicago, IL 60601
(312)555-1234
Frank Williams
456 Oak Street
Indianapolis, IN 46201
(317)555-9876
Haley Snell
4231 Elm Street
Detroit, MI 48201
(313)555-4938
[root@localhost ~]# awk 'BEGIN{FS="\n"; RS=""} {print $1,$4}' data2
Riley Mullen (312)555-1234
Frank Williams (317)555-9876
Haley Snell (313)555-4938
| 变量名 | 功能 |
|---|---|
| ARGC | 命令行参数个数。 |
| ARGIND | 当前文件在 ARGC 中的位置。 |
| ARGV | 包含命令行参数的数组。 |
| CONVFMT | 数字的转换格式，默认值为 %.6g。 |
| ENVIRON | 当前 shell 环境变量及其值组成的关联数组。 |
| ERRNO | 当读取或关闭输入文件发生错误时的系统错误号。 |
| FILENAME | 当前输入文档的名称。 |
| FNR | 当前数据文件中的数据行数。 |
| IGNORECASE | 设成非 0 值时，忽略 awk 命令中出现的字符串的字符大小写。 |
| NF | 数据文件中的字段总数。 |
| NR | 已处理的输入记录数。 |
| OFMT | 数字的输出格式，默认值为 %.6g。 |
| RLENGTH | 由 match 函数所匹配的子字符串的长度。 |
| TSTART | 由 match 函数所匹配的子字符串的起始位置。 |
| [表 2 环境信息变量] |
其中，FNR 和 NR 变量虽然类似，但又略有不同。FNR 变量含有当前数据文件中已处理过的记录数，NR 变量则含有已处理过的记录总数。举个例子：
[root@localhost ~]# cat data1
data11,data12,data13,data14,data15
data21,data22,data23,data24,data25
data31,data32,data33,data34,data35
[root@localhost ~]# awk '
> BEGIN {FS=","}
> {print $1,"FNR="FNR,"NR="NR}
> END{print "There were",NR,"records processed"}' data1 data1
data11 FNR=1 NR=1
data21 FNR=2 NR=2
data31 FNR=3 NR=3
data11 FNR=1 NR=4
data21 FNR=2 NR=5
data31 FNR=3 NR=6
There were 6 records processed
由此可以看出，当只使用一个数据文件作为输入时，FNR 和 NR 的值是相同的；如果使用多个数据文件作为输入，FNR 的值会在处理每个数据文件时被重置，而 NR 的值则会继续计数直到处理完所有的数据文件。
（2）自定义变量
和其他典型的编程语言一样，awk 允许用户定义自己的变量在脚本程序中使用。awk 自定义变量名可以是任意数目的字母、数字和下划线，但不能以数字开头。更重要的是，awk 变量名区分大小写。
举个简单的例子：
[root@localhost ~]# awk '
> BEGIN{
> testing="This is a test"
> print testing
> testing=45
> print testing
> }'
This is a test
45
可以看到，print 语句的输出是 testing 变量的当前值。
也可以用 awk 命令行来给程序中的变量赋值，这允许我们在正常的代码之外赋值，即时改变变量的值，比如：
[root@localhost ~]# cat script1
BEGIN{FS=","} {print $n}[root@localhost ~]# awk -f script1 n=2 data1
data12
data22
data32
[root@localhost ~]# awk -f script1 n=3 data1
data13
data23
data33
需要注意的是，使用命令行参数来定义变量值会有一个问题，即设置了变量后，这个值在代码的 BEGIN 部分不可用，如下所示：
[root@localhost ~]# cat script2
BEGIN{print "The starting value is",n; FS=","}
{print $n}
[root@localhost ~]# awk -f script2 n=3 data1
The starting value is
data13
data23
data33
解决这个问题，可以用 -v 命令行参数，它可以实现在 BEGIN 代码之前设定变量。在命令行上，-v 命令行参数必须放在脚本代码之前，如下所示：
[root@localhost ~]# awk -v n=3 -f script2 data1
The starting value is 3
data13
data23
data33
注意，awk 脚本程序中输出函数还可以使用 C 语言中的 printf 函数。
2、awk 使用数组
为了在单个变量中存储多个值，许多编程语言都提供数组，awk 使用关联数组提供数组功能。
关联数组跟数字数组不同之处在于，它的索引值可以是任意文本字符串。用户不需要用连续的数字来标识数组中的数据元素；相反，关联数组用各种字符串来引用值。每个索引字符串都必须能够唯一地标识出赋给它的数据元素。
如果你熟悉其他编程语言的话，其实关联数组和散列表、字典的用法类似。
（1）关联数组的定义和使用
在 awk 脚本程序中，定义一个数组变量可以使用标准复制语句，其基本格式为：
var[index]=element
其中，var 是数组名，index 是关联数组的索引值，element 是数据元素值。例如：
capital["Illinois"] = "Springfield"
capital["Indiana"] = "Indianapolis"
capital["Ohio"] = "Columbus"
在引用数组变量时，必须用索引值（index）来提取相应的数据元素值，例如：
[root@localhost ~]#awk 'BEGIN{
> capital["Illinois"] = "Springfield"
> print capital["Illinois"]
> }'
Springfield
数组变量也是变量，也可以使用其进行基本的算术运算，例如：
[root@localhost ~]# awk 'BEGIN{
> var[1] = 34
> var[2] = 3
> total = var[1] + var[2]
> print total
> }'
37
（2）关联数组的遍历
在 awk 中遍历关联数组，可以用 for 语句的一种特殊形式：
for (var in array)
{
statements
}
这个 for 语句会在每次循环时将关联数组 array 的下一个索引值赋给变量 var，然后执行一遍 statements。
再次强调，整个遍历过程中，传给 var 的都是每个数组元素的索引值（也就是 index），不是数组元素的值。
举个例子：
[root@localhost ~]# awk 'BEGIN{
> var["a"] = 1
> var["g"] = 2
> var["m"] = 3
> var["u"] = 4
> for (test in var)
> {
> print "Index:",test," - Value:",var[test]
> }
> }'
Index: u - Value: 4
Index: m - Value: 3
Index: a - Value: 1
Index: g - Value: 2
注意，索引值不会按任何特定顺序返回，但它们都能够指向对应的数据元素值。
（3）删除数组变量
awk脚本程序还支持从关联数组中删除某个数组索引，使用 delete 命令就可以，此命令会从数组中删除指定的索引值及相关的数据元素的值。
delete 命令的基本格式如下：
delete array[index]
举个例子：
[root@localhost ~]# awk 'BEGIN{
> var["a"] = 1
> var["g"] = 2
> for (test in var)
> {
> print "Index:",test," - Value:",var[test]
> }
> delete var["g"]
> print "---"
> for (test in var)
> {
> print "Index:",test," - Value:",var[test]
> }
> }'
Index: a - Value: 1
Index: g - Value: 2
Index: a - Value: 1
需要注意的是，一旦从关联数组中删除了索引值，就没法再用它来提取元素值。
3、awk使用分支结构
awk 支持标准的 if-then-else 格式的 if 语句，其基本格式为：
if (condition)
statement1
else
statements
也可以将它放在一行上，像这样：
if (condition) statement1；else statement2
举个简单的例子：
[root@localhost ~]# cat data4
10
5
13
50
34
[root@localhost ~]# awk '{if ($1 > 20) print $1 * 2; else print $1 / 2}' data4
5
2.5
6.5
100
68
4、awk使用循环结构
awk 脚本程序中，可以使用 while、do-while、for 这 3 种循环结构，它们各自的基本格式分别如表 3 所示。
| 基本格式 | 实例 |
|---|---|
| while (条件) { 运行代码； } | [root@localhost ~]# cat data5 130 120 135 160 113 140 145 170 215 [root@localhost ~]# awk '{ > total = 0 > i = 1 > while (i < 4) > { > total += $i > i++ > } > avg = total / 3 > print "Average:",avg > }' data5 Average: 128.333 Average: 137.667 Average: 176.667 |
| do { 运行代码； }while(条件) | [root@localhost ~]# awk '{ > total = 0 > i = 1 > do > { > total += $i > i++ > } while (total < 150) > print total }' data5 250 160 315 |
| for(变量；条件；计数器) { 运行代码； } | [root@localhost ~]# awk '{ > total = 0 > for (i = 1; i < 4; i++) > { > total += $i > } > avg = total / 3 > print "Average:",avg > }' data5 Average: 128.333 Average: 137.667 Average: 176.667 |
| [表 3 循环结构基本格式及实例] |
从表 3 中可以看出，awk 支持使用的循环结构的用法和 C 语言完全一样，除此之外，awk 还支持使用 break（跳出循环）、continue（终止当前循环）关键字，其用法和 C 语言中也完全相同。
5、awk使用函数
（1）内建函数
和内建变量类似，awk 也提供了不少内建函数，可进行一些常见的数学、字符串以及时间函数运算，如表 4 所示。
| 函数分类 | 函数原型 | 函数功能 |
| 数学函数 | atan2(x, y) | x/y 的反正切，x 和 y 以弧度为单位。 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
| 数学函数 |
|---------------------------------|-----------------------------------------------------------------------------------------------------------|------------------------|
| cos(x) | x 的余弦，x 以弧度为单位。 |
| exp(x) | x 的指数函数。 |
| int(x) | x 的整数部分，取靠近零一侧的值。 |
| log(x) | x 的自然对数。 |
| srand(x) | 为计算随机数指定一个种子值。 |
| rand() | 比 0 大比 1 小的随机浮点值。 |
| sin(x) | x 的正弦，x 以弧度为单位。 |
| sqrt(x) | x 的平方根。 |
| compl(val) | 执行 val 的补运算。 |
| lshift(val, count) | 将值 val 左移 count 位。 |
| or(v1, v2) | 执行值 v1 和 v2 的按位或运算。 |
| rshift(val, count) | 将值 val 右移 count 位。 |
| xor(v1, v2) | 执行值 v1 和 v2 的按位异或运算。 |
| asorti(s [,d]) | 将数组 s 按索引值排序。生成的数组会将索引值作为数据元素值，用连续数字索引来表明排序顺序。另外如果指定了 d，排序后的数组会存储在数组 d 中。 |
| gensub(r, s, h [, t]) | 查找变量 $0 或目标字符串 t（如果提供了的话）来匹配正则表达式 r。如果 h 是一个以 g 或 G 开头的字符串，就用 s 替换掉匹配的文本。如果 h 是一个数字，它表示要替换掉第 h 处 r 匹配的地方。 |
| gsub(r, s [,t]) | 查找变量 $0 或目标字符串 t（如果提供了的话）来匹配正则表达式 r。如果找到了，就全部替换成字符串 s。 |
| index(s, t) | 返回字符串 t 在字符串 s 中的索引值，如果没找到的话返回 0。 |
| length([s]) | 返回字符串 s 的长度；如果没有指定的话，返回 $0 的长度。 |
| match(s, r [,a]) | 返回字符串 s 中正则表达式 r 出现位置的索引。如果指定了数组 a，它会存储 s 中匹配正则表达式的那部分。 |
| split(s, a [,r]) | 将 s 用 FS 字符或正则表达式 r（如果指定了的话）分开放到数组 a 中，并返回字段的总数。 |
| sprintf(format, variables) | 用提供的 format 和 variables 返回一个类似于 printf 输出的字符串。 |
| sub(r, s [,t]) | 在变量 $0 或目标字符串 t 中查找正则表达式 r 的匹配。如果找到了，就用字符串 s 替换掉第一处匹配。 |
| substr(s, i [,n]) | 返回 s 中从索引值 i 开始的 n 个字符组成的子字符串。如果未提供 n，则返回 s 剩下的部分。 |
| tolower(s) | 将 s 中的所有字符转换成小写。 |
| toupper(s) | 将 s 中的所有字符转换成大写。 |
| strftime(format [,timestamp]) | 将当前时间的时间戳或 timestamp（如果提供了的话）转化格式化日期（采用 shell 函数 date() 的格式）。 |
| systime() | 返回当前时间的时间戳。 |
[表 4 awk 内建函数]
时间戳指的是格林威治时间，即从 1970年1月1日8时1起到现在的总秒数。
（2）自定义函数
除了awk 中的内建函数，还可以在 awk 脚本程序中自定义函数，创建自定义函数的基本格式为：
function 函数名(参数1，参数2，...)
{
运行代码；
}
注意，**自定义函数的函数名必须能够唯一标识此函数，换句话说，在同一个 awk 脚本程序中，多个函数的函数名不能相同。**同时，函数的参数可以有多个（0 个、1 个或多个）。
例如：
function printthird()
{
print $3
}
此函数会打印记录中的第三个数据字段。
函数还能用 return 语句返回值，例如：
function myrand(limit) {
return int(limit * rand())
}
需要注意的是，在定义函数时，它必须出现在所有代码块之前（包括 BEGIN 和 END代码块）。
（3）创建函数库
awk 提供了一种途径来将多个函数放到一个库文件中，这样用户就能在所有的 awk 脚本程序中使用了。为了方便大家理解，下面给大家举个实例。
首先，我们需要创建一个存储所有 awk 函数的文件：
[root@localhost ~]# cat funclib
function myprint() {
printf "%-16s - %s\n", $1, $4
}
function myrand(limit)
{
return int(limit * rand())
}
function printthird()
{
print $3
}
要想让 awk 成功读取 funclib 函数库文件，就需要使用 -f 选项，但此选项无法和 awk 脚本程序同时放到命令行中一起使用。因此，要使用库函数文件，只能再创建一个脚本程序文件，例如：
[root@localhost ~]# cat script4
BEGIN{ FS="\n"; RS=""}
{
myprint()
}
[root@localhost ~]#awk -f funclib -f script4 data2
Riley Mullen - (312)555-1234
Frank Williams - (317)555-9876
Haley Snell - (313)555-4938