使用sed批量改文件名
Sed批量去拓展名
|- dev.gb.conll06.raw
|- test.gb.conll06.raw
|- train.gb.conll06.raw
想要去掉其中的后缀.raw，用个小脚本就可以搞定： for file in `ls`; do mv $file `echo $file | sed 's/\.raw$//'`; done
Sed批量添加拓展名
|- dev.gb.conll06
|- test.gb.conll06
|- train.gb.conll06
同理，一个小脚本可以搞定： for file in `ls`; do mv $file `echo $file | sed 's/$/\.raw//'`; done
一、Sed简介
Sed：Stream Editor 流式编辑器 又称行编辑器，每次只编辑一行。Sed工作是在“模式空间”中进行的，并不操作源文件。对源文件无危害。
二、Sed使用格式
Sed命令的常用格式如下：
（1）Sed [options] ‘script’ input_file…
（2）Sed [options] –f script_file input_file…
（3）Sed [options] ‘ADDR1,ADDR2command’ input_file…
例如：#sed ’1,2d’ fstab 就可以将fstab的前两行删除并显示出来，但是它不会改变源文件。
#Sed ‘1,2!d’ fstab 表示删除除第一行和第二行之外的所有行。
（4）Sed [options] ‘/PATTERN/command’ input_file……
&：s/l..e/&er/:表示引用前面匹配到的所有字符。
例如：sed ‘/[[:upper:]]/d’ binary.sh 表示删除所有的大写字母的行。
（5）Sed ‘/PATTERN1/,/PATTERN2/command’ input_file……
说明：这表示从第一次被PATTERN1匹配到的行到第一次被PATTERN2匹配到的中间的所有行执行command命令。
三、Sed的常用选项：
-n：只显示sed匹配到的行。其余行不显示。下文有范例。
-i ：可以直接操作原文件。默认情况下sed不会改变原文件，但是-i选项可以修改原文件，此选项应慎用。
-r：可以使用标准正则表达式。默认情况下sed只支持基本正则表达式，但是加上-r选项后则支持扩展正则表达式
-e：多脚本共用。可以同时执行多个命令。例如：
[root@localhost ~]# sed -e 's@\@H\1@g' -e 's@\(l..e\)\.@\1r.@g' test
He love His lover.
She like Her liker.
Dove love Her liker.
也可以这样用，中间用分号隔开：
[root@localhost ~]# sed 's@\@H\1@g;s@\(l..e\)\.@\1r.@g' test
四、Sed的常用命令
（1）P：模式空间中的文本在处理之前，每一次都会先显示一下；用p命令后再显示一下，即：匹配到的文本显示两次：例如：
[root@localhost ~]# sed '1,2p' fstab
/dev/vol0/root / ext3 defaults 1 1
/dev/vol0/root / ext3 defaults 1 1
/dev/vol0/home /home ext3 defaults 1 2
/dev/vol0/home /home ext3 defaults 1 2
LABEL=/boot /boot ext3 defaults 1 2
tmpfs /dev/shm tmpfs defaults 0 0
devpts /dev/pts devpts gid=5,mode=620 0 0
sysfs /sys sysfs defaults 0 0
proc /proc proc defaults 0 0
LABEL=SWAP-sda3 swap swap defaults 0 0
我们可以看到第1,2行显示了两次。如果你只想显示用sed处理的行，则可在其前加-n选项。例如：sed -n ‘1,2p’ fstab 其显示结果如下：
root@localhost ~]# sed -n '1,2p' fstab
/dev/vol0/root / ext3 defaults 1 1
/dev/vol0/home /home ext3 defaults 1 2
（2）a \：表示在模式匹配到的行后面添加新内容；
i \：表示在模式匹配到的行前面添加新内容；
/n:实现添加多行。如下例所示：
[root@localhost ~]# sed '/#/a \ This is a comment line.\nIt can be ignore.' test.sh
#!/bin/bash
This is a comment line.
It can be ignore.
#
This is a comment line.
It can be ignore.
JUSER() {
if id -u root &> /dev/null;then
echo "Exists"
else
echo "No this user."
fi
}
JUSER &> /dev/null
echo $?
这表示在#行的后面加上两行文字，如果将a换成i则表示在#行的前面添加文字。
注意：sed '/#/!i \ This is a comment line.\nIt can be ignore.' test.sh，如果在i前面加！表示对除了匹配到的行的其他行的前面添加以上两行。这样大家基本明白了a，i命令的使用方法了吧。
（3）r FILE:表示读取某一个文件。例如：
root@localhost ~]# sed '2r c.txt' c.sh #表示在c.sh的第二行添加c.txt的内容。
#!/bin/bash
#
This is my first lesson.
Think you!
line 1
line 2
line 3
[root@localhost ~]# sed '/^#/r c.txt' c.sh #表示在c.sh的#开头的行后面添加c.txt的内容。
#!/bin/bash
This is my first lesson.
Think you!
#
This is my first lesson.
Think you!
line 1
line 2
line 3
（4）w FILE: 可以将模式匹配到的行保存下来。例如：
root@localhost ~]# cat c.sh #显示c.sh中的内容
#!/bin/bash
#
line 1
line 2
line 3
[root@localhost ~]# sed -n '/^#/w cc.sh' c.sh #将c.sh文件中以#开头的行保存在cc.sh中
[root@localhost ~]# cat cc.sh #cc.sh的内容
#!/bin/bash
#
（5）s:s/PATTERN/string/[g|i] 表示搜索符号PATTERN的内容，将其替换为string。
g:表示将搜索到的内容全部替换。
i:表示将搜索到的内容忽略大小写。
如果PATTERN中含有与分隔符相同的字符时，可以将分隔符替换为其他符号。例如：s@PATTERN@string@[g|i]
范例如下：
[root@localhost ~]# cat test #显示test的内容
He love his love.
She like her like.
Dove love her like.
[root@localhost ~]# sed 's@\(l..e\)\.@\1r.@' test #在最后一个单词后面加r，注意第.
He love his lover. #前面要加转义字符\
She like her liker.
Dove love her liker.
[root@localhost ~]# sed 's@\@H\1@g' test #将以h开头的单词替换
He love His love. #为以H开头
She like Her like.
Dove love Her like.
（6）n:以覆盖的方式读去下一行。
N：以追加的方式读取下一行。例如：
[root@localhost ~]# cat test #test中的内容
He love his love.
She like her like.
Dove love her like.
four line
[root@localhost ~]# sed -n 'n;p' test #使用n时的效果
She like her like.
four line
[root@localhost ~]# sed 'n;d' test #只显示偶数行。
He love his love.
Dove love her like.
[root@localhost ~]# sed -n 'N;p' test #使用N时的效果
He love his love.
She like her like.
Dove love her like.
four line
[root@localhost ~]# sed 'N;N;s@\n@ @g' test #表示将前三行合并为一行
He love his love. She like her like. Dove love her like.
four line
[root@localhost ~]# sed '/\.$/!N;s@\n@ @g;s/bad animal/BAD ANIMAL/g' test
He love his love.
She like her like.
Dove love her like.
four line Wendy is BAD ANIMAL.
Blair is a BAD ANIMAL.
这题目较复杂：（1）/\.s/!N:表示先搜索不已点号结尾的行，（2）s@\n@ @g：将搜索到的行去掉换行符 （3）将小写的bad animal 替换为BAD ANIMAL.
（7） h：将模式空间中的内容以覆盖的方式复制到保留空间。
H：将模式空间中的内容以追加的方式复制到保留空间。
g：将保留空间的内容以覆盖的方式复制到模式空间。
G：将保留空间的内容以追加的方式复制到模式空间。例如：
[root@localhost ~]# cat newfile #显示文件中的内容
line 1
line 2
line 3
[root@localhost ~]# sed -n 'h;n;G;h;n;G;p' newfile #将文件中的行倒序排列
line 3
line 2
line 1
（8）b：跳转，掠过符合条件的行。例如：
[root@localhost ~]# sed '1b;y/123/456/' newfile
line 1
line 5
line 6
此例表示：跳过第一行，将其他各行的123替换为456；其中y表示替换的意思。
b lable：表示跳转到某个位置。例如
[root@localhost ~]# cat newfile
line 1
line
line 3
line
[root@localhost ~]# sed '/.*[[:digit:]].*/b para;s/.*/% &/;:para;s/.*[0-9].*/# &/g' newfile
# line 1
% line
# line 3
% line
此例表示，将带数字的行前添加#，不带数字前添加%；定义para为跳转符。这个参数可以随意指定。
本文只是对sed的一些常用命令和选项做介绍，其余命令可查看帮助手册。谢谢！
最近在处理一个文本，打算用sed命令来处理，但是由于经常情况下都是做简单的替换，所以对sed不是很熟悉，最近两天由于项目工作量比较小，所以就今天抽空整体学习下了sed。
abc
abc
3、sed返回码
[root@xm_41 tmp]# echo $?
1
[root@xm_41 tmp]# sed -n '/beauty/p' testfile
[root@xm_41 tmp]# echo $?
0
[root@xm_41 tmp]# sed '1,2d' testfile
dfg
jjjjjjjjj
hjk
[root@xm_41 tmp]# sed -n '/[ab]/p' testfile
abc
aaaaaaaaaa
bbbbbbbbbb
a\ 在当前行后添加一行或多行。多行时除最后一行外，每行末尾需用“\”续行
c\ 用此符号后的新文本替换当前行中的文本。多行时除最后一行外，每行末尾需用"\"续行
i\ 在当前行之前插入文本。多行时除最后一行外，每行末尾需用"\"续行
d 删除行
h 把模式空间里的内容复制到暂存缓冲区
H 把模式空间里的内容追加到暂存缓冲区
g 把暂存缓冲区里的内容复制到模式空间，覆盖原有的内容
G 把暂存缓冲区的内容追加到模式空间里，追加在原有内容的后面
l 列出非打印字符
n 读入下一输入行，并从下一条命令而不是第一条命令开始对其的处理
q 结束或退出sed
r 从文件中读取输入行
! 对所选行以外的所有行应用命令
s 用一个字符串替换另一个
p 打印行
w 将所选的行写入文件
x 交换暂存缓冲区与模式空间的内容
y 将字符替换为另一字符（不能对正则表达式使用y命令）
^ 行首定位符 /^my/ 匹配所有以my开头的行
$ 行尾定位符 /my$/ 匹配所有以my结尾的行
. 匹配除换行符以外的单个字符 /m..y/ 匹配包含字母m，后跟两个任意字符，再跟字母y的行
* 匹配零个或多个前导字符 /my*/ 匹配包含字母m,后跟零个或多个y字母的行
[] 匹配指定字符组内的任一字符 /[Mm]y/ 匹配包含My或my的行
[^] 匹配不在指定字符组内的任一字符 /[^Mm]y/ 匹配包含y，但y之前的那个字符不是M或m的行
\(..\)
保存已匹配的字符 1,20s/\(you\)self/\1r/
标记元字符之间的模式，并将其保存为标签1，之后可以使用\1来引用它。最多可以定义9个标签，从左边开始编号，最左边的是第一个。此例中，对第1到第
20行进行处理，you被保存为标签1，如果发现youself，则替换为your。
& 保存查找串以便在替换串中引用 s/my/**&**/ 符号&代表查找串。my将被替换为**my**
\< 词首定位符 /\
\> 词尾定位符 /my\>/ 匹配包含以my结尾的单词的行
x\{m\} 连续m个x /9\{5\}/ 匹配包含连续5个9的行
x\{m,\} 至少m个x /9\{5,\}/ 匹配包含至少连续5个9的行
x\{m,n\} 至少m个，但不超过n个x /9\{5,7\}/ 匹配包含连续5到7个9的行
abc
china
china
上面用符号'='作为分隔符
china china
[root@xm_41 tmp]# sed '/abc/r data' testfile
abc
china china
aaaaaaaaaa
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
abc
aaaaaaaaaa
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
[root@xm_41 tmp]# cat newdata
abc
abc
china
aaaaaaaaaa
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
china
abc
aaaaaaaaaa
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
china
aaaaaaaaaa
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
[root@xm_41 tmp]# sed '/abc/{n;s/a/q/g}' testfile
qqqqqqqqqq
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
[root@xm_41 tmp]# sed '/abc/{N;s/a/q/g}' testfile
qbc
qqqqqqqqqq
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
Abc
AAAAAAAAAA
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
引申：学习下tr命令
Abc
AAAAAAAAAA
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
abc
a
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
bc
bbbbbbbbbb
dfg
jjjjjjjjj
hjk
a
aaaaaaaaaa
abc
abc
abc
abc
dfg
dfg
dfg
[root@xm_41 tmp]# sed '/abc/h;/dfg/H;g' testfile
abc
abc
abc
abc
abc
dfg
abc
dfg
abc
dfg
abc
abc
abc
abc
abc
abc
abc
abc
abc
aaaaaaaaaa
abc
bbbbbbbbbb
abc
abc
dfg
abc
jjjjjjjjj
abc
hjk
abc
abc
aaaaaaaaaa
bbbbbbbbbb
abc
jjjjjjjjj
hjk
1:abc
2: aaaaaaaaaa
3: bbbbbbbbbb
4:
5:dfg
6: jjjjjjjjj
7:hjk
abc
abc
aaaaaaaaaa
bbbbbbbbbb
bbbbbbbbbb
dfg
dfg
jjjjjjjjj
hjk
abc
aaaaaaaaaa
abc
aaaaaaaaaa
bbbbbbbbbb
bbbbbbbbbb
dfg
jjjjjjjjj
dfg
jjjjjjjjj
hjk
sed是简单小巧但功能非常强大的工具。在上一篇博客中自己注解了sed的info文档中那些比较复杂的脚本示例，最近工作中使用到sed，复习了一下，再做一篇总结放在这里：
- sed有两块缓冲区：pattern space和hold space。pattern space中存放待处理的目标文本，hold space供程序员自己使用。
- sed处理流程：
- 清空pattern space。(如果这是对该输入流的第一次读取，则也将hold space初始化为空)
- 从输入流中读取一行，去除末尾的换行符，将其放入pattern space。
- 执 行sed脚本。sed脚本由一系列命令组成。因为sed是按行处理，所以sed命令的含义主要是“对于什么样的行，则进行什么样的处理”。例如，“把第3 行删除”，或者“如果这一行包含this，则把其中的this替换成that”。其中“包含什么样的行”由address指定，“执行什么样的处理”由 sed命令序列表达。
- 脚本执行完毕，如果输入流中还有内容，转至1，开始下一轮处理。
- 所以，学习sed，就是学习如何“指定需要处理的行”(address)，以及学习我们能使用sed“进行什么样的操作”(command)。
- 注 意的是，sed都是按行处理，即使指定的是一个address range，比如sed -e '3,7s/this/that/g'，s命令会被执行5次(从第3行到第7行每行执行一次)而不是只执行一次就将第3到第7行的所有this换成 that。可以使用sed的N命令或者其他命令读入多行文本到pattern space。
- sed使用/M或者/m来切换 到"multiple line mode"（即多行处理模式）。所谓“多行处理模式”，是指在这种模式下，元字符^不再表示字符串起始位置，而是表示换行符后面的空字符串，元字符$也不 再表示字符串末尾位置，而是表示换行符前面的空字符串。自我感觉这种模式没有任何作用，只会把问题弄得混乱，因为完全可以使用\n来匹配换行符，将其作为 普通字符用在正则表达式中。
- sed中的调试非常简便，可以使用上一篇博客中的那个python脚本来调试sed，也可以使用sed中的l命令或者p命令来输出pattern space中的内容进行调试。在以下的“去除多余空行“的方法二中使用l命令进行调试。
练习几个例子，以便将来温习：准备以下文件：
- hbwang@jcwkyl:/home/hbwang$cat test
- abc
- de f
- 1 2 345
- en d
- int main () {
- printf("hello\n");
- return 0;
- }
- last empty
- 去掉所有换行符：
- 方法一：vim打开文件，执行:1,$s/\n//即可。这里使用sed的方法：读入一行，删除换行符，再读入下一行，直到整个文件处理结束。实现如下：
- hbwang@jcwkyl:/home/hbwang$sed -e :a -e "N;s/\n//;ba" test
- abcde f1 2 345en dint main () { printf("hello\n"); return 0;}last empty
命令解释：-e参数用来添加执行命令。":a"用来设置一个名字为a的label以供后来的goto使用(sed中有两个跳转命令：b和t。b为无条件跳转，t为当上一个s命令替换成功时跳转)。"N;s/\n//;ba"用分号隔开了三条命令。在执行这些命令之前，pattern space中存放着一个输入行(其末尾的换行符已经去掉)，N命令在pattern space后面追加一个换行符并从输入流中读入下一行。此时pattern space中的内容就是输入流中的连续两行文本的拷贝，用s命令去掉换行符，然后再用b命令无条件跳转到label ":a"上继续处理后面的文本。执行结果如上所示，成功达到了目标。
这里有个细节。如果复习一下开头所说的sed的处理流程(execution cycle)，会发现每一轮开始sed都会自己删除pattern space的内容并从输入流中读取下一行。照刚才这种方法，pattern space中两行之间的换行符去掉了，但第二行末尾的换行符似乎没有机会被删除。然而实验结果证明这种方法是对的。不妨再验证一下，在每次替换后用l命令查看一下pattern space中的内容(l命令会以raw format来输出pattern space中的内容，其中特殊字符都会以其转义形式输出，例如换行符会被输出成为\n，字符串末尾会输出一个$来标记):- hbwang@jcwkyl:/home/hbwang$sed -e :a -e "N;s/\n//;l;ba" test
- abcde f$
- abcde f1 2 345$
- abcde f1 2 345en d$
- abcde f1 2 345en d$
- abcde f1 2 345en d$
- abcde f1 2 345en d$
- abcde f1 2 345en d$
- abcde f1 2 345en dint main () {$
- abcde f1 2 345en dint main () { printf("hello\\n");$
- abcde f1 2 345en dint main () { printf("hello\\n"); return \
- 0;$
- abcde f1 2 345en dint main () { printf("hello\\n"); return \
- 0;}$
- abcde f1 2 345en dint main () { printf("hello\\n"); return \
- 0;}$
- abcde f1 2 345en dint main () { printf("hello\\n"); return \
- 0;}$
- abcde f1 2 345en dint main () { printf("hello\\n"); return \
- 0;}last empty$
- abcde f1 2 345en dint main () { printf("hello\n"); return 0;}last empty
可以看到，pattern space中的内容一直没有被清除：删除第一、二行之间的换行符后，又读入第三行，删除第二、三行之间的换行符，直到整个文件处理完毕。
那如果要实现刚才设想的情况，只删除第奇数个换行符而保留第偶数个换行符，只需要让sed去除一个换行符后直接开始下一轮执行即可，用d命令可以做到：- hbwang@jcwkyl:/home/hbwang$sed -e :a -e "N;s/\n//;p;d" test
- abcde f
- 1 2 345en d
- int main () { printf("hello\n");
- return 0;}
- last empty
d命令会删除pattern space中的内容，所以在删除前先用p命令把pattern space中的内容输出出来。
- 方法二：读入整个文件，用一条命令删除所有换行符。
因为sed在每个cycle开始都会清空pattern space，所以要使用sed读入整个文件，要么在一个cycle中用一个循环把所有行都读入到pattern space，要么利用hold space不会被清空的特性，每读一行就把它添加到hold space中，整个文件读完，hold space中也就保存了整个文件的内容。sed中只支持两种跳转方式，即：- if(是目标行) { /* handle */ } else { /*非目标行 */}
- if(替换成功) { goto label; } else { /* 继续执行 */}
用第一种跳转方式读取整个文件容易些，实现如下：
- hbwang@jcwkyl:/home/hbwang$sed -e '$!{H;d}' -e '${H;x;s/\n//g;}' test
- abcde f1 2 345en dint main () { printf("hello\n"); return 0;}last empty
- 或者：
- hbwang@jcwkyl:/home/hbwang$sed -n -e '$!H' -e '${H;x;s/\n//gp}' test
- abcde f1 2 345en dint main () { printf("hello\n"); return 0;}last empty
- 或者：
- hbwang@jcwkyl:/home/hbwang$sed -n -e '$!H' -e '${H;g;s/\n//gp}' test
- abcde f1 2 345en dint main () { printf("hello\n"); return 0;}last empty
其中，"$"是最后一行地址，"$!"表示“不是最后一行”。实现1，'$!{H,d}'，表示如果不是最后一行，用H命令在hold space上添加一个换行符并把pattern space中的内容append到hold space，然后删除pattern space(如果不删除，因为我们没有指定-n选项，所以pattern space的内容会在进入下一轮cycle前输出出来)，'${H;x;s\n//g;}'表示如果是最后一行，用H命令把最后一行添加到hold space，用x命令交换pattern space和hold
space(其目的是把hold space内容放到pattern space以便s命令处理)，然后用s命令删除所有换行符。实现二，和实现一相同，不过指定了-n选项，所以需要用p命令输出自己希望输出的东西。实现三使用g命令，与x命令不同的是g命令直接用hold space的内容覆盖pattern space的内容。
- 方法一：vim打开文件，执行:1,$s/\n//即可。这里使用sed的方法：读入一行，删除换行符，再读入下一行，直到整个文件处理结束。实现如下：
- 去掉所有空行空行是只包含空白字符的行。这个处理非常简单：如果当前pattern space中只包含空白字符，删除它就可以：
- hbwang@jcwkyl:/home/hbwang$sed -e "/^[ \t]*$/d" test
- abc
- de f
- 1 2 345
- en d
- int main () {
- printf("hello\n");
- return 0;
- }
- last empty
- 去掉多余的空行
- 方法一：将连续多个空行变成一个，如果只有一个空行，则不变。有一个简单思路：如果当前行是空行，则删除当前行后续的所有连续空行。换一种描述：对所有的空行，删除其后续的所有连续空行。第二种描述更容易写出sed实现，因为sed基本功能就是“对什么样的行”进行“什么样的操作”。写出来的脚本如下：
- hbwang@jcwkyl:/home/hbwang$sed -e '/^[ \t]*$/{:a;N;s/^\([ \t]*\n\)\+/\1/;ta}' test
- abc
- de f
- 1 2 345
- en d
- int main () {
- printf("hello\n");
- return 0;
- }
- last empty
其中/^[ \t]*$/表示匹配空行，当从输入流中读取到一个空行时，就执行后面{}括起来的命令序列：继续从输入流中读取下一行，如果发现pattern space中是两个连续空行，则把这连续的两个空行替换成一个空行。
- 方法二：像冒泡排序算法那样，将相邻的两个空行替换成一个空行。实现：
- hbwang@jcwkyl:/home/hbwang$sed -e ":a; N; s/\n\([ \t]*\n\)\1/\n\1/g; ba" test
- abc
- de f
- 1 2 345
- en d
- int main () {
- printf("hello\n");
- return 0;
- }
- last empty
如果不清楚这条sed命令是如何完成任务的，可以使用l命令输出每次执行s命令前的pattern space中的内容，以理解s命令为什么写成那样：
- hbwang@jcwkyl:/home/hbwang$sed -n -e ":a ; N; l 200; ba" test
- abc\nde f$ <===执行到N时，pattern space中是abd$，执行命令N后，pattern space中是abd\nde f$
- abc\nde f\n1 2 345$
- abc\nde f\n1 2 345\nen d$
- abc\nde f\n1 2 345\nen d\n$
- abc\nde f\n1 2 345\nen d\n\n$
- abc\nde f\n1 2 345\nen d\n\n\n$
- abc\nde f\n1 2 345\nen d\n\n\n\n$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");\n return 0;$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");\n return 0;\n}$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");\n return 0;\n}\n$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");\n return 0;\n}\n\n$
- abc\nde f\n1 2 345\nen d\n\n\n\n\nint main () {\n printf("hello\\n");\n return 0;\n}\n\n\nlast empty$
以上，"l 200"表示以raw format输出pattern space的内容，200指定一行输出200个字符。
- 方法三：和方法一类似，比方法一更简单的实现：
- hbwang@jcwkyl:/home/hbwang$sed -e "/^[[:blank:]]*$/{h; s/.*//; :a; N; s/^\n[[:blank:]]*$//; ta; s/^\n//; H; x;}" test
- abc
- de f
- 1 2 345
- en d
- int main () {
- printf("hello\n");
- return 0;
- }
- last empty
这里用POSIX标准的方括号表达式[:blank:]表示空格和制表符，和方法一相同，当读到一个空行时，就执行后面的命令序列：首先把读取到的空行原样保存到hold space中去(h命令的作用)，然后s/.*//命令用来清空pattern space中的内容（GNU版本的sed另外提供了z命令来清空pattern spac），N在pattern space中append一个换行符然后从输入流中读取下一行append到pattern space，s/^\n[ \t]*$//命令用来删除空行（因为N命令会在append下一行前先在pattern space中append一个换行符，所以s命令中匹配了换行符），如果替换成功，说明方才N命令读取的确实是一个空行，则用t命令跳转到label a去循环执行以删除空行。如果替换失败，则表示N命令读取到了一个非空行，则先去掉pattern space的第一个换行符（这个换行符是被N命令自动添加的），然后用H命令将pattern space中的内容append到hold space，最后用x命令把hold space中的内容放到pattern space做为最终的处理结果，这里的x命令也可以用g命令。
- 方法一：将连续多个空行变成一个，如果只有一个空行，则不变。有一个简单思路：如果当前行是空行，则删除当前行后续的所有连续空行。换一种描述：对所有的空行，删除其后续的所有连续空行。第二种描述更容易写出sed实现，因为sed基本功能就是“对什么样的行”进行“什么样的操作”。写出来的脚本如下：
sed命令是隐性的全局命令
1.在包含字符串test的任意行上，将111替换成222
#sed '/test/s/111/222/g' sample.txt
2.以下三个命令相等，先在包含字符串test的任意行上，将111替换成222，再将字符f替换成hello
#sed '/test/s/111/222/g ; s/f/hello/g' sample.txt
#sed -e '/test/s/111/222/g' -e 's/f/hello/g' sample.txt
将要执行的所以编译命令放入在文件中
#more scher
/test/s/111/222/g
s/f/hello/g' sample.txt
#sed -f scher sample.txt
3.替换每行的第N个匹配(示例为替换第八个字符)
#sed ‘s/test/TEST/8' sample.txt
4在第三到第五行前加入hello
#sed '3,5 s/^/hello/' sample.txt
参数d: 删除数据行。最多与两个地址参数配合。
1.删除第一到三行
#sed ‘1，3d’sample.txt
2.删除带user的行
#sed ‘/user/d’sample.txt
3.删除带有a或b字符的行
#sed '/[ab]/d' sample.txt
参数a:将资料添加到指定文件后。最多与一个地址参数配合。
1.在含有FTP的行后面插入一行123
#sed -e '/FTP/a\123' sample.txt
2.在第五行后插入123
#sed -e '5 a\123' sample.txt
参数i将资料插入到指定文件前。最多与一个地址参数配合。
1.在含有FTP的行前面插入一行123
#sed -e '/FTP/i\123' sample.txt
2.在第五前后插入123
#sed -e '5 i\123' sample.txt
参数c：改变文件中的数据。最多与两个地址参数配合。
1.以使用者输入的数据取代数据
eg:将文件1到100行的数据替换成test
#sed -e '1.100c test' sample.txt
2.把a和b替换成hello
#sed '/[a b]/c\hello' sample.txt
参数p：打印出资料。最多与两个地址参数配合。
1.打印出含有a或b的行
#sed -n -e '/[ab]/p' sample.txt
参数r：读入他的档案内容到文件中。最多与一个地址参数配合。
1.将temp.txt中的内容，搬至文件中含有AA字符串的数据行后（temp.txt中有内容）
#sed -e '/AA/r temp.txt' sample.txt
参数w：读入文件中的内容存入到另一文件中（temp.txt)。最多与一个地址参数配合。
1.将文件中含test字符串的数据行，copy至temp.txt档中储存(原temp.txt中无内容）
#sed -e '/test/w temp.txt' sample.txt
参数y：转换数据中的字符。最多与两个地址参数配合。
1.将文件中的小写字母替换成大写字母。
#sed -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' sample.txt
其中前后字符个数必须相同.
参数!:表示不执行函数参数。
1.将文件中除了important字符串，其余全删除。
#sed -e '/important/!d' sample.txt
参数n：表示读入下一行数据。最多与两个地址参数配合。
解释：例如源文件为：
A
B
C
D
那么实际读入到pattern space的数据就为B D，因为他们分别为第一行A和第三行C的下一行.
1.输出源文件的偶数行数据。
#sed -n -e 'n' -e 'p' sample.txt
或#sed -n 'n;p' sample.txt
这里-n是选项。‘’中的n才是参数。-n的意思是将数据输出的控制权转给指令，即只显示处理后的结果。
利用n将下一行资料（即：偶数行）取代pattern space的资料行（奇数行）
2.输出源文件的奇数行数据。
#sed -n -e 'p' -e 'n' sample.txt
#sed -n 'p;n' sample.txt
参数q：表示跳离sed。最多与一个地址参数配合。
1.打印出含有a或b字符的行，一旦遇到数字，即刻停止打印。
#sed -n -e '/[0-9]/q' -e '/[a b]/p' sample.txt
参数=：表示印出资料的行数。最多与两个地址参数配合。
1.印出文件资料中的行数。
#sed -e ‘=’ sample.txt
参数#：表示对文字的注释。
参数N：表示添加下一笔资料到pattern space内。最多与两个地址参数配合。（添加下一笔：添加一笔资料后，继续添加这个资料的下一行数据到pattern space内）
1，将文件中的数据合并。文件内容如下：
UNIX
LINUX
#sed -e 'N' -e's/\n/\,/g' sample.txt
结果如下：
UNIX,LINUX
参数D：表示删除pattern space内的第一行资料。最多与两个地址参数配合。
参数P：打印出pattern space内的第一行资料。
#sed -n -e 'N' -e 'P' sample.txt
利用N将下一行资料（即：偶数行）添加到pattern space内，在利用P打印出奇数行。
解释过程：由于N的作用，使得每次添加一条资料到pattern space后，先不执行操作，而是继续添加这个资料的下一行到pattern space内，
然后P参数打印出第一行资料。
参数h：表示暂存pattern space的内容至hold space（覆盖）。最多与两个地址参数配合。
参数H：表示暂存pattern space的内容至hold space（添加）。最多与两个地址参数配合。
参数g：表示将hold space的内容放回至pattern space内。（覆盖掉原pattern space内的数据）
参数G：表示将hold space的内容放回至pattern space内。（添加大到原pattern space数据之后）
1.将文件中所有空行删除，并在每一行后面增加一个空行。
sed '/^$/d;G' sample.txt
2.将文件中所有空行删除，并在每一行后面增加两个空行。
sed '/^$/d;G;G' sample.txt
参数x：表示交换hold space与pattern space内的数据。
1.将文件第三行的数据替换成第一行的数据。
#sed -e '1h' -e '3x' sample.txt
参数b：
参数t：
一些示例：
1.在匹配式样test的行之前插入一空行。
#sed '/test/i\ ' sample.txt
#sed '/test/{x;p;x}' sample.txt
2.在匹配式样test的行之后插入一空行。
#sed '/test/a\ ' sample.txt
#sed '/test/G' sample.txt
3.为文中每一行进行编号。
#sed = sample.txt | sed 'N;s/\n/:/'
#sed = sample.txt | sed 'N;s/\n/\t/'
4.为文中每一行进行编号，但只显示非空行的编号。
#sed /./= sample.txt | sed '/./N;s/\n/:/'
.不匹配空。将sample.txt中所有非空行编号，然后取出不包含非空行的行及其下一行数据放入pattern space内，再将空格替换成：）
5.计算文件行数。
#sed -n '$=' sample.txt
6.字串翻转。
#sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
7，打印文档奇数行。
#sed 'n;d'
#sed 'x;$!N;x'
#sed -n 'p;n' （sed -n -e 'p' -e 'n' ）
#sed -e 'n' -e 'd' 将文件下一行（偶数行),放进pattern space中并删除。
8.打印文档偶数行。
#sed '1d;n;d;' （先删掉第一行，再像奇数行类似处理）
#sed -n 'n;p' （sed -n -e 'n' -e 'p'）
9.删除连续重复行。（可以用sort加uniq取代）
#sed '$!N; /^\(.*\)\n\1$/!P; D'
10.合并上下两行并用空格分割
#sed '$!N;s/\n/ /'
#sed -e 'N' -e 's/\n/ /g'
11.将以\符号结尾的行与下行合并并以空格分隔(拼接断行)
#sed -e :a -e '/\\$/N; s/\\\n/ /; ta'
12.按关键字拼接行。
如果某行以=开始，则合并到上一行并替代＝为空格
#sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'
13.输出匹配行的下一行 （grep -A）
#sed -n '/regexpr/{n;p;}' filename
14.显示匹配行的行号并输出匹配行的上行、匹配行、下行 （grep -N N为想显示的行数）
#sed -n -e '/regexpr/{=;x;1!p;g;$!N;p;D;}' -e h
15.删除文档中某标志区域内的关键字匹配行
删除文档中从being开到end结束的块中包含myword的行
#sed '/^begin/,/^end/{/myword/d;}' filename
16.字串解析。
1.从字串中解析出两个子串(前2各字符和后9个字符)
#echo "WeLoveChinaUnix"|sed -e 'H;s/\(..\).*/\1/;x;s/.*\(.\{9\}\)$/\1/;x;G;s/\n/ /'
We ChinaUnix
2.分解日期串
echo 20030922|sed 's/\(....\)\(..\)\(..\)/\1 \2 \3/'|read year month day
echo $year $month $day
2003 09 22
例如想把aaaa1111bbbb分成 aaaa 1111 bbbb
sed 's/\(....\)\(....\)\(....\)/\1 \2 \3/' sample.txt
\1 \2中间的部分就是想空出来的部分。
示例部分参考http://bbs.chinaunix.net/viewthread.php?tid=166936&extra=&page=1
作者：admirer
补：
sed '/aaa/,/bbb/s/yes/no/' sample.txt
将文件sample.txt中，一行中的aaa到bbb中间的yes替换成no
1.sed
[root@stu93 sed]# sed -r '/\n!G;s/(.)(.*\n)/&\2\1;//D;s/.//' abc.txt
回去查
流编辑器 stream editer,是以行为单位的处理程序
sed 流编辑器 stream editer
语法
sed [options] 'command' in_file[s]
options 部分
-n 阻止输入行自动输出
-e
-i
-f 脚本文件
-r 支持拓展正则
command 部分
'[地址1,地址2] [函数] [参数(标记)]'
定址的方法 1.数字 2.正则
数字
十进制数
1 单行
1,3 范围 从第一行到第三行
2,+4 匹配行后若干行
4,~3 从第四行到下一个3的倍数行
2~3 第二行起每间隔三行的行
$ 尾行
1! 除了第一行以外的行
2.sed -n '' /etc/passwd 阻止输入行自动显示
3.sed -n 'p' /etc/passwd
4.'cmd'
定址 函数［标记］;函数
5. [root@stu93 ~]# sed -n '1{p;p}' /etc/passwd
root:x:0:0:root:/root:/bin/bash
root:x:0:0:root:/root:/bin/bash
[root@stu93 ~]# sed -n '1p;3p' /etc/passwd
[root@stu93 ~]# sed -n '/^id/s/[0-6]/3/p' /etc/inittab
id:3:initdefault:
6 [root@stu93 ~]# cat -n /etc/passwd | sed '6,~3p'倍数行
[root@stu93 ~]# cat -n /etc/passwd | sed '6,+3p'重复行
[root@stu93 ~]# cat -n /etc/passwd | sed '6~3p'间隔行
[root@stu93 ~]# cat -n /etc/passwd | sed '6p'指定行
[root@stu93 ~]# cat -n /etc/passwd | sed '6!p'除了6行
[root@stu93 ~]# cat -n /etc/passwd | sed '$p'最后一行
[root@stu93 ~]# sed -n '/root\|seker/p' /etc/passwd 含root和seker的行
[root@stu93 ~]# sed -n '/^root/,/^adm/p' /etc/passwd 以root和adm开头的行
[root@stu93 sed]# sed '2c xyz.txt' abc.txt
aaaaaaaaaaa
xyz.txt
ccccccccccc
7. 基本正则
正则介绍
^ 行首
$ 行尾
. 除了换行符以外的任意单个字符
* 前导字符的零个或多个
.* 所有字符贪婪性取多不取少
[] 字符组内的任一字符
[^] 对字符组内的每个字符取反(不匹配字符组内的每个字符)
^[^] 非字符组内的字符开头的行
[a-z] 小写字母
[A-Z] 大写字母
[a-Z] 小写和大写字母
四则运算 ［+ - * /］不可以 ［- + * /］减号方前面就可以了
[0-9] 数字
\< 单词头 单词一般以空格或特殊字符做分隔,连续的字符串被当做单词
\> 单词尾
. 匹配除换行符职位的任意单个字符，awk中可以匹配换行符
* 匹配任意一个（包括零个）在它前面的字符
[...] 匹配方括号中的任意一个字符，^为否定匹配， -表示字符的范围
^ 作为正则表达式的第一个字符，匹配行的开始。在awk中可以嵌入换行符
$ 作为正则表达式的最后一个字符，匹配行的结尾。在awk中可以嵌入换行符
\{n,m\} 匹配出现的n到m次数， \{n\}匹配出现n次。\{n,\}匹配至少出现n次
\ 转义字符
\< \>单词
sed '/正则/'
8. 扩展正则
sed -r '拓展正则'
grep -E
egrep
grep \
+ 匹配前面的正则表达式的一次出现或多次出现
? 匹配前面的正则表达式的零次出现或一次出现
| 可以匹配前面的或后面的正则表达式（替代方案）
() 对正则表达式分组
{n,m} 匹配出现的n到m次数， {n}匹配出现n次。{n,}匹配至少出现n次，大多数awk都不支持，用于POSIX egrep和POSIX awk
[root@stu93 ~]# cat 4
egg
cow
[root@stu93 ~]# sed -e 's/egg/cow/' -e 's/cow/pig/ ' 4
pig
pig
[root@stu93 ~]# sed -e 's/cow/pig/' -e 's/egg/cow/' 4
cow
pig
此时应该考虑顺序问题 可以变换下替换顺序
扩展正则 加 -r 参数 或转义
sed -n '/roo\?/p' /etc/passwd
sed -rn '/roo?/p' /etc/passwd
? 前导字符零个或一个
+ 前导字符一个或多个
abc|def abc或def
a(bc|de)f abcf 或 adef
x\{m\} x出现m次
x\{m,\} x出现m次至多次(至少m次)
x\{m,n\} x出现m次至n次
函数
增删改
a\ 后插
c\ 替换
i \前插
d 删除
这些命令每一个都要求后面加一个反斜杠用于转义第一个行尾
输入输出
p 打印匹配的行 一般和 -n 参数连用,以屏蔽默认输出
r 从文件中读入
w 写入到文件中
y 字符替换(变形)
q 退出
控制流
! 命令取反 例: 1!d 删除第一行以外的行
{} 命令组合 命令用分号分隔 {1h;G} 可以理解为 -e 参数的另一种写法
= 打印行号(输入行的号码,而非处理的次数行号) 例如： sed -n '2{=;p}' infile
n 读入下一行到模式空间 例:'4{n;d}' 删除第5行
N 是追加下一行到模式空间，再把当前行和下一行同时应用后面的命令
R 两个文件个行输出
r 输出一行之后另个文件全不输出之后再输出前一个文件的另一行
c
i 对内存操作
P 输出当前模式空间中匹配的第一部分(第一个字符到第一个换行符为止)
D 从第一个字符删除到第一个换行符结束 它不会导入新的输入行 而是返回输入行顶部继续执行
[root@stu93 ~]# sed -n 's/root/ABCDEF/gp' /etc/passwd
ABCDEF:x:0:0:ABCDEF:/ABCDEF:/bin/bash
operator:x:11:0:operator:/ABCDEF:/sbin/nologin
[root@stu93 ~]# sed -n 's/root/ABCDEF/2p' /etc/passwd
root:x:0:0:ABCDEF:/root:/bin/bash
[root@stu93 ~]# sed -n 's/root/ABCDEF/3p' /etc/passwd
root:x:0:0:root:/ABCDEF:/bin/bash
[root@stu93 ~]# sed -n 's/root/ABCDEF/gp' /etc/passwd
ABCDEF:x:0:0:ABCDEF:/ABCDEF:/bin/bash
operator:x:11:0:operator:/ABCDEF:/sbin/nologin
[root@stu93 ~]#cat a.txt
123
123
123
[root@stu93 ~]#sed -r '$!N; /^(.*)\n\1$/!P;D' a.txt
123
高级命令
NDP sed -r '$!N;/^(.*)\n\1$/!p;D'
[root@stu93 ~]# cat a
this is the unix
system and unix is like the
unix system
[root@stu93 ~]# sed 'N;s/\n/''/;s/ system/ opting system/;P;D' a
this is the unix opting system and unix is like the
unix opting system
：
替换
s 字符串替换 s/old/new/
$ sed -n 's/root/ABCDEF/p' /etc/passwd
ABCDEF:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/ABCDEF:/sbin/nologin
定址
[root@stu93 ~]# cat a.txt
beijing ,chain
shanghai ,chain
aaa
tianjin .chain
bbb
chengdu .chain
[root@stu93 ~]# sed '/^aaa/,/^bbb/{s/tianjin/TJ/;s/chain/CN/}' a.txt
beijing ,chain
shanghai ,chain
aaa
TJ .CN
bbb
chengdu .chain
[root@stu93 sed]# sed -n '1,3s/root/AA/gp' passwd
AA:x:0:0:AA:/AA:/bin/bash
[root@stu93 ~]# sed '=' /etc/passwd | sed 'N;s/\n/ /' 每两行处理为一行
三行处理成一行
[root@stu93 ~]# cat b.txt
2010-09-23
192.168.0.1
shutdown
2010-09-22
192.168.0.2
reboot
2010-09-24
192.168.0.3
init 0
[root@stu93 ~]# sed 'N;N; s/\n/ /g' b.txt
2010-09-23 192.168.0.1 shutdown
2010-09-22 192.168.0.2 reboot
2010-09-24 192.168.0.3 init 0
连着的多个空行变为一个空行输出
[root@stu93 ~]# cat c.txt
1111111
3333
666666666
100000000
[root@stu93 ~]# sed '/^$/{N; /^\n$/D }' c.txt D 删除第一个空行
[root@stu93 ~]# sed '/^$/d;$!G' c.txt $!G表示最后一行不执行G规则
1111111
3333
666666666
100000000
[root@stu93 ~]# time sed '2q' a.txt q 对大文件操作较快
[root@stu93 ~]# time sed -n '1,2p' a.txt 对小文件可以
\(\) 保存被匹配的字符 以备反向引用\N时使用 最多9个标签 标签顺序从左至右
& 替换时使用,在不定义标签时使用(反向引用)
试做：
删除第一个单词
删除最后一个单词
将第一个单词和最后一个单词兑换位置
y 字符替换(变形)
工作模式 模式空间和保持空间介绍
[root@stu93 ~]# sed '1{p;p}' a.txt
11111111
11111111
11111111
22222222
33333333
44444444
55555555
66666666
置换 模式空间和保持空间(暂存空间)
h 把模式空间内容覆盖到保持空间中
H 把模式空间内容追加到保持空间中
g 把保持空间内容覆盖到模式空间中
G 把保持空间内容追加到模式空间中
x 交换模式空间与保持空间的内容
[root@stu93 ~]# cat test.sh
1111111
2222222
3333333
4444444
[root@stu93 ~]# sed '{1h;2,3H;4G}' ./test.sh
1111111
2222222
3333333
4444444
1111111
2222222
3333333
[root@stu93 ~]# sed '{1h;2x;3g;$G}' ./test.sh
1111111
1111111
2222222
4444444
2222222
#
[root@stu93 sed]# sed '1H;2,3{G};$g' xyz.txt
1111111
2222222
1111111
3333333
1111111
1111111
[root@stu93 sed]# sed '1h;2,3H;$!G' xyz.txt
1111111
1111111
2222222
1111111
2222222
3333333
1111111
2222222
3333333
4444444
cmd qianhou
sed null\n
1h 11111111
$!G 1111 11111111
==>1111 1111
2H 22221111 2222
$!G 2222 1111 2222 11112222
==>2222 1111 2222
3H 33331111 2222 3333
$!G 3333 1111 2222 3333
==>3333 1111 2222 3333
$!G 4444
[root@stu93 sed]# tac xyz.txt
4444444
3333333
2222222
1111111
[root@stu93 sed]# sed '4G;2,3{G;h;d};1{h;d};' xyz.txt
[root@stu93 sed]# sed '4G;3{G;h;d};2{G;h;d};1{h;d};' xyz.txt
4444444
3333333
2222222
1111111
4G 44444/n/n
=>4444/n
3{G;h;d} 3333 /n
3333 3333
3333
==>3333
2{G;h;d} 2222
2222 2222
2222
==>2222
1{h;d} 1111 1111
1111
==>1111
[root@stu93 sed]# sed '1!G;h;$!d' xyz.txt
试做题
奇数行和偶数行互换
[root@stu93 ~]# cat 3 .txt
1
2
11
22
111
222
[root@stu93 ~]# sed -e '/1/{h;d}' -e '/2/{G}' 3.txt
每行的后面加空行
[root@stu93 ~]# sed 'G' 3.txt
每行的后面加2个空行
[root@stu93 ~]# sed 'G;G' 3txt
显示文件的前10行
[root@stu93 ~]# sed -n '1,10p' /etc/passwd
每行的前面加空行
[root@stu93 ~]# sed -e 'x;P;x' 3.txt
将第一行插入到每个偶数行的后面
$ sed '1h;0~2G' a.txt
11111111
22222222
11111111
33333333
44444444
11111111
55555555
66666666
11111111
$
颠倒输出
[root@stu93 ~]# sed '1!G;h;$!d' rev.txt
[root@stu93 ~]# sed -n '1!G;h;$p' 3
xyz
def
abc
脚本方法
四 编写sed脚本
模式空间
sed -e ‘s/pig/cow/’ -e ‘s/cow/horse/’
sed -e ‘s/cow/horse/’ -e ‘s/pig/cow/’
寻址上的全局透视
全局操作 范例file2.txt
$ sed '/Beijing/s/CN/China/g' file2.txt
删除所有的行
d
删除文件的最后两行
[root@stu93 ~]# sed 'N;$!P;$!D;$d' c.txt
只删除第一行
1d
使用寻址符号$，删除最后一行
$d
删除空行，正则表达式必须封闭在斜杠//当中
/^$/d
删除.TS和.TE标记的tbl输入
/^\.TS/,/^\.TE/d
删除第五行到结尾所有的行
5,$d
混合使用行地址和模式地址
$ sed '1,/^$/d' file2.txt
删除除了那些行以外的行
1，5!d
分组命令
/^\.TS/,/^\.TE/{
/^$/d
}
/^\.TS/,/^\.TE/{
/^$/d
s/^\.ps 10/.ps 8/
s/^\.vs 12/.vs 10/
}
-f 参数 引用脚本(脚本的末尾不能有空格制表符或其他文本)
# cat sed.sh
2,4d
s/777/seker/
s/999/seker&seker/
# sed -f sed.sh test.txt
1111111
5555555
6666666
seker7777
8888888
seker999seker9999
#
在脚本中指明解释器为sed
# cat sed.sh
#!/bin/sed -f
2,4d
s/777/seker/
s/999/seker&seker/
# ./sed.sh test.txt
1111111
5555555
6666666
seker7777
8888888
seker999seker9999
#
高级流控命令 b分支 t测试
分支命令用于无条件转移,测试命令用于有条件转移
分支 branch
跳转的位置与标签相关联
如果有标签则跳转到标签所在的后面行继续执行
如果没有标签则跳转到脚本的结尾处.
标签 以冒号开始后接标签名 不要在标签名前后使用空格
跳转到标签指定位置
:top
cmd1
cmd2
/aa/b top
cmd3
cmd1
/aa/b end
cmd2
:end
cmd3
cmd1
/aa/b dothree
cmd2
b
:dothree
cmd3
[root@stu254 ~]# grep seker /etc/passwd
seker:x:500:500::/home/seker:/bin/bash
[root@stu254 ~]#
[root@stu254 ~]# grep seker /etc/passwd |sed ':top;s/seker/blues/;/seker/b top;s/5/555/'
blues:x:55500:500::/home/blues:/bin/bash
[root@stu254 ~]#
命令分析:让单次替换(cmd1)循环执行,直到条件不满足
:top; 定义一个top标签
s/seker/blues/; cmd1
/seker/b top; 如果模式匹配则跳转到top标签
s/5/555/ 当上一条模式不匹配时,既会继续执行这一条
选择执行
[root@stu254 ~]# grep 'seker' /etc/passwd |sed 's/seker/blues/;/seker/b end;s/5/555/;:end;s/5/666/'
blues:x:66600:500::/home/seker:/bin/bash
[root@stu254 ~]#
zorro:x:501:501::/home/zorro:/bin/bash
[root@stu254 ~]# grep 'zorro' /etc/passwd |sed 's/seker/blues/;/seker/b end;s/5/555/;:end;s/5/666/'
zorro:x:6665501:501::/home/zorro:/bin/bash
[root@stu254 ~]#
命令分析: 执行cmd1,再去模式匹配,成功则跳转到cmd3开始执行,否则(模式不匹配)会按命令顺序逐个执行
s/seker/blues/; cmd1
/seker/b end;
s/5/555/; cmd2
:end;
s/5/666/ cmd3
另一种选择执行
[root@stu254 ~]# grep 'seker' /etc/passwd |sed 's/seker/blues/;/seker/b end;s/5/555/;b;:end;s/5/666/'
blues:x:66600:500::/home/seker:/bin/bash
[root@stu254 ~]# grep 'zorro' /etc/passwd |sed 's/seker/blues/;/seker/b end;s/5/555/;b;:end;s/5/666/'
zorro:x:55501:501::/home/zorro:/bin/bash
[root@stu254 ~]#
命令分析: 执行cmd1;模式匹配cmd2成功则执行cmd3;否则执行cmd2,再跳转到脚本末尾
s/seker/blues/; cmd1
/seker/b end;
s/5/555/; cmd2
b;
:end;
s/5/666/ cmd3
测试命令,如果前一个替换命令执行成功则跳转到脚本末尾 (case结构)
[root@stu254 ~]# grep 'seker' /etc/passwd |sed 's/seker/ABC/;t;s/home/DEF/;t;s/bash/XYZ/'
ABC:x:500:500::/home/seker:/bin/bash
[root@stu254 ~]# grep 'zorro' /etc/passwd |sed 's/seker/ABC/;t;s/home/DEF/;t;s/bash/XYZ/'
zorro:x:501:501::/DEF/zorro:/bin/bash
[root@stu254 ~]#
与标签关联,跳转到标签位置
[root@stu254 ~]# grep 'seker' /etc/passwd |sed 's/seker/ABC/;t end;s/home/DEF/;t;:end;s/bash/XYZ/'
ABC:x:500:500::/home/seker:/bin/XYZ
[root@stu254 ~]#
[seker@seker ~]$ grep 'zorro' /etc/passwd |sed 's/seker/ABC/;t end;s/home/DEF/;t;:end;s/bash/XYZ/'
zorro:x:501:501::/DEF/zorro:/bin/bash
[seker@seker ~]$
runsed 对输入文件作永久性改变
#!/bin/bash
for x
do
echo "editing $x: \c"
if test "$x" = sedscr;then
echo "not editing sedscript"
elif test -s $x;then
sed -f sedscr $x > /tmp/$x$$
if test -s /tmp/$x$$
then
if cmp -s /tmp/$x$$
then
echo "file not changed: \c"
else
mv $x.bak # save original, just in case
cp /tmp/$x$$ $x
fi
echo "done"
else
echo "Sed produced an empty file\c"
echo "- check your sedscript."
fi
rm -f /tmp/$x$$
else
echo "original file is empty."
fi
done
echo "all done"
sed学习总结
(2012-03-30 18:42:11)
| s | d | a | i | c | p | l | r | w | y | ! | n | q | = | # | N | D | P | h | H | g | G | x | b | t |
s
函数参数 s 表示替换(substitute)文件内字串。其指令格式如下:[address1[
,address2]] s/pattern/replacemen/[flag].函数参数 s 最多与两个位址参数配合
pattern : 它为 reguler expression
字串。它表示文件中要被替换的字串
replacement : 它为一般字串。但其内出现下列字元有特别意义:
& : 代表其前
pattern 字串。例如 sed -e 's/test/& my car/' 指令中 ,
& 代表 pattern 字串 "test"。故执行後 , 资料档的 "test" 被替换成
"test my car"
\n : 代表 pattern 中被第 n 个 \(
、\)(参照[附录 A]) 所括起来的字串。例如sed -e 's/\(test\) \(my\) \(car\)/[\2 \3
\1]/' 指令中 , \1 表示 "test"、\2 表示 "my"、\1 表示 "car" 字串。故执行後 , 资料档的
"test my car" 被替换成 "[my car test]"
\ : 可用它来还原一些特殊符号(如上述的
& 与 \ )本身字面上的意义 , 或用它来代表换行。
flag : 主要用它来控制一些替换情况:
当 flag 为 g 时 ,
代表替换所有符合(match)的字串
当 flag 为十进位数字 m 时 , 代表替换行内第 m
个符合的字串
当 flag 为 p 时 , 代表替换第一个符合
pattern 的字串後 , 将资料输出标准输出档
当 flag 为 w wfile 时 , 代表替换第一个符合
pattern 的字串後 , 输出到 wfile 档内(如果 wfile 不存在 , 则会重新开启名为 wfile
的档案)
当没有 flag 时 , 则将资料行内第一个符合
pattern 的字串以 replacement 字串来替换
delimiter : 在 "/pattern/replace/[flag] " 中 "/"
被当成一 delimiter。除了空白(blank)、换行(newline) 之外,使用者可用任何字元作为
delimiter。例如下述编辑指令s#/usr#/usr1#g,上述命令中 \verb|#| 为 delimiter。如果用 "/"
做 delimiter , 则 sed 会将 pattern 与 replacement 中的 "/"当成 delimiter
而发生错误
例:替换 input.dat 档内 "1996" 字串成 "1997" , 同时将这些资料行存入
year97.dat 档内
说明:用函数参数 s 指示 sed 将 "1996" 字串替换成 "1997" , 另外用 s
argument 中的 flag w 指示sed将替换过的资料行存入 year97.dat 档内
sed -e 's/1996/1997/w year97.dat' input.dat
语法格式
s/Regexp/Replacement/Flags
分隔字符/可以用其他任意一个单字符代替，若在Regexp或Replacement中有分隔字符，必须要进行转义操作。
功能说明
命令s可能是sed最重要的命令，基本功能就是：用指定的Regexp试图匹配模版空间中的数据，若成功，就用指定的Replacement替换模版空间中匹配的部分。
替换选项说明
1、\n
替换正则表达式Replacement中可含有后向引用中的\n(n是1至9)，引用前面定义的子表达。
2、&
代表模版空间中的整个匹配部分。
3、\L GNU的扩展功能
将在其后的替换部分转换成小写字母，直到发现一个\U或\E。
4、\l GNU的扩展功能
将下一个字符转换成小写字母。
5、\U GNU的扩展功能
将在其后的替换部分转换成大写字母，直到发现一个\L或\E。
6、\u GNU的扩展功能
将下一个字符转换成大写字母。
7、\E GNU的扩展功能
停止由\L或\U指示开始的大小写转换。
所以替换正则表达式Replacement中要含有字符\或&或字符串\n的本身，必须要进行转义操作，即变成：\\、\&和的形式。
注意：为什么在Replacement中不用重复元字符：\+、\?、\{、\}
d
函数参数 d 表示删除资料行,其指令格式如下:[address1[ ,address2]]
d 对上述格式有下面几点说明:函数参数 d 最多与两个位址参数配合
sed 执行删除动作情况如下:将 pattern space
内符合位址参数的资料删除,将下一笔资料读进 pattern space重新执行 sed script
删除命令，清空模版空间中的数据，立即开始sed 下一处理循环。
a
函数参数 a 表示将资料添加到文件中。其指令格式如下: [address1]
a\ 使用者所输入的资料 对上述格式有下面几点说明:函数参数 a
最多与一个位址参数配合
函数参数 a 紧接着 "\"
字元用来表示此行结束,使用者所输入的资料必须从下一行输入。如果资料超过一行 , 则须在每行的结尾加入"\"
sed 执行添加动作情况如下 : 当 pattern space 内资料输出後 , sed
跟着输出使用者所输入的资料
例:添加 "多工作业系统" 在含 "UNIX" 字串的资料行後。
sed -e '/UNIX/a\
多工作业系统
' input.dat
i
函数参数 i 表示将资料插入文件中。其指令格式如下:[address1]
i\ 使用者所输入的资料 对上述格式有下面几点说明:函数参数 i
最多与一个位址参数配合
函数参数 i 紧接着 "\" 字元用来表示此行结束 ,
使用者所输入的资料必须从下一行输入。如果资料超过一行 , 则须在每行的结尾加入"\"
sed 执行插入动作的情况如下 : 在 pattern space 内资料输出前 , sed
先输出使用者所输入的资料
例:将 "文章版权属於中央研究院" 插在 input.dat 档中含 "院长 : 李远哲"
的资料行之前
sed 命令列如下:
sed -e '/院长 : 李远哲/i\
文章版权属於中央研究院
' input.dat
c
函数参数 c 表示改变文件中的资料。其格式如下:[address1[ ,address2]]c\
使用者所输入的资料 对上述格式有下面几点说明:函数参数 c 最多与两个位址参数配合
函数参数 c 紧接着 "\" 字元用来表示此行结束 ,
使用者所输入的资料必须从下一行输入。如果资料超过一行 , 则须在每行的结尾加入"\"
sed 执行改变动作的情况 : 在 pattern space 内资料输出时 , sed
改变它成为使用者所输入的资料
p
显示命令，作用是显示模版空间的数据，通常和命令行选项-n 同时使用。
常用在多个命令要对相同 sed 地址行进行处理时
函数参数 p 表示印出资料。其指令格式如下:[address1[ , address2]]
p 对上述格式有下面几点说明:函数参数 p 最多与两个位址参数配合
sed 执行印出动作的情况如下 : sed 拷备一份 pattern space
内容至标准输出档
l
函数参数 l , 除可将资料中的 nonprinting character 以
ASCII码列出外 , 其於均与函数参数 p 相同。例如 , 将下面 input.dat 档中的 ^[ 以 ASCII
码印出
The Great ^[ is a movie starring Steve
McQueen.
执行命令 sed -e 'l' input.dat 後 , 则输出结果如下:
The Great \003 is a movie starring Steve
McQueen.
The Great is a movie starring Steve
McQueen.
上述第二行资料为 sed 的自动输出
r
函数参数 r 表示读入它档案内容到文件中。其指令格式如下:[address1] r
它档名称 对上述格式有下面几点说明:函数参数 r 最多与一个位址参数配合
在指令中 , 函数参数 r 与它档名称间 , 只能有一空格
sed 执行读入动作的情况如下 : 在 pattern space 内资料输出後 , sed
读出它档的内容跟着输出。当它档不存在时,sed 照样执行其它指令而不会有任何错误讯息产生
w
函数参数 w 表示将文件中的写到它档内。其指令格式如下:[address1[
,address2]] w 它档名称 对上述格式有下面几点说明:函数参数 w
最多与两个位址参数配合
在指令中 , 函数参数 w 与它档名称间 , 只能有一空格
sed 执行写出动作的情况如 : 将 pattern space 内资料写到它档内。资料写入时 ,
会取代(overwrite)原来档案内的资料。另外 , 当它档不存在时 , sed 会重新产生(creat)它
y
函数参数 y 表示转换资料中的字元。其指令格式如下:[address1[ ,address2]]y
/xyz.../abc.../ 对上述格式有下面几点说明:函数参数最多配合两个位址参数
指令中 , /abc.../xyz.../(x、y、z、a、b、c 代表某些字元) 为 y 的
argument 。其中 abc... 与 xyz... 的字元个数必须相同
sed 执行转换时 , 将 pattern space 内资料内的 a 字元转换成 x 字元 、b
字元转换成 y 字元 、c 字元转换成 z 字元 ...。
!
函数参数 ! 表示不执行函数参数。当有如下指令时,[address1[ , address2]]
! 函数参数表示,对符合位址参数之资料不执行函数参数。例如删除,除了含 "1996" 字串,所有资料行,则执行如下命令sed -e
'/1996/!d' input.dat
n
函数参数 n 表示读入下一行资料。其指令格式如下:[address1[ ,address2]]
n 对格式有下面几点说明:函数参数 n 最多配合两个位址参数
sed 执行读入下一行动作的情况如下:输出在 pattern space 的资料,将下一笔资料读到
pattern space,执行下一个编辑指令。
新行命令，作用是显示模版空间的数据(无选项-n时)后，sed立即读取新的一行来取代模版空间
的数据，此时若没有待输入行了，sed直接退出，不再处理任何命令。
例:输出 input.dat 档内偶数行资料。假设 input.dat 档内容如下:
The
UNIX
Operation
System
说明: 在命令列上以选项 -n , 将资料输出的控制权转给指令,利用函数参数 n
将下一行资料(偶数行)取代 pattern space 内的资料行(奇数行),利用函数参数 p 将 pattern space
内的资料(偶数行)输出,最後 , 整个输出只有原先档内的偶数行资料
sed 命令列如下:sed -n -e 'n' -e 'p' infro.dat
执行上述命令後,输出的结果如下 :
UNIX
System
q
函数参数 q 表示跳离 sed 。其指令格式如下:[address1]
q 对上述格式有下面几点说明:函数参数 q 最多配合一个位址参数
sed 执行跳离动作时 , 它停止输入 pattern space 资料 ,
同时停止资料送到标准输出档
退出命令，只接受单一匹配的sed地址。表示退出sed，不再处理任何命令或输入，若没有选项
-n ，在退出前会显示当前模版空间中的数据。
退出并返回指定的退出代码，是GNU的扩展功能。
例 :
题目: 对文件档执行 script_file 内的编辑指令 , 除非遇到 "Linux"
字串
sed 命令列如下:sed -e '/Linux/q' -f script_file
input.dat
=
函数参数 = 表示印出资料的行数。其指令格式如下: [address1 ,[address2]]
= 对上述格式有下面几点说明:函数参数 = 最多配合两个位址参数
执行时 , 行数将在资料输出前先输出
例:印出 input.dat 档内资料行数。假设 input.dat 的内容如下:
The UNIX
Operating System
说明:用函数参数 = 来印出资料的行数 sed 命令列如下:
sed -e '=' input.dat
执行上述命令後 , 输出的结果如下:
1
The UNIX
2
Operating System
#
在 script file 内 , 函数参数 # 後的文字为注解。当注解文字超过多行时 ,
其行间须以 "\" 换行字元相隔
注释命令，不允许有sed地址。用于对sed脚本的注解和说明，此字符后内容即为注释直到行尾。
1、有些版本的sed只允许脚本有一行注释，且必须是第一行，即脚本的第一个字符必是# 。
2、当sed脚本的前两个字符是#n时，表示强制打开选项-n
(不自动显示)；同时考虑上面要求，
注释若是以#n开始的，必须改成#N或# n的形式。
N
函数参数 N 表示添加下一笔资料在 pattern space
内。其指令格式如下:[address1 ,[address2]] N
对上述格式有下面几点说明:函数参数 N 最多配合两个位址参数
sed 执行时 , 将下一行资料读入并添加在 pattern space 内 ,
资料行间以换行字元(embedded newline character)分隔。此外 , 在替换时 , 换行字元可用 \n 来
match
例:将下述两行资料合。假设 input.dat 的内容如下:
The UNIX
Operating System
说明:先利用函数参数 N 将两行资料置於 pattern space内,再利用函数参数 s/\n/
/ 将两行资料间的分隔号 \n 以空白替代 , 如此两行资料变成一行输出
sed 命令列如下: sed -e 'N' -e 's/\n/ /' input.dat
D
函数参数 D 表示删除 pattern space
内的第一行资料。其指令格式如下:[address1,address2]D 对上述格式有下面几点说明:函数参数 D
最多配合两个位址参数
函数参数 D 与 d 的比较如下:当 pattern space 内只有一资料行时 , D 与 d
作用相同。当 pattern space 内有多行资料行时D 表示只删除 pattern space 内第一行资料 ; d
则全删除。D 表示执行删除後 , pattern space 内不添加下一笔资料 , 而将剩下的资料重新执行 sed script ;
d 则读入下一行後执行 sed script
P
函数参数 P 表示印出 pattern space 内的第一行资料。其指令格式如下:
[address1,address2] P 对上述格式有下面几点说明:函数参数 P
最多配合两个位址参数
P 与 p , 除了面对的 pattern space 内的资料行数不同外 ,
其它均相同
例:输出 input.dat 档内奇数行资料。假设 input.dat 档内容如下:
The
UNIX
System
说明: 在命令列上以选项 -n , 将资料输出的控制权转给指令。利用函数参数 N 将偶数行添加至
pattern space 内奇数行後。利用函数参数 P 将 pattern space 内的第一行(奇数行)输出。在奇数行输出後 ,
pattern space 内剩下的资料行(偶数行)则被放弃输出。最後 , 整个输出只有原先的奇数行资料。
sed 命令:sed -n -e 'N' -e 'P' infro.dat
执行上述命令後 , 输出的结果如下:
The
System
h
函数参数 h 表示暂存 pattern space 的资料至 hold
space。其指令格式如下:[address1 ,[address2]] h
对上述格式有下面几点说明:函数参数 h 最多配合两个位址参数
sed 执行暂存动作时 , 会盖掉(overwrite) hold space 内原来的资料,当
sed 全部执行结束时 , hold space 内资料会自动清除
H
函数参数 H 与 h 唯一差别是 , sed 执行 h 时 , 资料盖掉(overwrite)
hold space 内原来的资料 , 而 H , 资料则是 "添加(append)" 在 hold space 原来资料後。
g
函数参数 g 表示与函数参数 h 相反的动作 , 它表示将 hold space 内资料放回
pattern space 内。其指令格式如下:[address1,address2]g 函数参数 g
最多配合两个位址参数
sed 执行放回动作时 , 资料盖掉(overwrite)pattern space
内原来的资料
G
函数参数 G 与 g 唯一差别是 , sed 执行 g 时 , 资料盖掉(overwrite)
pattern space 内原来的资料 , 而 G , 资料则是 "添加(append)" 在 pattern space
原来资料後
x
函数参数 x 表示交换 hold space 与 pattern space
内的资料。其指令格式如下: [address1 ,[address2]] x 函数参数 x
大部份与其它处理 hold space 的函数参数一起配合
例如 , 将 input.dat 档内第 1 行资料取代第 3 行资料。此时 , 用函数参数 h
与 x 来配合。其中 , 以函数参数 h 将第 1 资料存入 hold space ; 当第 3 行资料出现在Pattern
space , 以函数参数 x 交换 hold space 与 pattern space 的内容。如此 , 第 3 行资料就被第 1
资料替代
其命令列如下:sed -e '1h' -e '3x' input.dat
b、:label
函数参数 : 与函数参数 b 可在 sed script 内建立类似 BASIC 语言中 GOTO
指令的功能。其中 , 函数参数 : 建立标记;
函数参数 b 将下一个执行的指令 branch 到标记处执行。函数参数 : 与 b , 在
script file 内配合的情况如下 [address1,[address2]]b
[记号]
如果指令中函数参数 b 後没有记号 , 则 sed 将下一个执行的指令 branch 到
script file 的最後
例:将 input.dat 档内资料行的开头字母重覆印 40 次。假设 input.dat
档的内容如下:
A
B
C
说明: 用指令 b p1 与 :p1 构成执行增加字母的圈(loop) , 同时在字母出现 40
个时 , 也用指令 b 来跳出圈。下面就以档内第一行资料 "A" 为例 , 描述它如何连续多添加 39 个 "A"
在同一行:
用指令 s/A/AA/将 "A" 替换成 "AA".用指令 b p1 与 :p1
构成圈(loop) , 它目的使上述动作被反覆的执行。每执行一次圈 , 则资料行上的 "A" 就多出一个。例如 , 第一次圈资料行变成
"AA" , 第二次圈资料行变成 "AAA" ...
用指令 [ABC]\{40\}/b(解[15]) 来作为停止圈的条件。当资料行有连续 40 个 A
出现时 , 函数参数 b 将执行的指令跳到最後 , 停止对此行的编辑。同样 , 对其它资料行也如同上述的方式执行.
sed 命令列如下:
sed -e '{
:p1
/A/s/A/AA/
/B/s/B/BB/
/C/s/C/CC/
/[ABC]\{40\}/b
b p1
}' input.dat
t
基本上 , 函数参数 t 与 函数参数 b 的功能类似 , 除了在执行 t 的 branch 前
, 会先去测试其前的替换指令有没有执行替换成功外
其中 , 与函数参数 b 不同处在於 , 执行函数参数 t branch 时 ,
会先检查其前一个替换指令成功与否。如成功 , 则执行 branch ; 不成功 , 则不 branch ,
而继续执行下一个编辑指令
例将 input.dat 档中资料 A1 替换成 C1、C1 替换成 B1、B1 替换成
A1。input.dat 档的内容如下:
代号
B1
A1
B1
C1
A1
C1
说明 : input.dat 档中全部资料行只需要执行一次替换动作 , 但为避免资料被替换多次,
使每行资料替换一次後能立即用函数参数 t 跳离替换编辑
sed 命令列:
sed -e '{
s/A1/C1/
t
s/C1/B1/
t
s/B1/A1/
t
}' input.dat
{ commands }
组命令。作用是将多个命令用字符对( {} )括起来，形成一组命令。
\+ 与星号(*)相同，只是至少重复1次。是GNU的扩展功能
\? 与星号(*)相同，只是最多重复1次。是GNU的扩展功能
\{i\} 与星号(*)相同，只是重复指定的i次,i的值必须介于0至RE_DUP_MAX(含)之间。RE_
DUP_ MAX是POSIX定义的符号型常数，可通过getconf命令取得，最小值为255
\{i,j\} 与星号(*)相同，只是重复i至j次
\{i, \} 与星号(*)相同，只是至少重复i次
\(regexp\)
将regexp看作一个整体，用于：1、重复匹配中，如\(abc\)+匹配至少有一个整体abc的字符串;2、定义后向引用的子表达式
regexp1\|regexp2 用在相邻的正则表达式之间，表示匹配这些正则表达式中任一个都可以。匹配是从左向右开始的，一旦匹配就不再尝试下一个正则表达式。是GNU的扩展功能。
regexp1regexp2 匹配regexp1和regexp2的连接结果
GNU对转义字符的功能扩展
编号 转义字符 功能说明
1 \a 产生或匹配一个BEL字符，响铃作用，ASCII
7 。
2 \f 产生或匹配一个换页字符，ASCII
12 。
3 \n 产生或匹配一个换行字符，ASCII
10 。
4 \r 产生或匹配一个回车字符，ASCII
13 。
5 \t 产生或匹配一个水平Tab字符，ASCII
9 。
6 \v 产生或匹配一个垂直Tab字符，ASCII
11 。
7 \cX
产生或匹配Control-X，X是任意字符。精确结果是：若X是小写字母，就转成对应的大写字母。将X的ASCII值的第7bit位(从右向左)求反：\cz变为x1A，\c{变为x3B，\c;变为x7B
8 \dXXX 产生或匹配一个ASCII码是十进制XXX的字符。
9 \oXXX 产生或匹配一个ASCII码是八进制XXX的字符。
10 \xXX 产生或匹配一个ASCII码是十六进制XX的字符。
11 \w 匹配任意一个单词字符(字母、数字和下划线)。
12 \W 匹配任意一个非单词字符。
13 \b 匹配一个单词的边界符：字符的左边是一个单词字符，并且右边是一个非单词字符，反之亦然。？？？？？？？
14 \B 匹配除单词边界符外所有字符：字符的左边和右边同时是单词字符或非单词字符。？？？？？？？
15 \` 匹配模版空间的开头，在多行模式时，不同于字符^。？？？？？？？
16 \’ 匹配模版空间的结束，在多行模式时，不同于字符$。？？？？？？
sed脚本中的地址形式,sed的地址用于sed命令的前面，表示只有符合指定地址条件的行才能执行后面的命令
1、NUMBER(单一匹配) 只匹配指定号行NUMBER的那一行
2、FIRST~STEP(递增匹配) GNU的扩展功能 匹配从起始行FIRST
(含)开始，以后行号每增加STEP的正整数倍，就是匹配行。比如要匹配所有奇数行就用1~2即可
3、$(尾行匹配) 匹配最后一个输入文件的最后一行；若有选项-i或-s则匹配每个输入文件的最后一行
4、/REGEXP/(正则表达式匹配) 匹配成功匹配正则表达式REGEXP的所有行。若REGEXP本身含有斜杠字符(/)，则要用转义字
符反斜杠(\)进行转义：即\/,一个空的正则表达式(//)，表示重复最近的一个非空的正则表达。空的正则表达式不能和调节器(I或M)一直使用，即
//I和//M是错误的
5、\%REGEXP%(正则表达式匹配) 和/REGEXP/功能一样。只是用字符%作为分隔符，而不是字符/，并且可用其他任意一个单字符作为分隔符。同样，若REGEXP本身含有指定的分隔符，要对它进行转义,
6、/REGEXP/I或\%REGEXP%I(I正则表达式匹配)
GNU的扩展功能 调节器I表示不区分大小，其余和上面第4、5项一样
7、/REGEXP/M或\%REGEXP%M(M正则表达式匹配)
GNU的扩展功能 调节器M使正则表达式REGEXP中的元字符^和$除了它们原含义的匹配功能外，元字符^和$还分别匹配：换行符后的空字符串和换行符前的空字符串。M是代表多行(Multi-line)的含义。而\`
和 \'总是分别匹配缓冲的开始和结束
8、NONE(全匹配) 没有指定地址时，即匹配输入文件中的所有行。
9、FIRST,END(区间匹配) 匹配行号从起始行(含)到终止行(含)之间的所有行,若终止行数值小于等于起始行数值，则只匹配行号等于
起始行的一行文本,若终止行是一个正则表达式(REGEXP)，则从起始行的下一行开始匹配这个正则表达式，一旦匹配(含匹配行)就结束，或直到输入数据
流结束(若有选项-i或-s时就是输入文件尾)
10、0,/REGEXP/(排除匹配) 这是唯一可以指定行号为0的形式，表示从文件第一行就开始尝试匹配指定的正则表达式，一旦匹配就结束
11、ADDR1,+N(连续匹配) 匹配ADDR1行及其后连续的N行
12、ADDR1,~ N(跳跃匹配) 匹配ADDR1行及其后行号是N的倍数的所有行。
13、!(反向匹配) 可以在以上12种地址形式后加一个惊叹号字符(!)，表示反向匹配指定的地址，即匹配那些不在指定地址范围内的行
注意：
1、不允许指定地址的命令有(即所有行都会执行)：
①、:label；②、#；③、}
2、最多能指定一个地址的命令有：
①、=；②、a\；③、i\；④、q ；⑤、Q；⑥、r；⑦、R
3、可指定多个地址的命令有：
①、{；②、b；③、t；④、T；⑤、c\；⑥、d；⑦、D；⑧、h；⑨、H；⑩、g；⑾、G；⑿、l；⒀、n；⒁、N；⒂、p；⒃、P；⒄、s；⒅、w；⒆、W；⒇、y
元字符表
元字符 含义说明
* 将*
前面的那一个正则表达式匹配的结果重复任意次(含0次)。前面的正则表达式可能是一个普通字符，或一个转义的元字符，或一个元字符句点( .
)，或一个方括号表达式，或一个\(regexp\)。为了更好的可移植性，在要匹配星号( * )本身时,要用转义字符。
\+ 与星号(
* )相同，只是至少重复1次。是 GNU的扩展功能。
\? 与星号(
* )相同，只是最多重复1次。是 GNU的扩展功能。
\{i\} 与星号(
* )相同，只是重复指定的i次。i的值必须介于 0至 RE_DUP_MAX (含)之间。RE_ DUP_ MAX是
POSIX定义的符号型常数，可通过getconf命令取得，最小值为255。
\{i,j\} 与星号(
* )相同，只是重复i至j次。
\{i,
\} 与星号(
* )相同，只是至少重复i次。
\(regexp\) 将regexp看作一个整体，用于：1、上面第1到第
6项的重复匹配中，如\(abc\)+ 匹配至少有一个整体abc的字符串。2、定义后向引用的子表达式。
. 匹配任意单个字符。
^ 匹配模版空间(PATTERN
SPACE) 开始处的
NULL字符串，即任何出现在字符^后面的东西，必须是位于模版空间的开始处才能成功匹配。只有作为正则表达式的第一个字符或子表达式的第一个字符(在\(
或 \|
之后)，字符^才有此作用，否则只是普通字符。为了更好的可移植性，不要在子表达式中使用此功能。
$ 同字符^类似，只是匹配的是模版空间结束处，只有作为正则表达式的最后一个字符或子表达式的最后一个字符(在\)
或 \|
之前)，才有此作用，否则只是普通字符。为了更好的可移植性，不要在子表达式中使用此功能。
[list]、[
^list] 匹配方括号中的字符列表中的任意一个。1、第一个字符为脱字符(
^)，则表示否定匹配，即匹配除字符列表中列出的那些字符以外的所有字符。 2、方括号中的连字符( -
)：不是第一或最后一个字符时，只表示连续字符的范围(注意：范围会因
locale而有所不同，因此不具可移植性)，否则作为普通字符进行匹配。3、要匹配右方括号( ]
)必须将它作为字符列表中的第一个字符。4、所有其他的元字符都看作为普通字符进行匹配。5、方括号表达式里可以含有POSIX定义的类字符
([..][==][::])。6、当系统没有完全遵守 POSIX标准时(即没设置 export
POSIXLY_CORRECT＝true )，能识别方括号中含有的，且在
GNU对转义字符功能扩展中定义的转义功能，如\n表示换行符；否则不能识别，即\n表示两字符\和 n 。
regexp1\ | regexp2
用在相邻的正则表达式之间，表示匹配这些正则表达式中任一个都可以。匹配是从左向右开始的，一旦匹配就不在尝试下一个正则表达式。是
GNU的扩展功能。
regexp1regexp2 匹配regexp1和regexp2的连接结果。
\digit 匹配正则表达式前半部分定义的后向引用的第
digit个子表达式。digit为1至9的数字, 1为从左开始。
\n 匹配换行符。
\meta 将元字符meta转换成普通字符，以便匹配该字符本身，有$
、 * 、 . 、[ 、
\ 和 ^。
sed的3个编程命令
1、:Label
不允许有地址。无空格。
在分支命令的位置前指定标签Label，是没有操作指令的。
2、b [Label]
无条件地跳到分支Label的位置。省略Label时，立即开始(无选项-n时，会先显示模版空间)下一个sed处理循环。
3、t [Label]
仅当分支条件符合时，或自从读取上一输入行后有过一次成功替换时，就跳到分支Label的位置。省略Label时，立即开始(无选项-n时，会先显示模版空间)下一个sed处理循环。
GNU sed的9个扩展命令
1、e [Command]
允许将来自Shell命令的输出通过管道输入到模版空间。
①、没有指定Command时，在模版空间中被发现的Shell命令会被执行，并用执行结果取代模版空间中的数据，会自动去掉执行结果尾部的换行符。这类似于s命令的标志选项e功能。
②、指定Command时，就执行Command，并像r命令那样，将执行结果送到输出流；这个命令可以跨度多行，除了最后一行，每行要以一个反斜杠(\)结尾。
上面两种情况中，当被执行的命令包含NUL字符时，结果是没有定义的。
2、F
显示当前输入文件的文件名，会自动进行换行。
3、L n
在将来的版本中会删除此命令。
4、Q [Exit-code]
只接受单一匹配的sed地址。表示退出sed，不再处理任何命令或输入，一定不前会显示当前模版空间中的数据。若指定了退出代码，则返回它。
5、R Filename
在当前循环(即处理当前模版空间的过程)结束时，或当前循环没处理完，在读取下一输入行前时，将文件Filename的内容排成一行、读取并插入到输出流。注意，若文件Filename不能读取，就当作是一个空文件，是没有任何错误提示的。
在GNU sed中，文件可以是/dev/stdin，表示读取标准输入中一行内容。
6、T Label
仅当分支条件符合时，或自从读取上一输入行后没有过一次成功替换时，就跳到分支Label的位置。省略Label时，立即开始(无选项-n时，会先显示模版空间)下一个sed处理循环。
7、v [Version]
用来验证是否支持GNU
sed的扩展功能，若不支持将使sed失败。同时，还可指定脚本要求的sed版本Version，如4.0.5，默认是4.0。
这命令会启用所有GNU的扩展功能，即使用环境变量POSIXLY_CORRECT取消也不行。
8、W Filename
将从模版空间的开始直到第一个换行符的数据写入文件Filename，其他的同命令w一样。
9、z
清空模版空间的内容，基本等同于命令s/.*//的作用，但比后者更有效、更可靠。
POSIX规定：元字符句点(.)是不能匹配不合法的多字节序列。所以，在大多数多字节地区(包括UTF-8地区)，不能在脚本中实现可移植的清空sed缓冲区的方法。
其中“//D”是什么意思？？"//"是简写，//代表使用上一次的正则
模式空间就是读入行所在的缓存，sed对文本行进行的处理都是在这个缓存中进行的
[]
匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed
[^]
匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行
\(..\)
保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers
&
保存搜索字符用来替换其他字符，如s/love，love这成**love**
\<
锚定单词的开始，如:/\<love/匹配包含以love开头的单词的行
\>
锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行
x\{m\}
重复字符x，m次，如：/0\{5\}/匹配包含5个o的行
x\{m,\}
重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行
x\{m,n\}
重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行
:lable
在脚本中标记一行，用于实现由b或t的控制转移。Label最多可以包含7个字符
=
=[address]=
将所寻址的行编写到标准输出,打印模式匹配的行号，使用格式
/pattern/=,整个文件都打印出来，并且匹配行打印了行号。如果只关心实际行号，使用 -e选项
a
[address]a
text
在与address匹配的每行后面追加text。如果text多于一行，必须用反斜杠将这些行前面的换行符“隐藏”起来。Text将被没有用这种方法隐藏
的第一个换行符结束。Text在模式空间中是不可用的并且后续的命令不能应用于它。当编辑命令的列表用完时，这个命令的结果将被输送到标准输出，而不管在
模式空间中的当前行发生了什么
b
[address1[,address2]]b[label] 无条件地将控制转移到脚本的其他位置的：label处。也就是说，label后面的命令是应用于当前行的下一个命令。如果没有指定label,
控制将一直到达脚本的末端，因此不再有命令作用于当前行
c
[address1[,address2]]c text
用text替代（改变）由地址选定的行。当指定的是一个行范围时，将所有的这些行作为一个组由text的一个副本来替代。每个text行后面的换行符必须用反斜杠将其转义，但最后一行除外。实际上，模式空间的内容被删除，因此后续的命令不能应用于它（或应用于text）
d
[address1[,address2]]d
从模式空间中删除行。因此行没有传递到标准输出。一个新的输入行被读取，并用脚本的第一个命令来编辑
D
[address1[,address2]]D
删除由命令N创建的多行模式空间中的一部分（直到嵌入的换行符），并且用脚本的第一条命令恢复编辑。如果这个命令使模式空间为空，那么将读取一个新的输入行，和执行了d命令一样
g
[address1[,address2]]g
将保持空间（参见h或H命令）中的内容复制到模式空间中，并将当前的内容清除
G
[address1[,address2]]G
将换行符后的保持空间（参见h或H命令）内容追加到模式空间。如果保持空间为空，则将换行符添加到模式空间
h
[address1[,address2]]h
将模式空间的内容复制到保存空间，即一个特殊的临时缓冲区。保存空间的当前内容被清除
H
[address1],address2]]H
将换行符和模式空间的内容追加到保持空间中，即使保持空间为空，这个命令也追加换行符
i
[address1]i
text 将text插入到每个和address匹配的行的前面
l
[address1[,address2]]l
列出模式空间的内容，将不可打印的字符表示为ASCII码。长的行被折行
n
[address1[,address2]]n
读取下一个输入行到模式空间。当前行被送到标准输出。新行成为当前行并递增行计数器。将控制转到n后面的命令，而不是恢复到脚本的顶部
N
[address1[,address2]]N
将下一个输入行追加到模式空间的内容之后；新添加的行与模式空间的当前内容用换行符分隔（这个命令用于实现跨两行的模式匹配。利用n来匹配嵌入的换行符，则可以实现多行匹配模式）
p
[address1[,address2]]p
打印所寻址的行。注意这将导致输出的重复，除非默认的输出用”#n”或”-n”命令行选项限制。常用于改变流控制（d,n,b）的命令之前并可能阻止当前行被输出
P
[address1[,address2]]P
打印由命令N创建的多行模式空间的第一部分（直接嵌入的换行符）。如果没有将N应用于某一行则和p相同
q
[address]q
当遇到address时退出。寻址的行首先被写到输出（如果没有限制默认输出），包括前面的a或r命令为它追加的文本
r
[address]r file
读取file的内容并追加到模式空间内容的后面。必须在r和文件名file之间保留一个空格
s
[address1[,address2]]s/pattern/replacement/[flags]
用replacement代替每个寻址的pattern。如果使用了模式地址，那么模式//表示最后指定的模式地址。可以指定下面的标志：
n
替代每个寻址的行的第n个/pattern/。N是1到512之间的任意数字，并且默认值为1
g
替代每个寻址的行的所有/pattern/，而不只是第一个
p
如果替换成功则打印这一行。如果成功进行了多个替换，将打印这个行的多个副本
w file
如果发生一次替换则将这行写入file。最多可以打开10个不同的file
replacement是一个字符串,用来替换与正则表达式匹配的内容.在replacement部分,只有下列字符有特殊含义:
&
用正则表达式匹配的内容进行替换
n
匹配第n个子串(n是一个数字),这个子串以前在pattern中用"("和")"指定
当在替换部分包含"与"符号(&),反斜杠()和替换命令的定界符时可用转义它们.另外,它用于转义换行符并创建多行replacement字符串
数字标志 s/pattern/replacememt/flag
如果flag是数字,
那么指定对一行上某个位置的匹配.如果没有数字标志,则替换命令只替换第一个匹配串,因此"1"可以被看作是默认的数字标志
替换元字符是反斜杠()、与符号(&)和n:
反斜杠一般用于转义其他的元字符，但是它在替换字符串中也用于包含换行符。
例如对于如下的行：column1(制表符)column2(制表符)column3(制表符)column4 使用如下替换语句：s/制表符//2 注意，在反斜杠的后面不允许有空格。这个脚本产生下面的结果：
column1(制表符)column2
column3(制表符)column4
"与"符号(&)作为元字符表示模式匹配的范围,不是被匹配的行.例如下面的命令:s/UNIX/s-2&s0/g 可以将输入行:on
the UNIX Operating System 替换成:on the s-2UNIXs0
Operating System。当正则表达式匹配单词的变化时,"与"符号特别有用.它允许指定一个可变的替换字符串.诸如"See
Section 1.4"或"See Section 12.9"的引用都应该出现在圆括号中，如"(See Section
12.9)".正则表达式可以匹配数字的不同组合，所以在替换字符串中可以使用"&"并括起所匹配的内容：s/See
Section
[1-9][0-9]*.[1-9][0-9]*/(&)/ 这里"与"符号用于在替换字符串中引用整个匹配内容
n元字符用于选择被匹配的字符串的任意独立部分，并且在替换字符串中回调它．在sed中转义的圆括号括住正则表达式的任意部分并且保存以备回调．一行最多允许保存９次．例如，当节号出现在交叉引用中时要表示为用粗体：s/(See
Section )([1-9][0-9]*.[1-9][0-9]*)/1fB2fp/
t
[address1[,address2]]t[label] 测试在寻址的行范围内是否成功执行了替换，如果是，则转移到有label标志的行（参见b和:)。如果没有给出label，控制将转移到脚本的底部
w
[address1[,address2]]w file
将模式空间的内容追加到file。这个动作是在遇到命令时发生而不是在输出模式空间内容时发生。必须在w和这个文件名之间保留一个空格。在脚
本中可以打开的最大文件数是10。如果文件不存在，这个命令将创建一个文件。如果文件存在，则每次执行脚本时将改写其内容，多重写入命令直接将输出写入到
同一个文件并追加到这个文件的末端
x
[address1[,address2]]x
交换模式空间和保持空间的内容
y
[address1[,address2]]y/abc/xyz/
按位置将字符串abc中的字符替换成字符串xyz中相应字符
在使用sed时，替换变量出现特殊字符，此时变量需要用"${var}"括起来,从shell向sed传值,要从命令行中向sed传值，值得注意的是用双引号，否则功能不执行.
"'$var'"
这种写法大家无需改变用'括起awk程序的习惯.如:var="test" awk
'BEGIN{print "'$var'"}'
这种写法是双括号变为单括号的常量,传递给了awk.如果var中含空格,为了shell不把空格作为分格符,应如下使用:
var="this is a test"
awk 'BEGIN{print "'"$var"'"}'
'"$var"'
如果变量含空格,则变为'""$var""'较为可靠.
把括起awk程序的''变为"",使用"$var"
如:
$var="this is a test"
awk 'BEGIN{print "$var"}"
因为在""里$是特殊字符,而在''里$是普通字符.
export 变量,使用ENVIRON["var"]形式
如:
$var="this is a test";export $var
awk 'BEGIN{print ENVIRON["var"]}'
也可以使用-v选项
如:
$var="this is a test"
awk -vnvar="$var" '{print nvar}'
这样便把系统变量定义成了awk变量.
在awk中给系统变量附值
eval $(awk 'BEGIN{print "a=ggg b=3"}')
eval $(grep -v '#' "$CONFFILE" | awk 'BEGIN{FS="|"}
NR=="'$var_list'"{printf("HOST=\"%s\" MAX=\"%s\" EMAILLIST=\"%s\"
PHONE=\"%s\"\n",$1,$2,$3,$4)}')
倒序文件 sed -e '1!G;h;$!d' a.txt >
b.txt
把保留空间（临时缓冲区）的内容附接到当前行的模式空间，删除当前行模式空间，如此往复，直到最后一行，到最后一行的时候不删除当前模式空间，最后输出模式空间。上述sed命令'1!G;h;$!d'，用分号隔开三个子命令G,
h,
d，应用于每一行的分析，G表示把缓冲区内容附接到当前模式空间中，h表示将模式空间的内容保存到缓冲区中，d表示删除模式空间。
去掉<xx>abcdefg</xxx>内容两边的括号，如果内容之间有换行，又该如何办？
*没有换行的情况：
echo
"<xx>abcdefg</xxx>"
| sed
's/\(<.*>\)\(.*\)\(<.*>\)/\2/'
echo
"<xx>abcdefg</xxx>"
| sed
's/<[^>]*>//g'
*内容中有换行的情况
#cat test.sed
#!/bin/sed -f
:a
/<[^>]*$/{
N
ba
}
s/<[^>]*>//g
删除配置文件中#号注释的行
sed 's#\#.*##' file.conf >
file.new.conf
sed -i 's#\#.*##' file.conf
grep -v "#" file.conf
删除配置文件中//号注释的行
sed 's#//.*##' file.conf >
file.new.conf
grep -v '^//' file.conf
单引号内所有元字符都失去特殊含义（包括\）,双引号内除了变量域（$）和命令域（'）以外的元字符都失去特殊含义，一般使用双引号引用.花括号{}被用来区分变量名和周围的文本：echo
${file} and $file1
寻找变量file，file1.''命令替代的格式：反引号来环绕一个命令像'cmd',和$（cmmand）是等价的：echo ${ls}
= echo 'ls' 执行此选项中的命令
对ip地址进行替换和修改
#在sed中使用变量
aa=0
bb=77
sed
"1,2{s/\([0-9]\{1,3\}\.[0-9]\{1,3\}\.\)$aa\(\.[0-9]\{1,3\}\)/\1$bb\2/}"
file
其中的中间()号中的是对IP地址的匹配。注意其IP地址的正则表达的匹配方式。而前面的1,2表示需要处理的起止行数
删除文件中的后两行
sed -i "$d" file | sed -i "$d" file 或 sed
'N;$d;P;D'
匹配一行中的或关系的多个字符串
awk '/string1/||/string2/ { print $0 }'
file 或 sed -n
"/string1\|string2/p" file
取特定数目倍数的行
nl filename | awk
'(NR-3)%3==0' 取filename中3,2×3,3×3,3×4等行，当然也可以把逻辑变换以下，取任意于行数相关的行。
选出以数字开头的行，该行的数字要大于10位
sed -n '/^[0-9]\{10,\}/p' ff
把/usr/local:替换成/usr:
sed -e 's/\(\/usr\).*/\1:/g' file
sed -e 's/\/usr/local:/\/usr:/g' file
sed -e 's:/usr/local:/usr:g' file
awk -F'/' '{print "/"$2":"}'
有文件d7如下,请把第三行的7全部变成8
20080602/1/6/2
20080602/2/7/3
20080602/3/7/2
20080602/4/6/3
sed -e 's/\(.*\/.*\/\)7\(\/.*\)/\18\2/'
file
awk -F'/' '{if($3==7) {$3=8} print
$1"/"$2"/"$3"/"$4}' file
awk -F "/" '{OFS="/"}{if($3==7) $3=8; print $0}'
file
取一行中的特定段的字符的方法总结
1) sed
2) awk
3) cut
4) grep
*)删除文件中的前10000行
1) sed '1,10000d' file
2) awk 'NR>10000' file
*)删除含有特定字符串1到特定字符串2的行
1) sed '/str1/,/str2/d' file
把文件中的所有行末尾的\n都去掉；把文件组成一行
sed '{:a;N;s/\n/ /;ba}' filename
这是一个循环，用N来读取下一行并追加到模式空间中；用标签:a和跳转b来循环这个过程
每隔两行进行合并
sed '{N;s/\n/ /}' filename
把文中的单词(以,号隔开)的格式化成，每行一个（用\n替换掉,即可）
sed 's/,/\n/g' filename
替换一列
11 22 33
11 22 33
替换第一列为55
sed 's/^11/55/' file
替换第2列为66
sed 's/\(.*\) .* \(.*\)/\1 66 \2/' file
删除空白(由tab和空格或只有\n的行组成)行
sed '/^[ \t\n]*$/d' file
sed '/^[[:space:]]*$/d'
替换每行的第2个字符到第6个字符为*号
sed 's/\(^.\).\{5\}\(.*\)/\1*****\2/'
sed '{s/.3;s/.5;s/./'
将每一行拖尾的“空白字符”（空格，制表符）删除
sed 's/[ \t]*$//'
将每一行中的前导和拖尾的空白字符删除
sed 's/^[ \t]*//;s/[ \t]*$//'
在每一行开头处插入5个空格（使全文向右移动5个字符的位置）
sed
's/^/
/'
以79个字符为宽度，将所有文本右对齐
sed -e :a -e 's/^.\{1,78\}$/
&/;ta' #78个字符外加最后的一个空格
以79个字符为宽度，使所有文本居中。在方法1中，为了让文本居中每一行的前头和后头都填充了空格。
在方法2中，在居中文本的过程中只在文本的前面填充空格，并且最终这些空格将有一半会被删除。此外每一行的后头并未填充空格
sed -e :a -e 's/^.\{1,77\}$/
& /;ta'
sed -e :a -e 's/^.\{1,77\}$/
&/;ta' -e 's/\( *\)\1/\1/'
在每一行中查找字串“foo”，并将找到的“foo”替换为“bar”
sed 's/foo/bar/'
sed 's/foo/bar/4'
sed 's/foo/bar/g'
sed 's/\(.*\)foo\(.*foo\)/\1bar\2/'
sed 's/\(.*\)foo/\1bar/'
只在行中出现字串“baz”的情况下将“foo”替换成“bar”
sed '/baz/s/foo/bar/g'
将“foo”替换成“bar”，并且只在行中未出现字串“baz”的情况下替换
sed '/baz/!s/foo/bar/g'
不管是“scarlet”“ruby”还是“puce”，一律换成“red”
sed
's/scarlet/red/g;s/ruby/red/g;s/puce/red/g' #对多数的sed都有效
gsed
's/scarlet\|ruby\|puce/red/g' #只对GNU
sed有效
倒置所有行，第一行成为最后一行，依次类推（模拟“tac”）(由于某些原因，使用下面命令时HHsed
v1.5会将文件中的空行删除)
sed '1!G;h;$!d'
sed -n '1!G;h;$p'
将行中的字符逆序排列，第一个字成为最后一字，……（模拟“rev”）
sed
'/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
将每两行连接成一行（类似“paste”）
sed '$!N;s/\n/ /'
如果当前行以反斜杠“\”结束，则将下一行并到当前行末尾,并去掉原来行尾的反斜杠
sed -e :a -e '/\\$/N; s/\\\n//; ta'
如果当前行以等号开头，将当前行并到上一行末尾,并以单个空格代替原来行头的“=”
sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'
为数字字串增加逗号分隔符号，将“1234567”改为“1,234,567”
gsed
':a;s/\B[0-9]\{3\}\>/,&/;ta'
sed -e :a -e
's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta'
为带有小数点和负号的数值增加逗号分隔符（GNU sed）
gsed -r
':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'
在每5行后增加一空白行 （在第5，10，15，20，等行后增加一空白行）
gsed '0~5G'
sed 'n;n;n;n;G;'
选择性地显示特定行：
#显示文件中的前10行 （模拟“head”的行为）
sed 10q
#显示文件中的第一行 （模拟“head -1”命令）
sed q
#显示文件中的最后10行 （模拟“tail”）
sed -e :a -e '$q;N;11,$D;ba'
#显示文件中的最后2行（模拟“tail -2”命令）
sed '$!N;$!D'
#显示文件中的最后一行（模拟“tail -1”）
sed '$!d'
sed -n '$p'
显示文件中的倒数第二行
sed -e '$!{h;d;}' -e
x
#当文件中只有一行时，输入空行
sed -e '1{$q;}' -e '$!{h;d;}' -e
x #当文件中只有一行时，显示该行
sed -e '1{$d;}' -e '$!{h;d;}' -e
x #当文件中只有一行时，不输出
只显示匹配正则表达式的行（模拟“grep”）
sed -n '/regexp/p'
sed '/regexp/!d'
只显示“不”匹配正则表达式的行（模拟“grep -v”）
sed -n '/regexp/!p'
sed '/regexp/d'
查找“regexp”并将匹配行的上一行显示出来，但并不显示匹配行
sed -n '/regexp/{g;1!p;};h'
查找“regexp”并将匹配行的下一行显示出来，但并不显示匹配行
sed -n '/regexp/{n;p;}'
显示包含“regexp”的行及其前后行，并在第一行之前加上“regexp”所在行的行号 （类似“grep -A1
-B1”）
sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h
显示包含“AAA”、“BBB”或“CCC”的行（任意次序）
sed '/AAA/!d; /BBB/!d; /CCC/!d'
显示包含“AAA”、“BBB”和“CCC”的行（固定次序）
sed '/AAA.*BBB.*CCC/!d'
显示包含“AAA”“BBB”或“CCC”的行 （模拟“egrep”）
sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e
d #多数sed
gsed
'/AAA\|BBB\|CCC/!d' #对GNU
sed有效
显示包含“AAA”的段落 （段落间以空行分隔）,HHsed v1.5
必须在“x;”后加入“G;”，接下来的3个脚本都是这样
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'
显示包含“AAA”“BBB”和“CCC”三个字串的段落 （任意次序）
sed -e '/./{H;$!d;}' -e
'x;/AAA/!d;/BBB/!d;/CCC/!d'
显示包含“AAA”、“BBB”、“CCC”三者中任一字串的段落 （任意次序）
sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e
'/CCC/b' -e d
gsed
'/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d'
#只对GNU sed有效
显示包含65个或以上字符的行
sed -n '/^.\{65\}/p'
显示包含65个以下字符的行
sed -n '/^.\{65\}/!p'
sed '/^.\{65\}/d'
显示部分文本——从包含正则表达式的行开始到最后一行结束
sed -n '/regexp/,$p'
显示部分文本——指定行号范围（从第8至第12行，含8和12行）
sed -n '8,12p'
sed '8,12!d'
显示第52行
sed -n '52p'
sed '52!d'
sed '52q;d'
从第3行开始，每7行显示一次
gsed -n
'3~7p'
#只对GNU sed有效
sed -n
'3,${p;n;n;n;n;n;n;}'
#其他sed
显示两个正则表达式之间的文本（包含）
sed -n
'/Iowa/,/Montana/p'
#区分大小写方式
显示通篇文档，除了两个正则表达式之间的内容
sed '/Iowa/,/Montana/d'
删除文件中相邻的重复行（模拟“uniq”）,只保留重复行中的第一行，其他行删除
sed '$!N; /^\(.*\)\n\1$/!P; D'
删除文件中的重复行，不管有无相邻,注意hold space所能支持的缓存大小，或者使用GNU sed
sed -n 'G;
s/\n/&&/; /^\([ -~]*\n\).*\n\1/d;
s/\n//; h; P'
删除除重复行外的所有行（模拟“uniq -d”）
sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'
删除文件中开头的10行
sed '1,10d'
删除文件中的最后一行
sed '$d'
删除文件中的最后两行
sed 'N;$!P;$!D;$d'
删除文件中的最后10行
sed -e :a -e '$d;N;2,10ba' -e 'P;D'
sed -n -e :a -e '1,10!{P;N;D;};N;ba'
删除8的倍数行
gsed
'0~8d'
#只对GNU sed有效
sed
'n;n;n;n;n;n;n;d;'
#其他sed
删除匹配式样的行
sed '/pattern/d'
删除文件中的所有空行（与“grep '.' ”效果相同）
sed '/^$/d'
sed '/./!d'
只保留多个相邻空行的第一行,并且删除文件顶部和尾部的空行,（模拟“cat -s”）
sed
'/./,/^$/!d'
#删除文件顶部的空行，允许尾部保留一空行
sed
'/^$/N;/\n$/D'
#允许顶部保留一空行，尾部不留空行
只保留多个相邻空行的前两行
sed '/^$/N;/\n$/N;//D'
删除文件顶部的所有空行
sed '/./,$!d'
删除文件尾部的所有空行
sed -e :a -e '/^\n*$/{$d;N;ba' -e '}'
sed -e :a -e '/^\n*$/N;/\n$/ba'
删除每个段落的最后一行
sed -n '/^$/{p;h;};/./{x;/./p;}'
移除手册页（man page）中的nroff标记。在Unix System V或bash
shell下使用'echo'命令时可能需要加上 -e 选项
sed "s/.`echo
"
#外层的双括号是必须的（Unix环境）
sed
's/.^H//g'
#在bash或tcsh中, 按 Ctrl-V 再按 Ctrl-H
sed
's/.\x08//g'
#sed 1.5，GNU sed，ssed所使用的十六进制的表示方法
提取新闻组或 e-mail 的邮件头
sed
'/^$/q'
#删除第一行空行后的所有内容
提取新闻组或 e-mail 的正文部分
sed
'1,/^$/d'
#删除第一行空行之前的所有内容
从邮件头提取“Subject”（标题栏字段），并移除开头的“Subject:”字样
sed '/^Subject: */!d; s///;q'
从邮件头获得回复地址
sed '/^Reply-To:/q; /^From:/h; /./d;g;q'
获取邮件地址。在上一个脚本所产生的那一行邮件头的基础上进一步的将非电邮地址的部分剃除
sed 's/ *(.*)//; s/>.*//;
s/.*[:<] *//'
在每一行开头加上一个尖括号和空格（引用信息）
sed 's/^/> /'
将每一行开头处的尖括号和空格删除（解除引用）
sed 's/^> //'
移除大部分的HTML标签（包括跨行标签）
sed -e :a -e
's/<[^>]*>//g;/</N;//ba'
将分成多卷的uuencode文件解码。移除文件头信息，只保留uuencode编码部分,文件必须以特定顺序传给sed,下面第一种版本的脚本可以直接在命令行下输入,第二种版本则可以放入一个带执行权限的shell脚本中
sed '/^end/,/^begin/d' file1 file2 ... fileX |
uudecode #vers. 1
sed '/^end/,/^begin/d' "$@" |
uudecode
#vers. 2
将文件中的段落以字母顺序排序。段落间以（一行或多行）空行分隔。GNU
sed使用字元“\v”来表示垂直制表符，这里用它来作为换行符的占位符——当然你也可以用其他未在文件中使用的字符来代替它。
sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed
'1s/={NL}=//;s/={NL}=/\n/g'
gsed '/./{H;d};x;y/\n/\v/' file | sort | sed
'1s/\v//;y/\v/\n/'
分别压缩每个.TXT文件，压缩后删除原来的文件并将压缩后的.ZIP文件命名为与原来相同的名字（只是扩展名不同）（DOS环境：“dir
/b”#显示不带路径的文件名）
echo @echo off >zipup.bat
dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1
\1.TXT/" >>zipup.bat
dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1
\1.TXT/" >>zipup.bat
‘s/\.$//g’
删除以句点结尾行
‘-e
/abcd/d’
删除包含abcd的行
‘s/[][][]*/[]/g’
删除一个以上空格，用一个空格代替
‘s/^[][]*//g’
删除行首空格
‘s/\.[][]*/[]/g’
删除句点后跟两个或更多空格，代之以一个空格
‘/^$/d’
删除空行
‘s/^.//g’
删除第一个字符
‘s/COL\(...\)//g’
删除紧跟COL的后三个字母
‘s/^\///g’
从路径中删除第一个\
‘s/[]/[]//g’
删除所有空格并用tab键替代
‘S/^[]//g’
删除行首所有tab键
‘s/[]*//g’
删除所有tab键
sed常用操作
删除配置文件中#号注释行
sed ' s#\#.
:e## '
_
.conf
>
~
.new.conf
删除配置文件中／／号注释行
sed 's#//.*##' file.conf >
file.new.conf
删除无内容空行
sed '/^$/d' file.conf >
file.new.conf
删除由空格和Tab而成的空行
sed '/^[[:space:]]*$/d' file.conf
> file.new.conf
sed—i可以直接写入不用>
grep对应的用法
删除配置文件中#号注释行
sed
's#\#.*##' file.conf > file.new.conf
sed -i
's#\#.*##' file.conf
grep -v "#"
file.conf
删除配置文件中／／号注释行
sed
's#//.*##' file.conf > file.new.conf
grep
-v '^//' file.conf
删除无内容空行
sed '/^$/d' file.conf >
file.new.conf
grep -v
'^$' file.conf
删除由空格和Tab而成的
sed '/^[[ : space: ] ]*$/d ' file.conf
> file.new.conf
grep [ : space : ] file.conf
利用sed取行／替换
单引号、双引号、括号、花括号及反引号
单引号内所有元字符都失去特殊含义（包括＼）双引号内除了变量域（$）和命令域（'）以外的元字符都失去特殊含义，所以一般使用双引号引用
花括号{}被用来区分变量名和周围的文本：echo ${f．le）and
$filel寻找变量file，filel
''命令替代的格式：反引号来环绕一个命令象'cmd'，它和$(command)是等价的echo
${ls)=echo \ls','执行此选项中的命令'
取行
sed—n“3”p file取第3行
sed—n“1，3“p file取第1到3行
sed—n“1，$“p file取第1到最后一行
sed—n“1，$num”p file取第1至0 num行
sed—n“\$p“file取最后1行
sed—e'1 1Gj hj$!d'file倒过来显示
sed附加/替换
sed “/xmdh/a\daoyou“
file 把含有xmdh的行的结尾附加daoyou（有换行）
sed 's/$/
daoyou/’file 把每行的结尾附加daoyou（在同一行）
sed ’/test/s/$/
daoyou/' file把包含test行的结尾附加daoyou（在同一行）
sed '10s/$/
daoyou/’file 把第10行的结尾附加daoyou（在同一行）
sed "s/xmdh/daoyou/g"
file 把xmdh替换成daoyou
sed "s/xmdh/daoyou/;G"
file 把xmdh替换成daoyou并增加一个换行
cat userlog | sed —n ’/xmdh/w
test.txt’ 查看含有xmdh并写入test .txt中
搜索
vi file后:
/\<daoyou\>/
显示行号
awk '/dhshunde/{print NR,$O}'
userlog 或 grep -n dhshunde
userlog显示含有dhshunde的行号及内容
cat userlog lsed—n‘/erptest/=’
显示含有erptest的行号
cat userlog lsed—n’/xmdh/p' |
sed—n’$p’ 显示包含xmdh的最后一行
awk中使用变量
/bin/cat /etc/ppp/chap-secretslgrep $5lawk
'{print
logoutt ime " \t " , -' u sername : -' $1 -' \t
-' , " logout " -' \t -' , -' data : -' data size}
logouttime=" - /bin/date- "datasize=
"$size"
>>$pptplogdirectory/userlog (注:
size前面已经有定义)
find的用法
注：find命令将所有匹配到的文件一起传递给exec执行，而xargs命令每次只获取一部分文件而不是全部所以exec有长度限制，文件不能太多，否则会产生溢出错误，而xargs别没有
find．-mtime -1
-print 跟现在小于1天修改的文件
find．-perm 755
-print 显示具有755属性的文件
find．-size +1000000c
-print 查找大于1M的文件
find．-type f -exec ls —l {}
\；查找文件并列表显示（注：{}与\之间有空格，最后有;）
find．-type f -exec rm {}
\; 查找文件并删除
find．-type f -print | xargs ls
-l 查看文件并列表显示
find / \（-perm -4000 -o -perm -2000＼）-type f-
print查找SUID和SGID文件
向登录终端用户发送消息
echo "hello i am jiangdaoyou" |tee /dev/pts/2
(tty可以查看自己的终端号)，等同于：write root pts/2然后输入：hello i am jiangdaoyou
然后Ctrl+D结束
awk之BEGIN和END
即在文件头增加列名：
cat userlog lawk 'BEGIN{print "Time
username\n----
一“）j{print$4J$7)
Time
username
15:19: 28 username:xmdh
15: 20: 00 username: xmdh
即在文件头增加列名：
cat userlog lawk 'BEGIN{print "Time
username\n----
一“）；{print$4,$7)'
Time username
截取/转化字符
echo "200604211031" | cut
-c9-12 得到 1031
cat test.ok |tr 'arp' 'rpm' 把
arp转为 rpm
求平均值
vmstat 1 4 |awk '{print $4}'
|grep -o '[0-9]*' |sed 's/,//g' |awk
'{total=total+$l; if(NR%4==0)
{print total/4}} ' 成如下方法:
vmstat 1 4lawk
'NR>2{sum+=$4}END{print sum/4}'
循环
ls | for file in *;do echo "rpm -ivh"
$file;done
ls | for file in $(ls *.rpm);do echo "rpm -ivh"
$file;done
在每一行后面增加一空行
sed G
将原来的所有空行删除并在每一行后面增加一空行。这样在输出的文本中每一行后面将有且只有一空行。
sed '/^$/d;G'
在每一行后面增加两行空行
sed 'G;G'
将第一个脚本所产生的所有空行删除（即删除所有偶数行）
sed 'n;d'
在匹配式样“regex”的行之前插入一空行
sed '/regex/{x;p;x;}'
在匹配式样“regex”的行之后插入一空行
sed '/regex/G'
在匹配式样“regex”的行之前和之后各插入一空行
sed '/regex/{x;p;x;G;}'
为文件中的每一行进行编号（简单的左对齐方式）。这里使用了“制表符”（tab，见本文末尾关于'\t'的用法的描述）而不是空格来对齐边缘。
sed = filename | sed 'N;s/\n/\t/'
对文件中的所有行编号（行号在左，文字右端对齐）。
sed = filename | sed 'N;
s/^/
/; s/ *\(.\{6,\}\)\n/\1 /'
对文件中的所有行编号，但只显示非空白行的行号。
sed '/./=' filename | sed '/./N; s/\n/ /'
计算行数 （模拟 "wc -l"）
sed -n '$='
Unix环境：转换DOS的新行符（CR/LF）为Unix格式。
sed
's/.$//'
# 假设所有行以CR/LF结束
sed
's/^M$//'
# 在bash/tcsh中，将按Ctrl-M改为按Ctrl-V
sed
's/\x0D$//'
# ssed、gsed 3.02.80，及更高版本
Unix环境：转换Unix的新行符（LF）为DOS格式。
sed "s/$/`echo -e
"
# 在ksh下所使用的命令
sed 's/$'"/`echo
"
# 在bash下所使用的命令
sed "s/$/`echo
"
# 在zsh下所使用的命令
sed
's/$/\r/'
# gsed 3.02.80 及更高版本
DOS环境：转换Unix新行符（LF）为DOS格式。
sed
"s/$//"
# 方法 1
sed -n
p
# 方法 2
DOS环境：转换DOS新行符（CR/LF）为Unix格式。
下面的脚本只对UnxUtils sed 4.0.7
及更高版本有效。要识别UnxUtils版本的sed可以通过其特有的“--text”选项。你可以使用帮助选项（“--help”）看其中有无一个
“--text”项以此来判断所使用的是否是UnxUtils版本。其它DOS版本的的sed则无法进行这一转换。但可以用“tr”来实现这一转换。
sed "s/\r//" infile
>outfile
# UnxUtils sed v4.0.7 或更高版本
tr -d \r <infile
>outfile
# GNU tr 1.22 或更高版本
将每一行前导的“空白字符”（空格，制表符）删除
使之左对齐
sed 's/^[
\t]*//'
# 见本文末尾关于'\t'用法的描述
将每一行拖尾的“空白字符”（空格，制表符）删除
sed 's/[
\t]*$//'
# 见本文末尾关于'\t'用法的描述
将每一行中的前导和拖尾的空白字符删除
sed 's/^[ \t]*//;s/[ \t]*$//'
在每一行开头处插入5个空格（使全文向右移动5个字符的位置）
sed
's/^/
/'
以79个字符为宽度，将所有文本右对齐
sed -e :a -e 's/^.\{1,78\}$/
&/;ta' # 78个字符外加最后的一个空格
以79个字符为宽度，使所有文本居中。在方法1中，为了让文本居中每一行的前头和后头都填充了空格。
在方法2中，在居中文本的过程中只在文本的前面填充空格，并且最终这些空格将有一半会被删除。此外每一行的后头并未填充空格。
sed -e :a -e 's/^.\{1,77\}$/
&
/;ta'
# 方法1
sed -e :a -e 's/^.\{1,77\}$/
&/;ta' -e 's/\( *\)\1/\1/' #
方法2
在每一行中查找字串“foo”，并将找到的“foo”替换为“bar”
sed
's/foo/bar/'
# 只替换每一行中的第一个“foo”字串
sed
's/foo/bar/4'
# 只替换每一行中的第四个“foo”字串
sed
's/foo/bar/g'
# 将每一行中的所有“foo”都换成“bar”
sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' #
替换倒数第二个“foo”
sed
's/\(.*\)foo/\1bar/'
# 替换最后一个“foo”
只在行中出现字串“baz”的情况下将“foo”替换成“bar”
sed '/baz/s/foo/bar/g'
将“foo”替换成“bar”，并且只在行中未出现字串“baz”的情况下替换
sed '/baz/!s/foo/bar/g'
不管是“scarlet”“ruby”还是“puce”，一律换成“red”
sed
's/scarlet/red/g;s/ruby/red/g;s/puce/red/g'
#对多数的sed都有效
gsed
's/scarlet\|ruby\|puce/red/g'
# 只对GNU sed有效
倒置所有行，第一行成为最后一行，依次类推（模拟“tac”）。由于某些原因，使用下面命令时HHsed
v1.5会将文件中的空行删除
sed
'1!G;h;$!d'
# 方法1
sed -n
'1!G;h;$p'
# 方法2
将行中的字符逆序排列，第一个字成为最后一字，……（模拟“rev”）
sed
'/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
将每两行连接成一行（类似“paste”）
sed '$!N;s/\n/ /'
如果当前行以反斜杠“\”结束，则将下一行并到当前行末尾并去掉原来行尾的反斜杠
sed -e :a -e '/\\$/N; s/\\\n//; ta'
如果当前行以等号开头，将当前行并到上一行末尾并以单个空格代替原来行头的“=”
sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'
为数字字串增加逗号分隔符号，将“1234567”改为“1,234,567”
gsed
':a;s/\B[0-9]\{3\}\>/,&/;ta'
# GNU sed
sed -e :a -e
's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta' #
其他sed
为带有小数点和负号的数值增加逗号分隔符（GNU sed）
gsed -r
':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'
在每5行后增加一空白行 （在第5，10，15，20，等行后增加一空白行）
gsed
'0~5G'
# 只对GNU sed有效
sed
'n;n;n;n;G;'
# 其他sed
显示文件中的前10行 （模拟“head”的行为）
sed 10q
显示文件中的第一行 （模拟“head -1”命令）
sed q
显示文件中的最后10行 （模拟“tail”）
sed -e :a -e '$q;N;11,$D;ba'
显示文件中的最后2行（模拟“tail -2”命令）
sed '$!N;$!D'
显示文件中的最后一行（模拟“tail -1”）
sed
'$!d'
# 方法1
sed -n
'$p'
# 方法2
显示文件中的倒数第二行
sed -e '$!{h;d;}' -e
x
# 当文件中只有一行时，输入空行
sed -e '1{$q;}' -e '$!{h;d;}' -e
x # 当文件中只有一行时，显示该行
sed -e '1{$d;}' -e '$!{h;d;}' -e
x # 当文件中只有一行时，不输出
只显示匹配正则表达式的行（模拟“grep”）
sed -n
'/regexp/p'
# 方法1
sed
'/regexp/!d'
# 方法2
只显示“不”匹配正则表达式的行（模拟“grep -v”）
sed -n
'/regexp/!p'
# 方法1，与前面的命令相对应
sed
'/regexp/d'
# 方法2，类似的语法
查找“regexp”并将匹配行的上一行显示出来，但并不显示匹配行
sed -n '/regexp/{g;1!p;};h'
查找“regexp”并将匹配行的下一行显示出来，但并不显示匹配行
sed -n '/regexp/{n;p;}'
显示包含“regexp”的行及其前后行，并在第一行之前加上“regexp”所在行的行号 （类似“grep -A1
-B1”）
sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h
显示包含“AAA”、“BBB”或“CCC”的行（任意次序）
sed '/AAA/!d; /BBB/!d; /CCC/!d'
# 字串的次序不影响结果
显示包含“AAA”、“BBB”和“CCC”的行（固定次序）
sed '/AAA.*BBB.*CCC/!d'
显示包含“AAA”“BBB”或“CCC”的行 （模拟“egrep”）
sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e
d #
多数sed
gsed
'/AAA\|BBB\|CCC/!d'
# 对GNU sed有效
显示包含“AAA”的段落 （段落间以空行分隔）
HHsed v1.5 必须在“x;”后加入“G;”，接下来的3个脚本都是这样
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'
显示包含“AAA”“BBB”和“CCC”三个字串的段落 （任意次序）
sed -e '/./{H;$!d;}' -e
'x;/AAA/!d;/BBB/!d;/CCC/!d'
显示包含“AAA”、“BBB”、“CCC”三者中任一字串的段落 （任意次序）
sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e
'/CCC/b' -e d
gsed
'/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d'
# 只对GNU sed有效
显示包含65个或以上字符的行
sed -n '/^.\{65\}/p'
显示包含65个以下字符的行
sed -n
'/^.\{65\}/!p'
# 方法1，与上面的脚本相对应
sed
'/^.\{65\}/d'
# 方法2，更简便一点的方法
显示部分文本——从包含正则表达式的行开始到最后一行结束
sed -n '/regexp/,$p'
显示部分文本——指定行号范围（从第8至第12行，含8和12行）
sed -n
'8,12p'
# 方法1
sed
'8,12!d'
# 方法2
显示第52行
sed -n
'52p'
# 方法1
sed
'52!d'
# 方法2
sed
'52q;d'
# 方法3, 处理大文件时更有效率
从第3行开始，每7行显示一次
gsed -n
'3~7p'
# 只对GNU sed有效
sed -n
'3,${p;n;n;n;n;n;n;}'
# 其他sed
显示两个正则表达式之间的文本（包含）
sed -n
'/Iowa/,/Montana/p'
# 区分大小写方式
显示通篇文档，除了两个正则表达式之间的内容
sed '/Iowa/,/Montana/d'
删除文件中相邻的重复行（模拟“uniq”）只保留重复行中的第一行，其他行删除
sed '$!N; /^\(.*\)\n\1$/!P; D'
删除文件中的重复行，不管有无相邻。注意hold space所能支持的缓存大小，或者使用GNU sed。
sed -n 'G;
s/\n/&&/; /^\([ -~]*\n\).*\n\1/d;
s/\n//; h; P'
删除除重复行外的所有行（模拟“uniq -d”）
sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'
删除文件中开头的10行
sed '1,10d'
删除文件中的最后一行
sed '$d'
删除文件中的最后两行
sed 'N;$!P;$!D;$d'
删除文件中的最后10行
sed -e :a -e '$d;N;2,10ba' -e
'P;D' # 方法1
sed -n -e :a -e
'1,10!{P;N;D;};N;ba' # 方法2
删除8的倍数行
gsed
'0~8d'
# 只对GNU sed有效
sed
'n;n;n;n;n;n;n;d;'
# 其他sed
删除匹配式样的行
sed
'/pattern/d'
# 删除含pattern的行。当然pattern可以换成任何有效的正则表达式
删除文件中的所有空行（与“grep '.' ”效果相同）
sed
'/^$/d'
# 方法1
sed
'/./!d'
# 方法2
只保留多个相邻空行的第一行。并且删除文件顶部和尾部的空行。（模拟“cat -s”）
sed
'/./,/^$/!d'
#方法1，删除文件顶部的空行，允许尾部保留一空行
sed
'/^$/N;/\n$/D'
#方法2，允许顶部保留一空行，尾部不留空行
只保留多个相邻空行的前两行。
sed '/^$/N;/\n$/N;//D'
删除文件顶部的所有空行
sed '/./,$!d'
删除文件尾部的所有空行
sed -e :a -e '/^\n*$/{$d;N;ba' -e
'}' # 对所有sed有效
sed -e :a -e
'/^\n*$/N;/\n$/ba'
# 同上，但只对 gsed 3.02.*有效
删除每个段落的最后一行
sed -n '/^$/{p;h;};/./{x;/./p;}'
移除手册页（man page）中的nroff标记。在Unix System V或bash
shell下使用'echo'命令时可能需要加上 -e 选项。
sed "s/.`echo
"
# 外层的双括号是必须的（Unix环境）
sed
's/.^H//g'
# 在bash或tcsh中, 按 Ctrl-V 再按 Ctrl-H
sed
's/.\x08//g'
# sed 1.5，GNU sed，ssed所使用的十六进制的表示方法
提取新闻组或 e-mail 的邮件头
sed
'/^$/q'
# 删除第一行空行后的所有内容
提取新闻组或 e-mail 的正文部分
sed
'1,/^$/d'
# 删除第一行空行之前的所有内容
从邮件头提取“Subject”（标题栏字段），并移除开头的“Subject:”字样
sed '/^Subject: */!d; s///;q'
从邮件头获得回复地址
sed '/^Reply-To:/q; /^From:/h; /./d;g;q'
获取邮件地址。在上一个脚本所产生的那一行邮件头的基础上进一步的将非电邮地址的部分剃除。（见上一脚本）
sed 's/ *(.*)//; s/>.*//;
s/.*[:<] *//'
在每一行开头加上一个尖括号和空格（引用信息）
sed 's/^/> /'
将每一行开头处的尖括号和空格删除（解除引用）
sed 's/^> //'
移除大部分的HTML标签（包括跨行标签）
sed -e :a -e
's/<[^>]*>//g;/</N;//ba'
将分成多卷的uuencode文件解码。移除文件头信息，只保留uuencode编码部分。文件必须以特定顺序传给sed。下面第一种版本的脚本可以直接在命令行下输入；第二种版本则可以放入一个带执行权限的shell脚本中。（由Rahul
Dhesi的一个脚本修改而来。）
sed '/^end/,/^begin/d' file1 file2 ... fileX |
uudecode # vers. 1
sed '/^end/,/^begin/d' "$@" |
uudecode
# vers. 2
将文件中的段落以字母顺序排序。段落间以（一行或多行）空行分隔。GNU
sed使用字元“\v”来表示垂直制表符，这里用它来作为换行符的占位符——当然你也可以用其他未在文件中使用的字符来代替它。
sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed
'1s/={NL}=//;s/={NL}=/\n/g'
gsed '/./{H;d};x;y/\n/\v/' file | sort | sed
'1s/\v//;y/\v/\n/'
分别压缩每个.TXT文件，压缩后删除原来的文件并将压缩后的.ZIP文件命名为与原来相同的名字（只是扩展名不同）。（DOS环境：“dir
/b”显示不带路径的文件名）。
echo @echo off >zipup.bat
dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1
\1.TXT/" >>zipup.bat
使用SED：Sed接受一个或多个编辑命令，并且每读入一行后就依次应用这些命令。当读入第一行输入后，sed对其应用所有的命令，然后将结果输出。接着
再读入第二行输入，对其应用所有的命令……并重复这个过程。上一个例子中sed由标准输入设备（即命令解释器，通常是以管道输入的形式）获得输入。在命令
行给出一个或多个文件名作为参数时，这些文件取代标准输入设备成为sed的输入。sed的输出将被送到标准输出（显示器）。因此：
cat filename | sed
'10q'
# 使用管道输入
sed '10q'
filename
# 同样效果，但不使用管道输入
sed '10q' filename >
newfile
# 将输出转移（重定向）到磁盘上
括号语法：前面的例子对sed命令基本上都使用单引号（'...'）而非双引号（"..."）这是因为sed通常是在Unix平台上使用。单引号
下，Unix的shell（命令解释器）不会对美元符（$）和后引号（`...`）进行解释和执行。而在双引号下美元符会被展开为变量或参数的值，后引号
中的命令被执行并以输出的结果代替后引号中的内容。而在“csh”及其衍生的shell中使用感叹号（!）时需要在其前面加上转义用的反斜杠（就像这
样：\!）以保证上面所使用的例子能正常运行（包括使用单引号的情况下）。DOS版本的Sed则一律使用双引号（"..."）而不是引号来圈起命令。
'\t'的用法：为了使本文保持行文简洁，我们在脚本中使用'\t'来表示一个制表符。但是现在大部分版本的sed还不能识别'\t'的简写方式，因此当
在命令行中为脚本输入制表符时，你应该直接按TAB键来输入制表符而不是输入'\t'。下列的工具软件都支持'\t'做为一个正则表达式的字元来表示制表
符：awk、perl、HHsed、sedmod以及GNU
sed v3.02.80。
不同版本的SED：不同的版本间的sed会有些不同之处，可以想象它们之间在语法上会有差异。具体而言，它们中大部分不支持在编辑命令中间使用标签
（:name）或分支命令（b,t），除非是放在那些的末尾。这篇文档中我们尽量选用了可移植性较高的语法，以使大多数版本的sed的用户都能使用这些脚
本。不过GNU版本的sed允许使用更简洁的语法。想像一下当读者看到一个很长的命令时的心情：
sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
好消息是GNU sed能让命令更紧凑：
sed
'/AAA/b;/BBB/b;/CCC/b;d'
# 甚至可以写成
sed '/AAA\|BBB\|CCC/b;d'
此外，请注意虽然许多版本的sed接受象“/one/
s/RE1/RE2/”这种在's'前带有空格的命令，但这些版本中有些却不接受这样的命令:“/one/!
s/RE1/RE2/”。这时只需要把中间的空格去掉就行了。
速度优化：当由于某种原因（比如输入文件较大、处理器或硬盘较慢等）需要提高命令执行速度时，可以考虑在替换命令（“s/.../.../”）前面加上地址表达式来提高速度。举例来说：
sed 's/foo/bar/g'
filename
# 标准替换命令
sed '/foo/ s/foo/bar/g'
filename # 速度更快
sed '/foo/ s//bar/g'
filename
# 简写形式
当只需要显示文件的前面的部分或需要删除后面的内容时，可以在脚本中使用“q”命令（退出命令）。在处理大的文件时，这会节省大量时间。因此：
sed -n '45,50p'
filename
# 显示第45到50行
sed -n '51q;45,50p'
filename
# 一样，但快得多
对所有文件中的内容进行替换:
sed -i "s/1/一/g" ./* 此方法有时无效
sed -i "s/1/一/g" `find . -type f`
不覆盖原文件内容: sed 's/111/一一一/g' file > file1
sed用法：
sed 'Command' filename(s) 只显示结果而不修改文件。
1、sed '2,5d' file 显示文件file，除去2-5行，但行数超过文件实际行数时不会报错。
sed '/10[1-4]/d' file 显示文件file，除去包含101-104的行。
sed '2,$d' file 显示文件，只显示第一行。sed '2,$!d' file则只显示除第一行外的其它行。
sed '/^ *$/d file 删除文件中的空行。
2、sed -n '/10[1-4]/p' file 只显示文件file中包含101-104的行。(-n和p必须同时使用，否则只有p时显示全部文件并多显示一次找到的行)
sed -n '5p' file 只显示文件的第5行
3、sed 's/moding/moden/g' file 将moding替换为moden
4、sed -n 's/^west/north/p' file 将west开头的行替换为north并显示出来。
5、sed 's/[0-9][0-9][0-9]$/&.5/' file将file文件中以3个数字结尾的行替换为原数字加".5",&代表搜索到的字符串。
6、sed 's/\(mod\)ing/\1en/g file 将mod做为模式1封装在括号里，然后替换。
sed 's/...$//' file 删除每一行的最后三个字符。
sed 's/^...//' file 删除每一行的头三个字符。
7、sed 's#moding#moden#g' file 将moding替换为moden，s后面的#代表搜索串和替换串之间的分界符。
8、sed -n '/101/,/105/p' file 显示从101的匹配行到105的匹配行。如果只找到101的匹配行，则从101的匹配行到文件末。
sed -n '2,/999/p' file 显示从第2行到匹配行。
9、sed '/101/,/105/s/$/ 20050119/' file将从101的匹配行到105的匹配行的行末增加" 20050119"内容。
10、sed -e '1,3d' -e 's/moding/moden/g' file 先删除文件的1-3行，再进行替换。
sed -e '/^#/!d' file 显示文件以#开头的行。
11、sed '/101/r newfile' file 在每个匹配行增加文件newfile的内容
sed '/101/w newfile' file 把匹配行写入newfile。
12、sed '/101/a\
> ###' file 在匹配行后增加一新行。
sed '/101/i\
> ###' file 在匹配行前增加一新行。
sed '/101/c\
> ###' file 用新行替换匹配行。
13、sed 'y/abcd/ABCD/' file 将a、b、c、d分别替换为ABCD。
14、sed '5q' file 显示到第5行时退出。
15、sed '/101/{ n; s/moding/moden/g; }' file 在文件中找到匹配行的后一行(n)再进行替换。
sed '/101/{ s/moding/moden/g; q; }' file 在文件中找到第一个匹配行后进行替换后再退出。
16、sed -e '/101/{ h; d; }' -e '/104/{ G; }' file 在文件中找到与101匹配行后先存在一个缓存中，再放在与104匹配行后。
sed -e '/101/{ h; d; }' -e '/104/{ g; }' file 在文件中找到与101匹配行后先存在一个缓存中，再替代104的匹配行。
sed -e '/101/h' -e '$G' file 将最后一个匹配行放在文件末。
sed -e '/101/h' -e '$g' file 将最后一个匹配行替换文件末行。
sed -e '/101/h' -e '/104/x' file 在文件中找到与101匹配行后先存在一个缓存中，再与104的匹配行进行互换。
17、sed -f sfile file 根据文件sfile的命令列表进行操作。
cat sfile
/101/a\
####101####\
****101****
/104/c\
####104 deleted####\
****104 deleted****
1i\
####test####\
****test****
很强大又很难，其中还有很多没懂，先都总结下来再慢慢学习。
sed
参数s：替换文字内字符串。最多与两个地址参数配合。
1.在包含字符串test的任意行上，将111替换成222
#sed '/test/s/111/222/g' sample.txt
2.以下三个命令相等，先在包含字符串test的任意行上，将111替换成222，再将字符f替换成hello
#sed '/test/s/111/222/g ; s/f/hello/g' sample.txt
#sed -e '/test/s/111/222/g' -e 's/f/hello/g' sample.txt
将要执行的所以编译命令放入在文件中
#more scher
/test/s/111/222/g
s/f/hello/g' sample.txt
#sed -f scher sample.txt
3.替换每行的第N个匹配(示例为替换第八个字符)
#sed ‘s/test/TEST/8' sample.txt
4在第三到第五行前加入hello
#sed '3,5 s/^/hello/' sample.txt
参数d: 删除数据行。最多与两个地址参数配合。
1.删除第一到三行
#sed ‘1，3d’sample.txt
2.删除带user的行
#sed ‘/user/d’sample.txt
3.删除带有a或b字符的行
#sed '/[ab]/d' sample.txt
参数a:将资料添加到指定文件后。最多与一个地址参数配合。
1.在含有FTP的行后面插入一行123
#sed -e '/FTP/a\123' sample.txt
2.在第五行后插入123
#sed -e '5 a\123' sample.txt
参数i将资料插入到指定文件前。最多与一个地址参数配合。
1.在含有FTP的行前面插入一行123
#sed -e '/FTP/i\123' sample.txt
2.在第五前后插入123
#sed -e '5 i\123' sample.txt
参数c：改变文件中的数据。最多与两个地址参数配合。
1.以使用者输入的数据取代数据
eg:将文件1到100行的数据替换成test
#sed -e '1.100c test' sample.txt
2.把a和b替换成hello
#sed '/[a b]/c\hello' sample.txt
参数p：打印出资料。最多与两个地址参数配合。
1.打印出含有a或b的行
#sed -n -e '/[ab]/p' sample.txt
参数r：读入他的档案内容到文件中。最多与一个地址参数配合。
1.将temp.txt中的内容，搬至文件中含有AA字符串的数据行后（temp.txt中有内容）
#sed -e '/AA/r temp.txt' sample.txt
参数w：读入文件中的内容存入到另一文件中（temp.txt)。最多与一个地址参数配合。
1.将文件中含test字符串的数据行，copy至temp.txt档中储存(原temp.txt中无内容）
#sed -e '/test/w temp.txt' sample.txt
参数y：转换数据中的字符。最多与两个地址参数配合。
1.将文件中的小写字母替换成大写字母。
#sed -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' sample.txt
其中前后字符个数必须相同.
参数!:表示不执行函数参数。
1.将文件中除了important字符串，其余全删除。
#sed -e '/important/!d' sample.txt
参数n：表示读入下一行数据。最多与两个地址参数配合。
解释：例如源文件为：
A
B
C
D
那么实际读入到pattern space的数据就为B D，因为他们分别为第一行A和第三行C的下一行.
1.输出源文件的偶数行数据。
#sed -n -e 'n' -e 'p' sample.txt
或#sed -n 'n;p' sample.txt
这里-n是选项。‘’中的n才是参数。-n的意思是将数据输出的控制权转给指令，即只显示处理后的结果。
利用n将下一行资料（即：偶数行）取代pattern space的资料行（奇数行）
2.输出源文件的奇数行数据。
#sed -n -e 'p' -e 'n' sample.txt
#sed -n 'p;n' sample.txt
参数q：表示跳离sed。最多与一个地址参数配合。
1.打印出含有a或b字符的行，一旦遇到数字，即刻停止打印。
#sed -n -e '/[0-9]/q' -e '/[a b]/p' sample.txt
参数=：表示印出资料的行数。最多与两个地址参数配合。
1.印出文件资料中的行数。
#sed -e ‘=’ sample.txt
参数#：表示对文字的注释。
参数N：表示添加下一笔资料到pattern space内。最多与两个地址参数配合。（添加下一笔：添加一笔资料后，继续添加这个资料的下一行数据到pattern space内）
1，将文件中的数据合并。文件内容如下：
UNIX
LINUX
#sed -e 'N' -e's/\n/\,/g' sample.txt
结果如下：
UNIX,LINUX
参数D：表示删除pattern space内的第一行资料。最多与两个地址参数配合。
参数P：打印出pattern space内的第一行资料。
#sed -n -e 'N' -e 'P' sample.txt
利用N将下一行资料（即：偶数行）添加到pattern space内，在利用P打印出奇数行。
解释过程：由于N的作用，使得每次添加一条资料到pattern space后，先不执行操作，而是继续添加这个资料的下一行到pattern space内，
然后P参数打印出第一行资料。
参数h：表示暂存pattern space的内容至hold space（覆盖）。最多与两个地址参数配合。
参数H：表示暂存pattern space的内容至hold space（添加）。最多与两个地址参数配合。
参数g：表示将hold space的内容放回至pattern space内。（覆盖掉原pattern space内的数据）
参数G：表示将hold space的内容放回至pattern space内。（添加大到原pattern space数据之后）
1.将文件中所有空行删除，并在每一行后面增加一个空行。
sed '/^$/d;G' sample.txt
2.将文件中所有空行删除，并在每一行后面增加两个空行。
sed '/^$/d;G;G' sample.txt
参数x：表示交换hold space与pattern space内的数据。
1.将文件第三行的数据替换成第一行的数据。
#sed -e '1h' -e '3x' sample.txt
参数b：
参数t：
一些示例：
1.在匹配式样test的行之前插入一空行。
#sed '/test/i\ ' sample.txt
#sed '/test/{x;p;x}' sample.txt
2.在匹配式样test的行之后插入一空行。
#sed '/test/a\ ' sample.txt
#sed '/test/G' sample.txt
3.为文中每一行进行编号。
#sed = sample.txt | sed 'N;s/\n/:/'
#sed = sample.txt | sed 'N;s/\n/\t/'
4.为文中每一行进行编号，但只显示非空行的编号。
#sed /./= sample.txt | sed '/./N;s/\n/:/'
.不匹配空。将sample.txt中所有非空行编号，然后取出不包含非空行的行及其下一行数据放入pattern space内，再将空格替换成：）
5.计算文件行数。
Sed命令是linux下的一个非常有用的命令，特别是在shell脚本中经常会使用到他。
熟悉他你会觉得非常有趣哦！
1.sed -n '2'p filename
打印文件的第二行。
2.sed -n '1,3'p filename
打印文件的1到3行
3. sed -n '/Neave/'p filename
打印匹配Neave的行(模糊匹配)
4. sed -n '4,/The/'p filename
在第4行查询模式The
5. sed -n '1,$'p filename
打印整个文件，$表示最后一行。
6. sed -n '/.*ing/'p filename
匹配任意字母，并以ing结尾的单词(点号不能少)
7 sed -n / -e '/music/'= filename
打印匹配行的行号，-e 会打印文件的内容，同时在匹配行的前面标志行号。-n只打印出实际的行号。
8.sed -n -e '/music/'p -e '/music/'= filename
打印匹配的行和行号，行号在内容的下面
9.sed '/company/' a\ "Then suddenly it happend" filename
选择含有company的行，将后面的内容"Then suddenly it happend"加入下一行。注意：它并不改变文件，所有操作在缓冲区，如果要保存输出，重定向到一个文件。
10. sed '/company/' i\ "Then suddenly it happend" filename
同9，只是在匹配的行前插入
11.sed '/company/' c\ "Then suddenly it happend" filename
用"Then suddenly it happend"替换匹配company的行的内容。
12.sed '1'd ( '1,3'd '$'d '/Neave/'d) filename
删除第一行(1到3行，最后一行，匹配Neave的行)
13.[ address [，address]] s/ pattern-to-find /replacement-pattern/[g p w n]
s选项通知s e d这是一个替换操作，并查询pattern-to-find，成功后用replacement-pattern替换它。
替换选项如下：
g 缺省情况下只替换第一次出现模式，使用g选项替换全局所有出现模式。
p 缺省s e d将所有被替换行写入标准输出，加p选项将使- n选项无效。- n选项不打印输出结果。
w 文件名使用此选项将输出定向到一个文件。(注意只将匹配替换的行写入文件，而不是整个内容)
14.sed s'/nurse/"hello "&/' filename
将'hello '增加到'nurse' 的前面。
15. sed '/company/r append.txt' filename
在匹配company的行的下一行开始加入文件append.txt的内容。
16. sed '/company/'q filename
首次匹配company后就退出sed程序
只所以看sed命令，是因为我遇到了这个一个问题。
网上有很多教程，他们发表了很多程序代码，但是作者为了解释方便，都对程序作了行号编码，就像下面这样：
代码::
1:#!/bin/bash
2:#rename file extesions
3:#
4:# rfe old_extensions new_extension
假设这个文件名是tmp，那么我们可以使用下面的命令来去掉这个行号和冒号(：)
代码::
sed -e s'/^[0-9]\{1,\}://g' tmp
不过上面的命令的命令有一个缺点，那就是如果这个行号不是数字开头，而是有空格的话，那就需要修改匹配规则，规则应该修改为匹配第一个非空白字符是数字开始，后面接一个冒号的配对。命令如下：
代码::
sed -e s'/^[^0-9a-zA-Z]*[0-9]\{1,\}://g' tmp
这令我很兴奋，于是想看看sed到底有多厉害，看了以后，明白的是不是sed有多厉害，就像awk一样，他们只是把正规表达式用到了极致。
以 Redhat6.0 为测试环境
事实上在solaris下的sed命令要比linux强，但因为没有测试
环境，我这里只给在linux下经过测试的用法。
★ 命令行参数简介
★ 首先假设我们有这样一个文本文件 sedtest.txt
★ 输出指定范围的行 p
★ 在每一行前面增加一个制表符(^I)
★ 在每一行后面增加--end
★ 显示指定模式匹配行的行号 [/pattern/]=
★ 在匹配行后面增加文本 [/pattern/]a\ 或者 [address]a\
★ 删除匹配行 [/pattern/]d 或者 [address1][,address2]d
★ 替换匹配行 [/pattern/]c\ 或者 [address1][,address2]c\
★ 在匹配行前面插入文本 [/pattern/]i\ 或者 [address]i\
★ 替换匹配串(注意不再是匹配行) [addr1][,addr2]s/old/new/g
★ 限定范围后的模式匹配
★ 指定替换每一行中匹配的第几次出现
★ &代表最后匹配
★ 利用sed修改PATH环境变量
★ 测试并提高sed命令运行效率
★ 指定输出文件 [address1][,address2]w outputfile
★ 指定输入文件 [address]r inputfile
★ 替换相应字符 [address1][,address2]y/old/new/
★ !号的使用
★ \c正则表达式c 的使用
★ sed命令中正则表达式的复杂性
★ 转换man手册成普通文本格式(新)
★ sed的man手册(用的就是上面的方法)
★ 命令行参数简介
sed
-e script 指定sed编辑命令
-f scriptfile 指定的文件中是sed编辑命令
-n 寂静模式，抑制来自sed命令执行过程中的冗余输出信息，比如只
显示那些被改变的行。
不明白？不要紧，把这些肮脏丢到一边，跟我往下走，不过下面的介绍里
不包括正则表达式的解释，如果你不明白，可能有点麻烦。
★ 首先假设我们有这样一个文本文件 sedtest.txt
cat > sedtest.txt
Sed is a stream editor
----------------------
A stream editor is used to perform basic text transformations on an input stream
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
★ 输出指定范围的行 p other types of editors.
sed -e "1,4p" -n sedtest.txt
sed -e "/from/p" -n sedtest.txt
sed -e "1,/from/p" -n sedtest.txt
★ 在每一行前面增加一个制表符(^I)
sed "s/^/^I/g" sedtest.txt
注意^I的输入方法是ctrl-v ctrl-i
单个^表示行首
★ 在每一行后面增加--end
sed "s/$/--end/g" sedtest.txt
单个$表示行尾
★ 显示指定模式匹配行的行号 [/pattern/]=
sed -e '/is/=' sedtest.txt
1
Sed is a stream editor
----------------------
3
A stream editor is used to perform basic text transformations on an input stream
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
7
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
9
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
-
意思是分析sedtest.txt，显示那些包含is串的匹配行的行号，注意11行中出现了is字符串
这个输出是面向stdout的，如果不做重定向处理，则不影响原来的sedtest.txt
★ 在匹配行后面增加文本 [/pattern/]a\ 或者 [address]a\
^D
sed -f sedadd.script sedtest.txt
Sed is a stream editor
A stream editor is used to perform basic text transformations on an input stream
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
-
[scz@ /home/scz/src]> sed -e "a\\
+++++++++
---------------------------------------------
找到包含from字符串的行，在该行的下一行增加+++++++++。
这个输出是面向stdout的，如果不做重定向处理，则不影响原来的sedtest.txt
很多人想在命令行上直接完成这个操作而不是多一个sedadd.script，不幸的是，这需要用?nbsp;
?nbsp;
续行符\，
[scz@ /home/scz/src]> sed -e "/from/a\\
＞ +++++++++" sedtest.txt
[scz@ /home/scz/src]> sed -e "a\\
＞ +++++++++" sedtest.txt
上面这条命令将在所有行后增加一个新行+++++++++
[scz@ /home/scz/src]> sed -e "1 a\\
＞ +++++++++" sedtest.txt
把下面这两行copy/paste到一个shell命令行上，效果一样
+++++++++" sedtest.txt
[address]a\ 只接受一个地址指定
对于a命令，不支持单引号，只能用双引号，而对于d命令等其他命令，同时
★ 删除匹配行 [/pattern/]d 或者 [address1][,address2]d
sed -e '/---------------------------------------------/d' sedtest.txt
Sed is a stream editor
A stream editor is used to perform basic text transformations on an input stream
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
sed works by making only one pass over the input(s), and is consequently more
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
sed -e '6,10d' sedtest.txt
删除6-10行的内容，包括6和10
sed -e "2d" sedtest.txt
删除第2行的内容
sed "1,/^$/d" sedtest.txt
删除从第一行到第一个空行之间的所有内容
注意这个命令很容易带来意外的结果，当sedtest.txt中从第一行开始并没有空行，则sed删
?nbsp;
?nbsp;
sed "1,/from/d" sedtest.txt
删除从第一行到第一个包含from字符串的行之间的所有内容，包括第一个包含
from字符串的行。
★ 替换匹配行 [/pattern/]c\ 或者 [address1][,address2]c\
sed -e "/is/c\\
**********" sedtest.txt
寻找所有包含is字符串的匹配行，替换成**********
**********
----------------------
**********
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
**********
-----------------------------------------------------------------------------
**********
--------------------------------------------------------------------------------
-
sed -e "1,11c\\
**********" sedtest.txt----------------------
在1-12行内搜索所有from字符串，分别替换成****字符串
★ 限定范围后的模式匹配
sed "/But/s/is/are/g" sedtest.txt
对那些包含But字符串的行，把is替换成are
sed "/is/s/t/T/" sedtest.txt
对那些包含is字符串的行，把每行第一个出现的t替换成T
sed "/While/,/from/p" sedtest.txt -n
输出在这两个模式匹配行之间的所有内容
★ 指定替换每一行中匹配的第几次出现
sed "s/is/are/5" sedtest.txt
把每行的is字符串的第5次出现替换成are
★ &代表最后匹配
sed "s/^$/(&)/" sedtest.txt
给所有空行增加一对()
sed "s/is/(&)/g" sedtest.txt
给所有is字符串外增加()
sed "s/.*/(&)/" sedtest.txt
给所有行增加一对()
sed "/is/s/.*/(&)/" sedtest.txt
给所有包含is字符串的行增加一对()
★ 利用sed修改PATH环境变量
先查看PATH环境变量
[scz@ /home/scz/src]> echo $PATH
/usr/bin:/usr/bin:/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/X11R6/bin:.
去掉尾部的{ :/usr/X11R6/bin:. }
[scz@ /home/scz/src]> echo $PATH | sed "s/^\(.*\):\/usr[/]X11R6\/bin:[.]$/\1/"
/usr/bin:/usr/bin:/bin:/usr/local/bin:/sbin:/usr/sbin
去掉中间的{ :/bin: }
[scz@ /home/scz/src]> echo $PATH | sed "s/^\(.*\):\/bin:\(.*\)$/\1\2/"
/usr/bin:/usr/bin/usr/local/bin:/sbin:/usr/sbin:/usr/X11R6/bin:.
[/]表示/失去特殊意义
\/同样表示/失去意义
\1表示子匹配的第一次出现
\2表示子匹配的第二次出现
\(.*\)表示子匹配
去掉尾部的:，然后增加新的路径
PATH=`echo $PATH | sed 's/\(.*\):$/\1/'`:$HOME/src
注意反引号`和单引号'的区别。
★ 测试并提高sed命令运行效率
time sed -n "1,12p" webkeeper.db > /dev/null
time sed 12q webkeeper.db > /dev/null可以看出后者比前者效率高。
[address]q 当碰上指定行时退出sed执行
★ 指定输出文件 [address1][,address2]w outputfile
sed "1,10w sed.out" sedtest.txt -n
将sedtest.txt中1-10行的内容写到sed.out文件中。
★ 指定输入文件 [address]r inputfile
sed "1r sedappend.txt" sedtest.txt
将sedappend.txt中的内容附加到sedtest.txt文件的第一行之后
★ 替换相应字符 [address1][,address2]y/old/new/
sed "y/abcdef/ABCDEF/" sedtest.txt
将sedtest.txt中所有的abcdef小写字母替换成ABCDEF大写字母。
★ !号的使用
sed -e '3,7!d' sedtest.txt
删除3-7行之外的所有行
sed -e '1,/from/!d' sedtest.txt
找到包含from字符串的行，删除其后的所有行
★ \c正则表达式c 的使用
sed -e "\:from:d" sedtest.txt
等价于 sed -e "/from/d" sedtest.txt
★ sed命令中正则表达式的复杂性
cat > sedtest.txt
^\/[}]{.*}[\(]$\)
^D
如何才能把该行替换成
\(]$\)\/[}]{.*}^[
★ 转换man手册成普通文本格式(新)
man sed | col -b > sed.txt
sed -e "s/^H//g" -e "/^$/d" -e "s/^^I/ /g" -e "s/^I/ /g" sed.txt > sedman
txt
删除所有退格键、空行，把行首的制表符替换成8个空格，其余制表符替换成一个空格。
★ sed的man手册(用的就是上面的方法)
NAME
sed - a Stream EDitor
SYNOPSIS
sed [-n] [-V] [--quiet] [--silent] [--version] [--help]
[-e script] [--expression=script]
[-f script-file] [--file=script-file]
[script-if-no-other-script]
[file...]
DESCRIPTION
Sed is a stream editor. A stream editor is used to per-
form basic text transformations on an input stream (a file
or input from a pipeline). While in some ways similar to
an editor which permits scripted edits (such as ed), sed
works by making only one pass over the input(s), and is
consequently more efficient. But it is sed's ability to
filter text in a pipeline which particularly distinguishes
it from other types of editors.
OPTIONS
Sed may be invoked with the following command-line
options:
-V
--version
Print out the version of sed that is being run and
a copyright notice, then exit.
-h
--help Print a usage message briefly summarizing these
command-line options and the bug-reporting address,
then exit.
-n
--quiet
--silent
By default, sed will print out the pattern space at
the end of each cycle through the script. These
options disable this automatic printing, and sed
will only produce output when explicitly told to
via the p command.
-e script
--expression=script
Add the commands in script to the set of commands
to be run while processing the input.
-f script-file
--file=script-file
Add the commands contained in the file script-file
to the set of commands to be run while processingthe input.
If no -e,-f,--expression, or --file options are given on
the command-line, then the first non-option argument on
the command line is taken to be the script to be executed.
If any command-line parameters remain after processing the
above, these parameters are interpreted as the names of
input files to be processed. A file name of - refers to
the standard input stream. The standard input will pro-
cessed if no file names are specified.
Command Synopsis
This is just a brief synopsis of sed commands to serve as
a reminder to those who already know sed; other documenta-
tion (such as the texinfo document) must be consulted for
fuller descriptions.
Zero-address ``commands''
: label
Label for b and t commands.
#comment
The comment extends until the next newline (or the
end of a -e script fragment).
} The closing bracket of a { } block.
Zero- or One- address commands
= Print the current line number.
a \
text Append text, which has each embedded newline pre-
ceeded by a backslash.
i \
text Insert text, which has each embedded newline pre-
ceeded by a backslash.
q Immediately quit the sed script without processing
any more input, except that if auto-print is not
diabled the current pattern space will be printed.
r filename
Append text read from filename.
Commands which accept address ranges
{ Begin a block of commands (end with a }).
b label
Branch to label; if label is omitted, branch to end
of script.
t label
If a s/// has done a successful substitution since
the last input line was read and since the last t
command, then branch to label; if label is omitted,
branch to end of script.
c \
text Replace the selected lines with text, which has
each embedded newline preceeded by a backslash.
d Delete pattern space. Start next cycle.
D Delete up to the first embedded newline in the pat-
tern space. Start next cycle, but skip reading
from the input if there is still data in the pat-
tern space.
h H Copy/append pattern space to hold space.
g G Copy/append hold space to pattern space.
x Exchange the contents of the hold and pattern
spaces.
l List out the current line in a ``visually unambigu-
ous'' form.
n N Read/append the next line of input into the pattern
space.
p Print the current pattern space.
P Print up to the first embedded newline of the cur-
rent pattern space.
s/regexp/replacement/
Attempt to match regexp against the pattern space.
If successful, replace that portion matched with
replacement. The replacement may contain the spe-
cial character & to refer to that portion of the
pattern space which matched, and the special
escapes \1 through \9 to refer to the corresponding
matching sub-expressions in the regexp.
w filename Write the current pattern space to file-
name.
y/source/dest/
Transliterate the characters in the pattern space
which appear in source to the corresponding charac-
ter in dest.
Addresses
Sed commands can be given with no addresses, in which case
the command will be executed for all input lines; with one
address, in which case the command will only be executed
for input lines which match that address; or with two
addresses, in which case the command will be executed for
all input lines which match the inclusive range of lines
starting from the first address and continuing to the sec-
ond address. Three things to note about address ranges:
the syntax is addr1,addr2 (i.e., the addresses are sepa-
rated by a comma); the line which addr1 matched will
always be accepted, even if addr2 selects an earlier line;
and if addr2 is a regexp, it will not be tested against
the line that addr1 matched.
After the address (or address-range), and before the com-
mand, a ! may be inserted, which specifies that the com-
mand shall only be executed if the address (or address-
range) does not match.
The following address types are supported:
number Match only the specified line number.
first~step
Match every step'th line starting with line first.
For example, ``sed -n 1~2p'' will print all the
odd-numbered lines in the input stream, and the
address 2~5 will match every fifth line, starting
with the second. (This is a GNU extension.)
$ Match the last line.
/regexp/
Match lines matching the regular expression regexp.
\cregexpc
Match lines matching the regular expression regexp.
The c may be any character.
Regular expressions
POSIX.2 BREs should be supported, but they aren't com-
pletely yet. The \n sequence in a regular expression
matches the newline character. There are also some GNU
extensions. [XXX FIXME: more needs to be said. At the
very least, a reference to another document which
describes what is supported should be given.]
Miscellaneous notes
This version of sed supports a \ sequence in all
regular expressions, the replacement part of a substitute
(s) command, and in the source and dest parts of a
transliterate (y) command. The \ is stripped, and the
newline is kept.
SEE ALSO
awk(1), ed(1), expr(1), emacs(1), perl(1), tr(1), vi(1),
regex(5) [well, one ought to be written... XXX], sed.info,
any of various books on sed, the sed FAQ
(http://www.wollery.demon.co.uk/sedtut10.txt,
http://www.ptug.org/sed/sedfaq.htm).
BUGS
E-mail bug reports to [email protected]. Be sure to
include the word ``sed'' somewhere in the ``Subject:''
field.
Sed学习笔记
作者：Jims of
肥肥世家
Table of Contents
1. Sed简介
2. 定址
3. Sed命令
4. 选项
5. 元字符集
6. 实例
7. 脚本
1. Sed简介
sed是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。
2. 定址
可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定 。
3. Sed命令
调用sed命令有两种形式：
sed [options] 'command' file(s)
sed [options] -f scriptfile file(s)
a\
在当前行后面加入一行文本。
b lable
分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
c\
用新的文本改变本行的文本。
d
从模板块（Pattern space）位置删除行。
D
删除模板块的第一行。
i\
在当前行上面插入文本。
h
拷贝模板块的内容到内存中的缓冲区。
H
追加模板块的内容到内存中的缓冲区
g
获得内存缓冲区的内容，并替代当前模板块中的文本。
G
获得内存缓冲区的内容，并追加到当前模板块文本的后面。
l
列表不能打印字符的清单。
n
读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
N
追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
p
打印模板块的行。
P（大写）
打印模板块的第一行。
q
退出Sed。
r file
从file中读行。
t label
if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
T label
错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
w file
写并追加模板块到file末尾。
W file
写并追加模板块的第一行到file末尾。
!
表示后面的命令对所有没有被选定的行发生作用。
s/re/string
用string替换正则表达式re。
=
打印当前行号码。
#
把注释扩展到下一个换行符以前。
以下的是替换标记
g表示行内全面替换。
p表示打印行。
w表示把行写入一个文件。
x表示互换模板块中的文本和缓冲区中的文本。
y表示把一个字符翻译为另外的字符（但是不用于正则表达式）
4. 选项
-e command, --expression=command
允许多台编辑。
-h, --help
打印帮助，并显示bug列表的地址。
-n, --quiet, --silent
取消默认输出。
-f, --filer=script-file
引导sed脚本文件名。
-V, --version
打印版本和版权信息。
5. 元字符集
^ 锚定行的开始 如：/^sed/匹配所有以sed开头的行。
$ 锚定行的结束 如：/sed$/匹配所有以sed结尾的行。
. 匹配一个非换行符的字符 如：/s.d/匹配s后接一个任意字符，然后是d。
* 匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[] 匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^] 匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
\(..\) 保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers。
& 保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
\ 锚定单词的开始，如:/\匹配包含以love开头的单词的行。
\> 锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
x\{m\}重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
x\{m,\} 重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
x\{m,n\}重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
6. 实例
删除：d命令
$ sed '2d' example-----删除example文件的第二行。
$ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
$ sed '$d' example-----删除example文件的最后一行。
$ sed '/test/'d example-----删除example文件所有包含test的行。
替换：s命令
$ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
$ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
$ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加 localhost，变成192.168.0.1localhost。
$ sed -n 's/\(love\)able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
$ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
选定行的范围：逗号
$ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
$ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
$ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
多点编辑：e命令
$ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执 行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
$ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
从文件读入：r命令
$ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
写入文件：w命令
$ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。
追加命令：a命令
$ sed '/^test/a\\--->this is a example' example被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
插入：i命令
$ sed '/test/i\\
new line
-------------------------' example
如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
下一个：n命令
$ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
变形：y命令
$ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
退出：q命令
$ sed '10q' example-----打印完第10行后，退出sed。
保持和获取：h命令和G命令
$ sed -e '/test/h' -e '$G example-----在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保 持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中 的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
保持和互换：h命令和x命令
$ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
7. 脚本
Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
#sed -n '$=' sample.txt
6.字串翻转。
#sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
7，打印文档奇数行。
#sed 'n;d'
#sed 'x;$!N;x'
#sed -n 'p;n' （sed -n -e 'p' -e 'n' ）
#sed -e 'n' -e 'd' 将文件下一行（偶数行),放进pattern space中并删除。
8.打印文档偶数行。
#sed '1d;n;d;' （先删掉第一行，再像奇数行类似处理）
#sed -n 'n;p' （sed -n -e 'n' -e 'p'）
9.删除连续重复行。（可以用sort加uniq取代）
#sed '$!N; /^\(.*\)\n\1$/!P; D'
10.合并上下两行并用空格分割
#sed '$!N;s/\n/ /'
#sed -e 'N' -e 's/\n/ /g'
11.将以\符号结尾的行与下行合并并以空格分隔(拼接断行)
#sed -e :a -e '/\\$/N; s/\\\n/ /; ta'
12.按关键字拼接行。
如果某行以=开始，则合并到上一行并替代＝为空格
#sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'
13.输出匹配行的下一行 （grep -A）
#sed -n '/regexpr/{n;p;}' filename
14.显示匹配行的行号并输出匹配行的上行、匹配行、下行 （grep -N N为想显示的行数）
#sed -n -e '/regexpr/{=;x;1!p;g;$!N;p;D;}' -e h
15.删除文档中某标志区域内的关键字匹配行
删除文档中从being开到end结束的块中包含myword的行
#sed '/^begin/,/^end/{/myword/d;}' filename
16.字串解析。
1.从字串中解析出两个子串(前2各字符和后9个字符)
#echo "WeLoveChinaUnix"|sed -e 'H;s/\(..\).*/\1/;x;s/.*\(.\{9\}\)$/\1/;x;G;s/\n/ /'
We ChinaUnix
2.分解日期串
echo 20030922|sed 's/\(....\)\(..\)\(..\)/\1 \2 \3/'|read year month day
echo $year $month $day
2003 09 22
例如想把aaaa1111bbbb分成 aaaa 1111 bbbb
sed 's/\(....\)\(....\)\(....\)/\1 \2 \3/' sample.txt
\1 \2中间的部分就是想空出来的部分。
示例部分参考http://bbs.chinaunix.net/viewthread.php?tid=166936&extra=&page=1
作者：admirer
补：
sed '/aaa/,/bbb/s/yes/no/' sample.txt
将文件sample.txt中，一行中的aaa到bbb中间的yes替换成no
Sed命令是linux下的一个非常有用的命令，特别是在shell脚本中经常会使用到他。
熟悉他你会觉得非常有趣哦！
1.sed -n '2'p filename
打印文件的第二行。
2.sed -n '1,3'p filename
打印文件的1到3行
3. sed -n '/Neave/'p filename
打印匹配Neave的行(模糊匹配)
4. sed -n '4,/The/'p filename
在第4行查询模式The
5. sed -n '1,$'p filename
打印整个文件，$表示最后一行。
6. sed -n '/.*ing/'p filename
匹配任意字母，并以ing结尾的单词(点号不能少)
7 sed -n / -e '/music/'= filename
打印匹配行的行号，-e 会打印文件的内容，同时在匹配行的前面标志行号。-n只打印出实际的行号。
8.sed -n -e '/music/'p -e '/music/'= filename
打印匹配的行和行号，行号在内容的下面
9.sed '/company/' a\ "Then suddenly it happend" filename
选择含有company的行，将后面的内容"Then suddenly it happend"加入下一行。注意：它并不改变文件，所有操作在缓冲区，如果要保存输出，重定向到一个文件。
10. sed '/company/' i\ "Then suddenly it happend" filename
同9，只是在匹配的行前插入
11.sed '/company/' c\ "Then suddenly it happend" filename
用"Then suddenly it happend"替换匹配company的行的内容。
12.sed '1'd ( '1,3'd '$'d '/Neave/'d) filename
删除第一行(1到3行，最后一行，匹配Neave的行)
13.[ address [，address]] s/ pattern-to-find /replacement-pattern/[g p w n]
s选项通知s e d这是一个替换操作，并查询pattern-to-find，成功后用replacement-pattern替换它。
替换选项如下：
g 缺省情况下只替换第一次出现模式，使用g选项替换全局所有出现模式。
p 缺省s e d将所有被替换行写入标准输出，加p选项将使- n选项无效。- n选项不打印输出结果。
w 文件名使用此选项将输出定向到一个文件。(注意只将匹配替换的行写入文件，而不是整个内容)
14.sed s'/nurse/"hello "&/' filename
将'hello '增加到'nurse' 的前面。
15. sed '/company/r append.txt' filename
在匹配company的行的下一行开始加入文件append.txt的内容。
16. sed '/company/'q filename
首次匹配company后就退出sed程序
只所以看sed命令，是因为我遇到了这个一个问题。
网上有很多教程，他们发表了很多程序代码，但是作者为了解释方便，都对程序作了行号编码，就像下面这样：
代码::
1:#!/bin/bash
2:#rename file extesions
3:#
4:# rfe old_extensions new_extension
假设这个文件名是tmp，那么我们可以使用下面的命令来去掉这个行号和冒号(：)
代码::
sed -e s'/^[0-9]\{1,\}://g' tmp
不过上面的命令的命令有一个缺点，那就是如果这个行号不是数字开头，而是有空格的话，那就需要修改匹配规则，规则应该修改为匹配第一个非空白字符是数字开始，后面接一个冒号的配对。命令如下：
代码::
sed -e s'/^[^0-9a-zA-Z]*[0-9]\{1,\}://g' tmp
这令我很兴奋，于是想看看sed到底有多厉害，看了以后，明白的是不是sed有多厉害，就像awk一样，他们只是把正规表达式用到了极致。
以 Redhat6.0 为测试环境
事实上在solaris下的sed命令要比linux强，但因为没有测试
环境，我这里只给在linux下经过测试的用法。
★ 命令行参数简介
★ 首先假设我们有这样一个文本文件 sedtest.txt
★ 输出指定范围的行 p
★ 在每一行前面增加一个制表符(^I)
★ 在每一行后面增加--end
★ 显示指定模式匹配行的行号 [/pattern/]=
★ 在匹配行后面增加文本 [/pattern/]a\ 或者 [address]a\
★ 删除匹配行 [/pattern/]d 或者 [address1][,address2]d
★ 替换匹配行 [/pattern/]c\ 或者 [address1][,address2]c\
★ 在匹配行前面插入文本 [/pattern/]i\ 或者 [address]i\
★ 替换匹配串(注意不再是匹配行) [addr1][,addr2]s/old/new/g
★ 限定范围后的模式匹配
★ 指定替换每一行中匹配的第几次出现
★ &代表最后匹配
★ 利用sed修改PATH环境变量
★ 测试并提高sed命令运行效率
★ 指定输出文件 [address1][,address2]w outputfile
★ 指定输入文件 [address]r inputfile
★ 替换相应字符 [address1][,address2]y/old/new/
★ !号的使用
★ \c正则表达式c 的使用
★ sed命令中正则表达式的复杂性
★ 转换man手册成普通文本格式(新)
★ sed的man手册(用的就是上面的方法)
★ 命令行参数简介
sed
-e script 指定sed编辑命令
-f scriptfile 指定的文件中是sed编辑命令
-n 寂静模式，抑制来自sed命令执行过程中的冗余输出信息，比如只
显示那些被改变的行。
不明白？不要紧，把这些肮脏丢到一边，跟我往下走，不过下面的介绍里
不包括正则表达式的解释，如果你不明白，可能有点麻烦。
★ 首先假设我们有这样一个文本文件 sedtest.txt
cat > sedtest.txt
Sed is a stream editor
----------------------
A stream editor is used to perform basic text transformations on an input stream
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
★ 输出指定范围的行 p other types of editors.
sed -e "1,4p" -n sedtest.txt
sed -e "/from/p" -n sedtest.txt
sed -e "1,/from/p" -n sedtest.txt
★ 在每一行前面增加一个制表符(^I)
sed "s/^/^I/g" sedtest.txt
注意^I的输入方法是ctrl-v ctrl-i
单个^表示行首
★ 在每一行后面增加--end
sed "s/$/--end/g" sedtest.txt
单个$表示行尾
★ 显示指定模式匹配行的行号 [/pattern/]=
sed -e '/is/=' sedtest.txt
1
Sed is a stream editor
----------------------
3
A stream editor is used to perform basic text transformations on an input stream
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
7
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
9
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
-
意思是分析sedtest.txt，显示那些包含is串的匹配行的行号，注意11行中出现了is字符串
这个输出是面向stdout的，如果不做重定向处理，则不影响原来的sedtest.txt
★ 在匹配行后面增加文本 [/pattern/]a\ 或者 [address]a\
^D
sed -f sedadd.script sedtest.txt
Sed is a stream editor
A stream editor is used to perform basic text transformations on an input stream
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
sed works by making only one pass over the input(s), and is consequently more
-----------------------------------------------------------------------------
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
--------------------------------------------------------------------------------
-
-
[scz@ /home/scz/src]> sed -e "a\\
+++++++++
---------------------------------------------
找到包含from字符串的行，在该行的下一行增加+++++++++。
这个输出是面向stdout的，如果不做重定向处理，则不影响原来的sedtest.txt
很多人想在命令行上直接完成这个操作而不是多一个sedadd.script，不幸的是，这需要用?nbsp;
?nbsp;
续行符\，
[scz@ /home/scz/src]> sed -e "/from/a\\
＞ +++++++++" sedtest.txt
[scz@ /home/scz/src]> sed -e "a\\
＞ +++++++++" sedtest.txt
上面这条命令将在所有行后增加一个新行+++++++++
[scz@ /home/scz/src]> sed -e "1 a\\
＞ +++++++++" sedtest.txt
把下面这两行copy/paste到一个shell命令行上，效果一样
+++++++++" sedtest.txt
[address]a\ 只接受一个地址指定
对于a命令，不支持单引号，只能用双引号，而对于d命令等其他命令，同时
★ 删除匹配行 [/pattern/]d 或者 [address1][,address2]d
sed -e '/---------------------------------------------/d' sedtest.txt
Sed is a stream editor
A stream editor is used to perform basic text transformations on an input stream
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
sed works by making only one pass over the input(s), and is consequently more
efficient. But it is sed's ability to filter text in a pipeline which particular
l
y
sed -e '6,10d' sedtest.txt
删除6-10行的内容，包括6和10
sed -e "2d" sedtest.txt
删除第2行的内容
sed "1,/^$/d" sedtest.txt
删除从第一行到第一个空行之间的所有内容
注意这个命令很容易带来意外的结果，当sedtest.txt中从第一行开始并没有空行，则sed删
?nbsp;
?nbsp;
sed "1,/from/d" sedtest.txt
删除从第一行到第一个包含from字符串的行之间的所有内容，包括第一个包含
from字符串的行。
★ 替换匹配行 [/pattern/]c\ 或者 [address1][,address2]c\
sed -e "/is/c\\
**********" sedtest.txt
寻找所有包含is字符串的匹配行，替换成**********
**********
----------------------
**********
--------------------------------------------------------------------------------
While in some ways similar to an editor which permits scripted edits (such as ed
)
,
--------------------------------------------------------------------------------
-
-
**********
-----------------------------------------------------------------------------
**********
--------------------------------------------------------------------------------
-
sed -e "1,11c\\
**********" sedtest.txt----------------------
在1-12行内搜索所有from字符串，分别替换成****字符串
★ 限定范围后的模式匹配
sed "/But/s/is/are/g" sedtest.txt
对那些包含But字符串的行，把is替换成are
sed "/is/s/t/T/" sedtest.txt
对那些包含is字符串的行，把每行第一个出现的t替换成T
sed "/While/,/from/p" sedtest.txt -n
输出在这两个模式匹配行之间的所有内容
★ 指定替换每一行中匹配的第几次出现
sed "s/is/are/5" sedtest.txt
把每行的is字符串的第5次出现替换成are
★ &代表最后匹配
sed "s/^$/(&)/" sedtest.txt
给所有空行增加一对()
sed "s/is/(&)/g" sedtest.txt
给所有is字符串外增加()
sed "s/.*/(&)/" sedtest.txt
给所有行增加一对()
sed "/is/s/.*/(&)/" sedtest.txt
给所有包含is字符串的行增加一对()
★ 利用sed修改PATH环境变量
先查看PATH环境变量
[scz@ /home/scz/src]> echo $PATH
/usr/bin:/usr/bin:/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/X11R6/bin:.
去掉尾部的{ :/usr/X11R6/bin:. }
[scz@ /home/scz/src]> echo $PATH | sed "s/^\(.*\):\/usr[/]X11R6\/bin:[.]$/\1/"
/usr/bin:/usr/bin:/bin:/usr/local/bin:/sbin:/usr/sbin
去掉中间的{ :/bin: }
[scz@ /home/scz/src]> echo $PATH | sed "s/^\(.*\):\/bin:\(.*\)$/\1\2/"
/usr/bin:/usr/bin/usr/local/bin:/sbin:/usr/sbin:/usr/X11R6/bin:.
[/]表示/失去特殊意义
\/同样表示/失去意义
\1表示子匹配的第一次出现
\2表示子匹配的第二次出现
\(.*\)表示子匹配
去掉尾部的:，然后增加新的路径
PATH=`echo $PATH | sed 's/\(.*\):$/\1/'`:$HOME/src
注意反引号`和单引号'的区别。
★ 测试并提高sed命令运行效率
time sed -n "1,12p" webkeeper.db > /dev/null
time sed 12q webkeeper.db > /dev/null可以看出后者比前者效率高。
[address]q 当碰上指定行时退出sed执行
★ 指定输出文件 [address1][,address2]w outputfile
sed "1,10w sed.out" sedtest.txt -n
将sedtest.txt中1-10行的内容写到sed.out文件中。
★ 指定输入文件 [address]r inputfile
sed "1r sedappend.txt" sedtest.txt
将sedappend.txt中的内容附加到sedtest.txt文件的第一行之后
★ 替换相应字符 [address1][,address2]y/old/new/
sed "y/abcdef/ABCDEF/" sedtest.txt
将sedtest.txt中所有的abcdef小写字母替换成ABCDEF大写字母。
★ !号的使用
sed -e '3,7!d' sedtest.txt
删除3-7行之外的所有行
sed -e '1,/from/!d' sedtest.txt
找到包含from字符串的行，删除其后的所有行
★ \c正则表达式c 的使用
sed -e "\:from:d" sedtest.txt
等价于 sed -e "/from/d" sedtest.txt
★ sed命令中正则表达式的复杂性
cat > sedtest.txt
^\/[}]{.*}[\(]$\)
^D
如何才能把该行替换成
\(]$\)\/[}]{.*}^[
★ 转换man手册成普通文本格式(新)
man sed | col -b > sed.txt
sed -e "s/^H//g" -e "/^$/d" -e "s/^^I/ /g" -e "s/^I/ /g" sed.txt > sedman
txt
删除所有退格键、空行，把行首的制表符替换成8个空格，其余制表符替换成一个空格。
★ sed的man手册(用的就是上面的方法)
NAME
sed - a Stream EDitor
SYNOPSIS
sed [-n] [-V] [--quiet] [--silent] [--version] [--help]
[-e script] [--expression=script]
[-f script-file] [--file=script-file]
[script-if-no-other-script]
[file...]
DESCRIPTION
Sed is a stream editor. A stream editor is used to per-
form basic text transformations on an input stream (a file
or input from a pipeline). While in some ways similar to
an editor which permits scripted edits (such as ed), sed
works by making only one pass over the input(s), and is
consequently more efficient. But it is sed's ability to
filter text in a pipeline which particularly distinguishes
it from other types of editors.
OPTIONS
Sed may be invoked with the following command-line
options:
-V
--version
Print out the version of sed that is being run and
a copyright notice, then exit.
-h
--help Print a usage message briefly summarizing these
command-line options and the bug-reporting address,
then exit.
-n
--quiet
--silent
By default, sed will print out the pattern space at
the end of each cycle through the script. These
options disable this automatic printing, and sed
will only produce output when explicitly told to
via the p command.
-e script
--expression=script
Add the commands in script to the set of commands
to be run while processing the input.
-f script-file
--file=script-file
Add the commands contained in the file script-file
to the set of commands to be run while processingthe input.
If no -e,-f,--expression, or --file options are given on
the command-line, then the first non-option argument on
the command line is taken to be the script to be executed.
If any command-line parameters remain after processing the
above, these parameters are interpreted as the names of
input files to be processed. A file name of - refers to
the standard input stream. The standard input will pro-
cessed if no file names are specified.
Command Synopsis
This is just a brief synopsis of sed commands to serve as
a reminder to those who already know sed; other documenta-
tion (such as the texinfo document) must be consulted for
fuller descriptions.
Zero-address ``commands''
: label
Label for b and t commands.
#comment
The comment extends until the next newline (or the
end of a -e script fragment).
} The closing bracket of a { } block.
Zero- or One- address commands
= Print the current line number.
a \
text Append text, which has each embedded newline pre-
ceeded by a backslash.
i \
text Insert text, which has each embedded newline pre-
ceeded by a backslash.
q Immediately quit the sed script without processing
any more input, except that if auto-print is not
diabled the current pattern space will be printed.
r filename
Append text read from filename.
Commands which accept address ranges
{ Begin a block of commands (end with a }).
b label
Branch to label; if label is omitted, branch to end
of script.
t label
If a s/// has done a successful substitution since
the last input line was read and since the last t
command, then branch to label; if label is omitted,
branch to end of script.
c \
text Replace the selected lines with text, which has
each embedded newline preceeded by a backslash.
d Delete pattern space. Start next cycle.
D Delete up to the first embedded newline in the pat-
tern space. Start next cycle, but skip reading
from the input if there is still data in the pat-
tern space.
h H Copy/append pattern space to hold space.
g G Copy/append hold space to pattern space.
x Exchange the contents of the hold and pattern
spaces.
l List out the current line in a ``visually unambigu-
ous'' form.
n N Read/append the next line of input into the pattern
space.
p Print the current pattern space.
P Print up to the first embedded newline of the cur-
rent pattern space.
s/regexp/replacement/
Attempt to match regexp against the pattern space.
If successful, replace that portion matched with
replacement. The replacement may contain the spe-
cial character & to refer to that portion of the
pattern space which matched, and the special
escapes \1 through \9 to refer to the corresponding
matching sub-expressions in the regexp.
w filename Write the current pattern space to file-
name.
y/source/dest/
Transliterate the characters in the pattern space
which appear in source to the corresponding charac-
ter in dest.
Addresses
Sed commands can be given with no addresses, in which case
the command will be executed for all input lines; with one
address, in which case the command will only be executed
for input lines which match that address; or with two
addresses, in which case the command will be executed for
all input lines which match the inclusive range of lines
starting from the first address and continuing to the sec-
ond address. Three things to note about address ranges:
the syntax is addr1,addr2 (i.e., the addresses are sepa-
rated by a comma); the line which addr1 matched will
always be accepted, even if addr2 selects an earlier line;
and if addr2 is a regexp, it will not be tested against
the line that addr1 matched.
After the address (or address-range), and before the com-
mand, a ! may be inserted, which specifies that the com-
mand shall only be executed if the address (or address-
range) does not match.
The following address types are supported:
number Match only the specified line number.
first~step
Match every step'th line starting with line first.
For example, ``sed -n 1~2p'' will print all the
odd-numbered lines in the input stream, and the
address 2~5 will match every fifth line, starting
with the second. (This is a GNU extension.)
$ Match the last line.
/regexp/
Match lines matching the regular expression regexp.
\cregexpc
Match lines matching the regular expression regexp.
The c may be any character.
Regular expressions
POSIX.2 BREs should be supported, but they aren't com-
pletely yet. The \n sequence in a regular expression
matches the newline character. There are also some GNU
extensions. [XXX FIXME: more needs to be said. At the
very least, a reference to another document which
describes what is supported should be given.]
Miscellaneous notes
This version of sed supports a \ sequence in all
regular expressions, the replacement part of a substitute
(s) command, and in the source and dest parts of a
transliterate (y) command. The \ is stripped, and the
newline is kept.
SEE ALSO
awk(1), ed(1), expr(1), emacs(1), perl(1), tr(1), vi(1),
regex(5) [well, one ought to be written... XXX], sed.info,
any of various books on sed, the sed FAQ
(http://www.wollery.demon.co.uk/sedtut10.txt,
http://www.ptug.org/sed/sedfaq.htm).
BUGS
E-mail bug reports to [email protected]. Be sure to
include the word ``sed'' somewhere in the ``Subject:''
field.
Sed学习笔记
作者：Jims of
肥肥世家
Table of Contents
1. Sed简介
2. 定址
3. Sed命令
4. 选项
5. 元字符集
6. 实例
7. 脚本
1. Sed简介
sed是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。
2. 定址
可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定 。
3. Sed命令
调用sed命令有两种形式：
sed [options] 'command' file(s)
sed [options] -f scriptfile file(s)
a\
在当前行后面加入一行文本。
b lable
分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
c\
用新的文本改变本行的文本。
d
从模板块（Pattern space）位置删除行。
D
删除模板块的第一行。
i\
在当前行上面插入文本。
h
拷贝模板块的内容到内存中的缓冲区。
H
追加模板块的内容到内存中的缓冲区
g
获得内存缓冲区的内容，并替代当前模板块中的文本。
G
获得内存缓冲区的内容，并追加到当前模板块文本的后面。
l
列表不能打印字符的清单。
n
读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
N
追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
p
打印模板块的行。
P（大写）
打印模板块的第一行。
q
退出Sed。
r file
从file中读行。
t label
if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
T label
错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
w file
写并追加模板块到file末尾。
W file
写并追加模板块的第一行到file末尾。
!
表示后面的命令对所有没有被选定的行发生作用。
s/re/string
用string替换正则表达式re。
=
打印当前行号码。
#
把注释扩展到下一个换行符以前。
以下的是替换标记
g表示行内全面替换。
p表示打印行。
w表示把行写入一个文件。
x表示互换模板块中的文本和缓冲区中的文本。
y表示把一个字符翻译为另外的字符（但是不用于正则表达式）
4. 选项
-e command, --expression=command
允许多台编辑。
-h, --help
打印帮助，并显示bug列表的地址。
-n, --quiet, --silent
取消默认输出。
-f, --filer=script-file
引导sed脚本文件名。
-V, --version
打印版本和版权信息。
5. 元字符集
^ 锚定行的开始 如：/^sed/匹配所有以sed开头的行。
$ 锚定行的结束 如：/sed$/匹配所有以sed结尾的行。
. 匹配一个非换行符的字符 如：/s.d/匹配s后接一个任意字符，然后是d。
* 匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[] 匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^] 匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
\(..\) 保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers。
& 保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
\ 锚定单词的开始，如:/\匹配包含以love开头的单词的行。
\> 锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
x\{m\}重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
x\{m,\} 重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
x\{m,n\}重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
6. 实例
删除：d命令
$ sed '2d' example-----删除example文件的第二行。
$ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
$ sed '$d' example-----删除example文件的最后一行。
$ sed '/test/'d example-----删除example文件所有包含test的行。
替换：s命令
$ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
$ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
$ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加 localhost，变成192.168.0.1localhost。
$ sed -n 's/\(love\)able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
$ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
选定行的范围：逗号
$ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
$ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
$ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
多点编辑：e命令
$ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执 行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
$ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
从文件读入：r命令
$ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
写入文件：w命令
$ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。
追加命令：a命令
$ sed '/^test/a\\--->this is a example' example被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
插入：i命令
$ sed '/test/i\\
new line
-------------------------' example
如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
下一个：n命令
$ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
变形：y命令
$ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
退出：q命令
$ sed '10q' example-----打印完第10行后，退出sed。
保持和获取：h命令和G命令
$ sed -e '/test/h' -e '$G example-----在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保 持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中 的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
保持和互换：h命令和x命令
$ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
7. 脚本
Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
Sed简介
sed [-nefr] 动作：该指令可以将输入的数据进行处理后输出到标准输出，利用sed处理后的结果不会影响到原输入流，比如sed '1,5d' filePath将会把文件filePath的第1到5行删除后再进行标准输出，但是这不会影响到文件filePath，处理可以是取代、删除、插入等。
参数：
-n：表示使用安静模式，sed默认会将处理后的所有行都打印出来，加上参数-n后就只有经过处理的行才会显示出来。
例如：
sed -n '1,5p' filePath，该指令将会只打印出filePath这个输入的1到5行，而没有加-n的话会先在输出filePath的1到5行之后再把整个filePath内容都输出。
-e：后面接动作，当后面只有一个动作的时候可以把-e省略。
例如：
1.sed -e '1,5d' filePath，该指令表示将filePath的第1到5行删除后再进行输出，因为sed后只进行了一个动作，所以-e参数也可以省略变成sed '1,5d' filePath
2.sed -e '1,5d' -e '8ihello' filePath，该指令表示将filePath的第1到5行删除，然后在第8行插入hello，之后再进行标准输出，因为这里是同时进行两个动作，所以参数-e是不能省略的
扩展：
1.同时执行多个动作的时候也可以使用分号“;”来进行分隔，这样上面的命令可以利用分号变成sed '1,5d;8ihello' filePath
2.当要在同一行上执行多个动作的时候还可以用大括号“{}”包起来，如sed -n '1,5{=;p}' filePath表示文件filePath的第1到5行需要执行两个动作，第一个动作“=”是打印出当前行的行号，第二个动作“p”是打印出当前行。
-f：后面接一个文件的完整路径，这种情况是我们把需要执行的动作写在一个文件里面，然后利用sed -f filePath来执行
例如：
将sed '1,5d' filePath改成使用-f的方式，先建立一个文件，假设为cmdFile，把命令放入该文件中，则cmdFile的内容为1,5d，这里面的命令是不需要用单引号包起来的，然后以后调用的时候就可以这样调用：sed -f cmdFile filePath，出来的效果和sed '1,5d' filePath是一样的。
-r：使用该参数表示该sed使用的正则表达式支持延伸型正则表达式，预设是基础正则表达式语法
动作：[n1[,n2]function]
n1、n2表示多少行到多少行（sed提供两种方式定位行，一种是数字，一种是正则表达式），当只有一个行的时候表示的就是代表的那一行，n1、n2也可以使用正则表达式来进行选取，例如/hello/d则表示将包含hello的那一行找出来并删除，还可以使用$表示最后一行，例如sed '5,$d' filePath表示将文件filePath的第5行到最后一行的内容都删除然后进行标准输出
/pattern1/,/pattern2/：表示满足pattern1那行到满足pattern2的那一行
/pattern1/,5：表示满足pattern1那行到第5行
3,5!：表示不包含3到5行的其他的行
function有以下几种：
a：表示新增，后面接的内容将出现在指定行的下面，例如sed '5ahello' filePath将在文件filePath的第5行后面添加一行，即为第6行内容为hello，而sed '3,5ahello' filePath则将在文件filePath的第3到第5行每一行的后面都添加一行内容为hello的行
i：表示插入，后面接的内容将插入到当前行，而当前行的内容将依次往后移，例如：sed '5ihello' filePath表示在文件filePath的第5行插入一行，内容为hello，然后原来的第5行将往下移动变为第6行，依此类推
c：表示取代，是针对行而言的，后面接的内容将取代指定行的内容，例如：sed '3,5chello' filePath表示将文件filePath的第3到5行用hello取代
d：表示删除，例如：sed '3,5d' filePath表示将文件filePath的第3到5行删除后再进行标准输出
p：表示进行打印，例如：sed '3,5p' filePath表示将文件filePath的第3到5行的内容打印出来
r：表示读取文件内容到指定行的下面
w：表示把指定行的内容写入到指定文件
s：表示取代，是针对每一行的内容而定的，例如：sed 's/hello/world/g' filePath，sed '3,5s/hello/world/' filePath， 表示将文件filePath里面的每一行中出现的hello都替换为world，如果最后没有加上参数g表示只会替换每一行的第一个匹配的hello，在匹配的替换值中可以使用“&”来代表当前匹配的值，如：sed '3,5s/hello/00&/g' filePath，由于”&“符号代表当前匹配到的值，所以该语句的意思就是将filePath中3到5行的hello都替换为00hello。
注：除了可以使用参数g之外，还可以使用以下参数：
数字参数，使用数字参数表示匹配到的指定第几个才替换；
参数p，使用参数p表示将替换的行进行打印出来，参数p需要与-n一起使用才能将替换的那一行打印出来，如：sed -n 's/hello/world/p' filePath
参数w，使用参数w表示将替换的行写到指定的文件，如：sed 's/hello/world/w outputFile' filePath
q：表示退出，当执行完指定的行之后就退出，如：sed '5 q' filePath，表示执行到第5行之后就退出，因为sed默认会进行打印操作，所以这句的意思是打印到5行之后就退出。
y：表示字符变换，是针对单个字符进行的，如：sed '1,5y/12345/abcde/' filePath表示将filePath文件1到5行内容中的1替换为a，2替换为b...，5替换为e
l：字母L命令可以用于显示内容中的特殊字符，如退格键等，如：sed 'l' filePath
n：n命令可以处理匹配行的下一行，如：sed '/hello/{n;s/123/321/g}'表示把包含hello字符串那一行的下一行中的123全部替换为321
Awk简介
awk [-F 分隔符] 'awk程序段' 输入文件：awk命令是用来把文件中每一行分成各个域来进行处理，预设的分隔符是空格键或者[tab键]，分割成的域会一次放入$1、$2...$n等变量中，而$0则代表一行。与sed相似，awk也可以使用-f参数表示调用awk脚本文件
awk由模式和动作组成，模式pattern决定了动作何时执行，模式一般就是正则表达式，awk支持“？”和“+”两个扩展元字符，而sed和grep是不支持的
awk 'pattern{动作}' file，动作是需要放到大括号{}里面的，如：awk '/01/{print $0}' test，表示将文件test中包含01的行打印出来
awk中内置的变量有：
FS：表示分隔符，在设置分隔符的时候也可以不使用-F参数，而是在BEGIN中指定FS的值
NR：表示当前执行的是第几行
NF：表示当前行被分隔成几个域
ARGC：表示当前awk命令的参数数量
ARGV：是数组形式，表示当前awk命令的参数，ARGV[0]是awk，ARGV[1]一般是文件名
如：awk '{print $1}' inputFile，则ARGC为2，ARGV[1]为inputFile
OFS：输出的域之间的分隔符，默认是一个空格
ORS：输出的记录之间的分隔符，默认是一个换行符
RS：输入文件按照什么分隔记录，默认是换行符
awk还可以使用awk -v var=val 'awk程序段' 输入文件，这样的形式来进行变量的申明与使用，使用-v申明和赋值的变量是可以在BEGIN语句段里面使用的，而直接接在awk程序段后面申明的变量是不能在BEGIN语句段里面使用的。
awk还可以使用模式匹配来进行行的选择，如：awk -F":" '$2>5' test，表示把文件test中的每一行按照“:”进行分隔，把分隔后第2个变量的值大于5的行选出
awk支持进行行的选择的模式有以下这些：
> 大于
== 等于
< 小于
>= 大于或等于
<= 小于或等于
!= 不等于
~ 匹配正则表达式，如：awk -F":" '$1~/hello/' test，表示把文件test按照":"进行分隔后，把第1个变量中包含hello的行选出
!~ 不匹配正则表达式
上面的这些模式也可以用来跟条件判断IF语句一起使用，如：awk -F"\t" '{if($1>5 && $2~/hello/) print $0}' test表示将test文件中的每一行按照tab键进行分隔，然后选出第一个域大于5并且第2个域包含hello的行
在awk中主要有3个语句段，一个是BEGIN，一个是MAIN，一个是END，BEGIN语句段会在执行awk的主语句段之前执行，END语句段会在执行awk主语句段之后执行
示例，使用BEGIN、MAIN和END来计算文件的总行数：awk 'BEGIN{sum=0}{sum++}END{print "Sum:",sum}' test，由这个示例可以看出，在awk中定义的变量在使用时是不需要加上"$"dollar符号的。
awk中内置的字符串函数：
gsub(a,b) 表示将输入文件中的a替换为b，返回值是替换的个数
gsub(a,b,c) 表示将c中的a替换为b，这里的c一般代表的是一个域，返回值是替换的个数
index(s,t) 返回字符串s中第一个t出现的位置
length(s) 返回字符串s的长度
split(a,b,c) 将字符串a以c为分隔符进行分割，分割后保存在数组b中，函数的返回值是分割后域的数量。
如：echo "Hello,World" | awk '{print split($0,words,",");for(var in words) print words[var]}'
match(s,t) 测试s是否包含匹配t的字符串，若匹配则返回匹配字符t在s中第一次出现的位置，若不匹配则返回0
sub(r,s,t) 将t中第一次出现的r替换为s，返回值是替换的个数
sub(r,s) 将每一行中第一次出现的r替换为s，返回值是替换的个数
substr(r,s) 返回字符串r中从s开始之后的字符串
substr(r,s,t) 返回字符串r中从s开始长度为t的字符串15602232321 525345
注：关于这些函数还可以这样使用：
awk 'sub("A","B"){print $0}' file，表示将file中每一行的第一个A替换为B，如果替换了就将该行进行打印。
向awk脚本传递参数，方法是：
awk 脚本 parameter=value 输入文件，示例：awk '{print num}' num=2 inputFile，该语句将根据inputFile的行数打印多个数字2
向awk脚本传递的参数不能在BEGIN语句段中使用，这是因为BEGIN语句段是一开始就执行的，这时候参数值还没有进行传递。
awk内部的语法跟C语言类似，它里面也支持条件IF语句和循环语句while、do while和for，还有switch case语句，当满足某个条件需要进行多个动作时需要用大括号把多个动作包起来。
if语句的语法：
if (条件判断1)
动作1
else if (条件判断2)
动作2
else
动作3
if中的条件判断也可以使用“~”符号和正则表达式进行判断，如：
if ($0~/hello/)
print $0
上面的语句表示如果该行包含hello字符串就将该行进行打印
while语句的语法：
while(条件判断)
动作
do while语句的语法：
do
动作
while(条件判断)
for语句的语法：
for(初值;判断;变化)
动作
如：awk '{for(i=1;i<=NF;i++) print $i}' inputFile
awk还支持数组，该数组的索引值可以为任意值，awk都会把它以键值对的形式进行储存，可以使用for(var in array)的形式对数组内容进行循环，也可以使用if (key in array)判断array中是否有以key为键值的键值对存在，可以使用delete删除数组中的一个元素或者删除整个数组，如：delete array[key]则会删除array中以key为索引的元素，要删除整个数组的时候，就直接使用delete 数组名，如：delete arrayName。
示例：
awk 'BEGIN{data[1]=1;data[hello]="hello"}{if("1" in data) print "exist element 1."}' inputFile
awk还支持多维数组，如：
awk 'BEGIN{
nums[0][0] = 0
nums[0][1] = 1
nums[0][2] = 2
nums[0][3] = 3
nums[1][0] = 1
nums[1][1] = 2
nums[1][2] = 3
nums[1][3] = 4
for (var1 in nums) {
for (var2 in nums[var1]) {
print nums[var1][var2]
}
}
}{}' fileName
LINUX的awk和sed的常用用法
awk的用法
a w k语言的最基本功能是在文件或字符串中基于指定规则浏览和抽取信息
调用awk
有三种方式调用a w k，
第一种是命令行方式，如：
awk –F : ‘commands’ input-files
第二种方法是将所有a w k命令插入一个文件，并使a w k程序可执行，然后用a w k命令作为脚本的首行，以便通过键入脚本名称来调用它。
第三种方式是将所有的a w k命令插入一个单独文件，然后调用：
awk –f awk-script-file input-files
awk脚本
模式和动作
在命令中调用a w k时，a w k脚本由各种操作和模式组成。模式包括两个特殊字段B E G I N和E N D。
使用B E G I N语句设置计数和打印头。B E G I N语句使用在任何文本浏览动作之前。E N D语句用来在a w k完成文本浏览动作后打印输出文本总数和结尾状态标志。
实际动作在大括号{ }内指明。
域和记录
$ 0，意即所有域
• 确保整个a w k命令用单引号括起来。
• 确保命令内所有引号成对出现。
• 确保用花括号括起动作语句，用圆括号括起条件语句。
awk中的正则表达式
+ 使用+匹配一个或多个字符。
？ 匹配模式出现频率。例如使用/X Y?Z/匹配X Y Z或Y Z。
awk '{if($4~/Brown/) print $0}' tab2
等效于
awk '$0 ~ /Brown/' tab2
内置变量
awk '{print NF,NR,$0}END{print FILENAME}' tab1
NF 域的总数
NR已经读取的记录数
FILENAME
awk '{if(NR>0 && $2~/JLNQ/) print $0}END{print FILENAME}' tab1
显示文件名
echo "/app/oracle/ora_dmp/lisx/tab1" | awk -F/ '{print $NF}'
定义域名
awk '{owner=$2;number=$3;if(owner~/SYSADMIN/ && number!=12101)print $0}END{print FILENAME}' tab1
awk 'BEGIN{NUM1=7}{if($1<=NUM1) print $0}END{print FILENAME}' tab1
当在a w k中修改任何域时，重要的一点是要记住实际输入文件是不可修改的，修改的只是保存在缓存里的a w k复本
awk 'BEGIN{NUM1=7}{if($1<=NUM1) print $1+2,$2,$3+100}END{print FILENAME}' tab1
只打印修改部分：用{}
awk 'BEGIN{NUM1=7}{if($1<=NUM1){$2="ORACLE"; print $0}}END{print "filename:"FILENAME}' tab1
可以创建新的域
awk 'BEGIN{NUM1=7;print "COL1"tCOL2"tCOL3"tCOL4"}{if($1<=NUM1){$4=$1*$3;$2="ORACLE"; print $0}}END{print "filename:"FILENAME}' tab1
打印总数：
awk 'BEGIN{NUM1=7;print "COL1"tCOL2"tCOL3"tCOL4"}{if($1<=NUM1){tot+=$3;$4=$1*$3;$2="ORACLE"; print $0}}END{print "filename:"FILENAME "total col3:" tot}' tab1
使用此模式打印文件名及其长度，然后将各长度相加放入变量t o t中。
ls -l | awk '/^[^d]/ {print$9""t"$5} {tot+=$5}END{print "total KB:" tot}'
内置字符串函数
gsub 字符要用引号，数字不用
awk 'gsub(/12101/,"hello") {print $0} END{print FILENAME}' tab1
awk 'gsub(/12101/,3333) {print $0} END{print FILENAME}' tab1
index
awk '{print index($2,"D")""t";print $0}' tab1
awk '{print index($2,"D")""t" $0}' tab1
length
awk '{print length($2)""t" $0}' tab1
ma
awk '{print match($2,"M")""t" $0}' tab1
split
awk '{print split($2,new_array,"_")""t" $0}' tab1
sub 替换成功返回1,失败返回0
awk '{print sub(/SYS/,"oracle",$2)""t" $0}' tab1
substr
awk '{print substr($2,1,3)""t" $0}' tab1
从s h e l l中向a w k传入字符串
echo "Stand-by" | awk '{print length($0)""t"$0}'
8 Stand-by
file1="tab1"
cat $file1 | awk '{print sub(/ADMIN/,"sss",$2)""t"$0}'
字符串屏蔽序列
" b 退格键 " t t a b键
" f 走纸换页 " d d d 八进制值
" n 新行 " c 任意其他特殊字符，例如" "为反斜线符号
" r 回车键
awk printf修饰符
- 左对齐
Wi d t h 域的步长，用0表示0步长
. p r e c 最大字符串长度，或小数点右边的位数
如果用格式修饰输出，要指明具体的域，程序不会自动去分辨
awk '{printf "%-2d %-10s %d"n", $1,$2,$3}' tab1
输出结果
9 SYSADMIN 12101
9 SYSADMIN 12101
14 SYSADMIN 121010000012002
9 SYSADMIN 12101
2 JLNQ 12101
2 JLNQ 12101
7 SYSADMIN 12101
7 SYSADMIN 12101
6 ac_ds_e_rr_mr 13333
向一行a w k命令传值
awk 'BEGIN{SYS="SYSADMIN"}{if($2==SYS) printf "%-2d %-10s %d"n", $1,$2,$3}' tab1
在动作后面传入
awk '{if($2==SYS) printf "%-2d %-10s %d"n", $1,$2,$3}' SYS="SYSADMIN" tab1
awk脚本文件
SED用法
sed怎样读取数据
s e d从文件的一个文本行或从标准输入的几种格式中读取数据，将之拷贝到一个编辑缓冲区，然后读命令行或脚本的第一条命令，并使用这些命令查找模式或定位行号编辑它。重复此过程直到命令结束。
调用s e d有三种方式
使用s e d命令行格式为：
sed [选项] s e d命令 输入文件。
记住在命令行使用s e d命令时，实际命令要加单引号。s e d也允许加双引号。
使用s e d脚本文件，格式为：
sed [选项] -f sed脚本文件 输入文件
要使用第一行具有s e d命令解释器的s e d脚本文件，其格式为：
s e d脚本文件 [选项] 输入文件
使用s e d在文件中定位文本的方式
x x为一行号，如1
x , y 表示行号范围从x到y，如2，5表示从第2行到第5行
/ p a t t e r n / 查询包含模式的行。例如/ d i s k /或/[a-z]/
/ p a t t e r n / p a t t e r n / 查询包含两个模式的行。例如/ d i s k / d i s k s /
p a t t e r n / , x 在给定行号上查询包含模式的行。如/ r i b b o n / , 3
x , / p a t t e r n / 通过行号和模式查询匹配行。3 , / v d u /
x , y ! 查询不包含指定行号x和y的行。1 , 2 !
sed编辑命令
p 打印匹配行
= 显示文件行号
a" 在定位行号后附加新文本信息
i" 在定位行号后插入新文本信息
d 删除定位行
c" 用新文本替换定位文本
s 使用替换模式替换相应模式
r 从另一个文件中读文本
w 写文本到一个文件
q 第一个模式匹配完成后推出或立即推出
l 显示与八进制A S C I I代码等价的控制字符
{ } 在定位行执行的命令组
n 从另一个文件中读文本下一行，并附加在下一行
g 将模式2粘贴到/pattern n/
y 传送字符
n 延续到下一输入行；允许跨行的模式匹配语句
sed编程举例
打印单行 sed -n '2p' quo*
打印范围 sed -n '1,3p' quote.txt
打印有此模式的行 sed -n '/disco/'p quote.txt
使用模式和行号进行查询 sed -n '4,/The/'p quote.txt
sed -n '1,/The/'p quote.txt 会打印所有记录？
用.*代表任意字符 sed -n '/.*ing/'p quote.txt
打印行号 sed -e '/music/'= quote.txt 或sed -e '/music/=' quote.txt
如果只打印行号及匹配行，必须使用两个s e d命令，并使用e选项。
第一个命令打印模式
匹配行，第二个使用=选项打印行号，格式为sed -n -e /pattern/p -e /pattern/=。
sed -n -e '/music/p' -e '/music/'= quote.txt
先打印行号，再打印匹配行
sed -n -e '/music/=' -e '/music/'p quote.txt
替换
sed 's/The/Wow!/' quote.txt
保存到文件
sed '1,2 w filedt' quote.txt
读取文件，在第一行后面读取
sed '1 r sedex.txt' quote.txt
替换字符系列
如果变量x含有下列字符串：
x="Department+payroll%Building G"
要实现以下转换：
+ to 'of'
% to located
语句： echo $x | sed 's/"+/ of /g' | sed 's/"%/ located /g'
sed命令可以替换给定文本中的字符串。它可以利用正则表达式进行匹配。
$ sed ‘s/pattern/replace_string/’ file
Sed命令也可以从stdin中读取输入，如：
$ cat file | sed ‘s/pattern/replace_string/’
使用-i选项，sed可以将替换结果应用于原文件，如：
$ sed –i ‘s/text/replace/’ file
以上sed命令会将每一行中第一处符合样式的内容替换掉，如果要替换每一行中的所有内容，可在命令尾部加上参数g，如：
$ sed ‘s/pattern/replace_string/g’ file
选项/Ng可以忽略前N-1处匹配，并从第N处开始替换，如：
$echo thisthisthisthis | sed ‘s/this/THIS/3g’
thisthisTHISTHIS
字符/在sed命令中作为定界符使用，其实任意字符都可以当作定界符，如：
$ sed ‘s:text:replace:g’
$ sed ‘s|text|replace|g’
当定界符出现在样式内部时，我们必须使用前缀\对它进行转义。
/pattern/d会移除匹配样式的行，我们可以利用这个移除文件空白行：
$ sed ‘/^$/d’ file
在sed中，用&标记匹配样式的字符串，例如：
$ echo this is an example | sed ‘s/\w\+/[&]/g’
[this] [is] [an] [example]
正则表达式\w\+匹配每一个单词，&对应于之前所匹配到的单词。
Sed命令也可以匹配给定样式中的子串。\(pattern\)用于匹配子串。模式被包括在使用斜线转义过的()中。对于匹配到的第一个子串，其对应的标记是\1，匹配到的第二个子串是\2，往后依次类推。例：
$ echo this is digit 7 in a number | sed ‘s/digit \([0-9]\)/\1/’
This is 7 in a number
这条命令将digit 7替换为7。样式中匹配到的子串是7。下面是包含多个匹配的例子：
$ echo seven EIGHT | sed ‘s/\([a-z]\+\) \([A-Z]\+\)/\2 \1/’
EIGHT seven
([a-z]\+\)匹配第一个单词，([A-Z]\+\)匹配第二个单词，\1和\2用来引用它们。
Sed命令还可以组合多个表达式，如利用管道组合多个sed命令的方法可以用以下方式代替：
$ sed ‘expression1’ | sed ‘expression2’
这等价于
$ sed ‘expression1; expression2’
Sed表达式通常用单引号来引用。不过也可以使用双引号。双引号会通过对表达式求值来对其进行扩展，例如：
$ text=hello
$ echo hello world | sed “s/$text/HELLO/”
HELLO world
Sed应用（我工作中碰到的问题）：
应用1：有这样一个文件，每行的格式为：
type1=value1 type2=value2 type3=value3…
其中type类型个数未知，每种type之间以’\t’隔开，要求提取出=右边的value，输出格式为：
value1 value2 value3…
value之间以’\t’隔开。
解决方案：用sed语句将=左边的字符替换成空串。
$sed –r ‘s/[^\t]*://g’ file
其中-r选项表示使用扩展的正则表达式
应用2：有这样一个文件，每行的格式为：
{type}:value t3 t4…
其中value与t之间以’\t’隔开，要求将type和value提取出来，输出格式为：
type value t3 t4…
各数据之间以’\t’隔开。
解决方案：用sed语句将{type}:替换为type\t，使用子串替换的方法。
$ sed ‘s/{\(\w\+\)}:/\1\t/g’ file
linux中sed的用法
sed命令行格式为：
sed [-nefri] ‘command’ 输入文本/文件
常用选项：
-n∶取消默认的输出,使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN的资料一般都会被列出到屏幕上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来
-e∶进行多项编辑，即对输入行应用多条sed命令时使用. 直接在指令列模式上进行 sed 的动作编辑
-f∶指定sed脚本的文件名. 直接将 sed 的动作写在一个档案内， -f filename 则可以执行 filename 内的sed 动作
-r∶sed 的动作支援的是延伸型正则表达式的语法。(预设是基础正则表达式语法)
-i∶直接修改读取的文件内容，而不是由屏幕输出
常用命令：
a ∶ 新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)
c ∶ 取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行
d ∶ 删除，因为是删除，所以 d 后面通常不接任何内容
i ∶ 插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)
p∶ 列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起用
s∶ 取代，可以直接进行替换的工作。通常这个 s 的动作可以搭配正则表达式。例如 1,20s/old/new/g
定址
|
只显示指定行范围的文件内容，例如：
sed -n '100,200p' mysql_slow_query.log
地址是逗号分隔的，那么需要处理的地址是这两行之间的范围（包括这两行在内）。范围可以用数字、正则表达式、或二者的组合表示。例如：
|
举例：（假设我们有一文件名为ab）
删除某行
[root@localhost ruby] # sed '1d' ab #删除第一行
[root@localhost ruby] # sed '$d' ab #删除最后一行
[root@localhost ruby] # sed '1,2d' ab #删除第一行到第二行
[root@localhost ruby] # sed '2,$d' ab #删除第二行到最后一行
显示某行
. [root@localhost ruby] # sed -n '1p' ab #显示第一行
[root@localhost ruby] # sed -n '$p' ab #显示最后一行
[root@localhost ruby] # sed -n '1,2p' ab #显示第一行到第二行
[root@localhost ruby] # sed -n '2,$p' ab #显示第二行到最后一行
使用模式进行查询
[root@localhost ruby] # sed -n '/ruby/p' ab #查询包括关键字ruby所在所有行
[root@localhost ruby] # sed -n '/\$/p' ab #查询包括关键字$所在所有行，使用反斜线\屏蔽特殊含义
增加一行或多行字符串
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1a drink tea' ab #第一行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,3a drink tea' ab #第一行到第三行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
drink tea
end
drink tea
[root@localhost ruby] # sed '1a drink tea\nor coffee' ab #第一行后增加多行，使用换行符\n
Hello!
drink tea
or coffee
ruby is me,welcome to my blog.
end
代替一行或多行
[root@localhost ruby] # sed '1c Hi' ab #第一行代替为Hi
Hi
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,2c Hi' ab #第一行到第二行代替为Hi
Hi
end
替换一行中的某部分
格式：sed 's/要替换的字符串/新的字符串/g' （要替换的字符串可以用正则表达式）
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby/bird/g' #替换ruby为bird
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby//g' #删除ruby
插入
[root@localhost ruby] # sed -i '$a bye' ab #在文件ab中最后一行直接输入"bye"
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
bye
替换：
-e是编辑命令，用于sed执行多个编辑任务的情况下。在下一行开始编辑前，所有的编辑动作将应用到模式缓冲区中的行上。
sed -e '1,10d' -e 's/My/Your/g' datafile
#选项-e用于进行多重编辑。第一重编辑删除第1-3行。第二重编辑将出现的所有My替换为Your。因为是逐行进行这两项编辑（即这两个命令都在模式空间的当前行上执行），所以编辑命令的顺序会影响结果。
# 替换两个或多个空格为一个空格
sed 's/[ ][ ]*/ /g' file_name
# 替换两个或多个空格为分隔符:
sed 's/[ ][ ]*/:/g' file_name
# 如果空格与tab共存时用下面的命令进行替换
# 替换成空格
sed 's/[[:space:]][[:space:]]*/ /g' filename
# 替换成分隔符:
sed 's/[[:space:]][[:space:]]*/:/g' filename
==============
sed命令的调用:
在命令行键入命令;将sed命令插入脚本文件,然后调用sed;将sed命令插入脚本文件,并使sed脚本可执行
sed [option] sed命令 输入文件 在命令行使用sed命令,实际命令要加单引号
sed [option] -f sed脚本文件 输入文件 使用sed脚本文件
sed脚本文件 [option] 输入文件 第一行具有sed命令解释器的sed脚本文件
option如下:
n 不打印; sed不写编辑行到标准输出,缺省为打印所有行(编辑和未编辑),p命令可以用来打印编辑行
c 下一命令是编辑命令,使用多项编辑时加入此选项
f 如果正在调用sed脚本文件,使用此选项,此选项通知sed一个脚本文件支持所用的sed命令,如
sed -f myscript.sed input_file 这里myscript.sed即为支持sed命令的文件
使用重定向文件即可保存sed的输出
使用sed在文本中定位文本的方式:
x x为一行号,比如1
x,y 表示行号范围从x到y,如2,5表示从第2行到第5行
/pattern/ 查询包含模式的行,如/disk/或/[a-z]/
/pattern/pattern/ 查询包含两个模式的行,如/disk/disks/
/pattern/,x 在给定行号上查询包含模式的行,如/disk/,3
x,/pattern/ 通过行号和模式查询匹配行,如 3,/disk/
x,y! 查询不包含指定行号x和y的行
基本sed编辑命令:
p 打印匹配行 c/ 用新文本替换定位文本
= 显示文件行号 s 使用替换模式替换相应模式
a/ 在定位行号后附加新文本信息 r 从另一个文本中读文本
i/ 在定位行号后插入新文本信息 w 写文本到一个文件
d 删除定位行 q 第一个模式匹配完成后退出或立即退出
l 显示与八进制ASCII代码等价的控制字符 y 传送字符
n 从另一个文本中读文本下一行,并附加在下一行 {} 在定位行执行的命令组
g 将模式2粘贴到/pattern n/
基本sed编程举例:
使用p(rint)显示行: sed -n '2p' temp.txt 只显示第2行,使用选项n
打印范围: sed -n '1,3p' temp.txt 打印第1行到第3行
打印模式: sed -n '/movie/'p temp.txt 打印含movie的行
使用模式和行号查询: sed -n '3,/movie/'p temp.txt 只在第3行查找movie并打印
显示整个文件: sed -n '1,$'p temp.txt $为最后一行
任意字符: sed -n '/.*ing/'p temp.txt 注意是.*ing,而不是*ing
打印行号: sed -e '/music/=' temp.txt
附加文本:(创建sed脚本文件)chmod u+x script.sed,运行时./script.sed temp.txt
#!/bin/sed -f
/name1/ a/ #a/表示此处换行添加文本
HERE ADD NEW LINE. #添加的文本内容
插入文本: /name1/ a/ 改成 4 i/ 4表示行号,i插入
修改文本: /name1/ a/ 改成 /name1/ c/ 将修改整行,c修改
删除文本: sed '1d' temp.txt 或者 sed '1,4d' temp.txt
替换文本: sed 's/source/OKSTR/' temp.txt 将source替换成OKSTR
sed 's//$//g' temp.txt 将文本中所有的$符号全部删除
sed 's/source/OKSTR/w temp2.txt' temp.txt 将替换后的记录写入文件temp2.txt
替换修改字符串: sed 's/source/"ADD BEFORE" &/p' temp.txt
结果将在source字符串前面加上"ADD BEFORE",这里的&表示找到的source字符并保存
sed结果写入到文件: sed '1,2 w temp2.txt' temp.txt
sed '/name/ w temp2.txt' temp.txt
从文件中读文本: sed '/name/r temp2.txt' temp.txt
在每列最后加文本: sed 's/[0-9]*/& Pass/g' temp.txt
从shell向sed传值: echo $NAME | sed "s/go/$REP/g" 注意需要使用双引号
快速一行命令:
's//.$//g' 删除以句点结尾行
'-e /abcd/d' 删除包含abcd的行
's/[][][]*/[]/g' 删除一个以上空格,用一个空格代替
's/^[][]*//g' 删除行首空格
's//.[][]*/[]/g' 删除句号后跟两个或更多的空格,用一个空格代替
'/^$/d' 删除空行
's/^.//g' 删除第一个字符,区别 's//.//g'删除所有的句点
's/COL/(.../)//g' 删除紧跟COL的后三个字母
's/^////g' 删除路径中第一个/
///////////////////////////////////////////////////////////////////////
、使用句点匹配单字符 句点“.”可以匹配任意单字符。“.”可以匹配字符串头，也可以是中间任意字符。假定正在过滤一个文本文件，对于一个有1 0个字符的脚本集，要求前4个字符之后为X C，匹配操作如下：. . . .X C. . . .
2、在行首以^匹配字符串或字符序列 ^只允许在一行的开始匹配字符或单词。在行首第4个字符为1，匹配操作表示为：^ . . . 1
3、在行尾以$匹配字符串或字符 可以说$与^正相反，它在行尾匹配字符串或字符， $符号放在匹配单词后。如果在行尾匹配单词j e t 0 1，操作如下：j e t 0 1 $ 如果只返回包含一个字符的行，操作如下：^ . $
4、使用*匹配字符串中的单字符或其重复序列 使用此特殊字符匹配任意字符或字符串的重复多次表达式。
5、使用/屏蔽一个特殊字符的含义 有时需要查找一些字符或字符串，而它们包含了系统指定为特殊字符的一个字符。如果要在正则表达式中匹配以* . p a s结尾的所有文件，可做如下操作：/ * / . p a s
6、使用[]匹配一个范围或集合 使用[ ]匹配特定字符串或字符串集，可以用逗号将括弧内要匹配的不同字符串分开，但并不强制要求这样做（一些系统提倡在复杂的表达式中使用逗号），这样做可以增 加模式的可读性。使用“ -”表示一个字符串范围，表明字符串范围从“ -”左边字符开始，到“ -”右边字符结束。假定要匹配任意一个数字，可以使用：[ 0 1 2 3 4 5 6 7 8 9 ] 要匹配任意字母，则使用：[ A - Z a - z ]表明从A - Z、a - z的字母范围。
7、使用/{/}匹配模式结果出现的次数 使用*可匹配所有匹配结果任意次，但如果只要指定次数，就应使用/ { / }，此模式有三种形式，即：
pattern/{n/} 匹配模式出现n次。
pattern/{n,/} 匹配模式出现最少n次。
pattern/{n,m} 匹配模式出现n到m次之间，n , m为0 - 2 5 5中任意整数。
匹配字母A出现两次，并以B结尾，操作如下：A / { 2 / } B匹配值为A A B 匹配A至少4次，使用：A / { 4 , / } B
===============
替换单引号为空：
可以这样写：
sed 's/'"'"'//g'
sed 's/'\''//g'
sed s/\'//g
sed命令详解
|
只显示指定行范围的文件内容，例如：
sed -n '100,200p' mysql_slow_query.log
地址是逗号分隔的，那么需要处理的地址是这两行之间的范围（包括这两行在内）。范围可以用数字、正则表达式、或二者的组合表示。例如：
|
3.命令与选项
sed命令告诉sed如何处理由地址指定的各输入行，如果没有指定地址则处理所有的输入行。
3.1 sed命令
| 命令 | 功能 |
| a\ | 在当前行后添加一行或多行。多行时除最后一行外，每行末尾需用“\”续行 |
| c\ | 用此符号后的新文本替换当前行中的文本。多行时除最后一行外，每行末尾需用"\"续行 |
| i\ | 在当前行之前插入文本。多行时除最后一行外，每行末尾需用"\"续行 |
| d | 删除行 |
| h | 把模式空间里的内容复制到暂存缓冲区 |
| H | 把模式空间里的内容追加到暂存缓冲区 |
| g | 把暂存缓冲区里的内容复制到模式空间，覆盖原有的内容 |
| G | 把暂存缓冲区的内容追加到模式空间里，追加在原有内容的后面 |
| l | 列出非打印字符 |
| p | 打印行 |
| n | 读入下一输入行，并从下一条命令而不是第一条命令开始对其的处理 |
| q | 结束或退出sed |
| r | 从文件中读取输入行 |
| ! | 对所选行以外的所有行应用命令 |
| s | 用一个字符串替换另一个 |
| g | 在行内进行全局替换 |
| w | 将所选的行写入文件 |
| x | 交换暂存缓冲区与模式空间的内容 |
| y | 将字符替换为另一字符（不能对正则表达式使用y命令） |
3.2 sed选项
| 选项 | 功能 |
| -e | 进行多项编辑，即对输入行应用多条sed命令时使用 |
| -n | 取消默认的输出 |
| -f | 指定sed脚本的文件名 |
| 元字符 | 功能 | 示例 |
| ^ | 行首定位符 | /^my/ 匹配所有以my开头的行 |
| $ | 行尾定位符 | /my$/ 匹配所有以my结尾的行 |
| . | 匹配除换行符以外的单个字符 | /m..y/ 匹配包含字母m，后跟两个任意字符，再跟字母y的行 |
| * | 匹配零个或多个前导字符 | /my*/ 匹配包含字母m,后跟零个或多个y字母的行 |
| [] | 匹配指定字符组内的任一字符 | /[Mm]y/ 匹配包含My或my的行 |
| [^] | 匹配不在指定字符组内的任一字符 | /[^Mm]y/ 匹配包含y，但y之前的那个字符不是M或m的行 |
| \(..\) | 保存已匹配的字符 | 1,20s/\(you\)self/\1r/ 标记元字符之间的模式，并将其保存为标签1，之后可以使用\1来引用它。最多可以定义9个标签，从左边开始编号，最左边的是第一个。此例中，对第1到第 20行进行处理，you被保存为标签1，如果发现youself，则替换为your。 |
| & | 保存查找串以便在替换串中引用 | s/my/**&**/ 符号&代表查找串。my将被替换为**my** |
| \< | 词首定位符 | /\<my/ 匹配包含以my开头的单词的行 |
| \> | 词尾定位符 | /my\>/ 匹配包含以my结尾的单词的行 |
| x\{m\} | 连续m个x | /9\{5\}/ 匹配包含连续5个9的行 |
| x\{m,\} | 至少m个x | /9\{5,\}/ 匹配包含至少连续5个9的行 |
| x\{m,n\} | 至少m个，但不超过n个x | /9\{5,7\}/ 匹配包含连续5到7个9的行 |
|
6.2 d命令
命令d用于删除输入行。sed先将输入行从文件复制到模式空间里，然后对该行执行sed命令，最后将模式空间里的内容显示在屏幕上。如果发出的是命令d，当前模式空间里的输入行会被删除，不被显示。
|
6.3 s命令
|
|
6.4 e选项
-e是编辑命令，用于sed执行多个编辑任务的情况下。在下一行开始编辑前，所有的编辑动作将应用到模式缓冲区中的行上。
|
6.5 r命令
r命令是读命令。sed使用该命令将一个文本文件中的内容加到当前文件的特定位置上。
|
|
6.7 a\ 命令
a\ 命令是追加命令，追加将添加新文本到文件中当前行（即读入模式缓冲区中的行）的后面。所追加的文本行位于sed命令的下方另起一行。如果要追加的内容超过一行，则每一行都必须以反斜线结束，最后一行除外。最后一行将以引号和文件名结束。
|
6.8 i\ 命令
i\ 命令是在当前行的前面插入新的文本。
6.9 c\ 命令
sed使用该命令将已有文本修改成新的文本。
6.10 n命令
sed使用该命令获取输入文件的下一行，并将其读入到模式缓冲区中，任何sed命令都将应用到匹配行紧接着的下一行上。
|
|
6.12 q命令
q命令将导致sed程序退出，不再进行其它的处理。
|
6.13 h命令和g命令
|
7. sed脚本
sed脚本就是写在文件中的一列sed命令。脚本中，要求命令的末尾不能有任何多余的空格或文本。如果在一行中有多个命令，要用分号分隔。执行脚本 时，sed先将输入文件中第一行复制到模式缓冲区，然后对其执行脚本中所有的命令。每一行处理完毕后，sed再复制文件中下一行到模式缓冲区，对其执行脚 本中所有命令。使用sed脚本时，不再用引号来确保sed命令不被shell解释。例如sed脚本script：
|
|
sed是一个很好的文件处理工具，本身是一个管道命令，主要是以行为单位进行处理，可以将数据行进行替换、删除、新增、选取等特定工作，下面先了解一下sed的用法
sed命令行格式为：
sed [-nefri] ‘command’ 输入文本
常用选项：
-n∶使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN的资料一般都会被列出到萤幕上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。
-e∶直接在指令列模式上进行 sed 的动作编辑；
-f∶直接将 sed 的动作写在一个档案内， -f filename 则可以执行 filename 内的sed 动作；
-r∶sed 的动作支援的是延伸型正规表示法的语法。(预设是基础正规表示法语法)
-i∶直接修改读取的档案内容，而不是由萤幕输出。
常用命令：
a ∶新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～
c ∶取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！
d ∶删除，因为是删除啊，所以 d 后面通常不接任何咚咚；
i ∶插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)；
p ∶列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起运作～
s ∶取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g 就是啦！
举例：（假设我们有一文件名为ab）
删除某行
[root@localhost ruby] # sed '1d' ab #删除第一行
[root@localhost ruby] # sed '$d' ab #删除最后一行
[root@localhost ruby] # sed '1,2d' ab #删除第一行到第二行
[root@localhost ruby] # sed '2,$d' ab #删除第二行到最后一行
显示某行
. [root@localhost ruby] # sed -n '1p' ab #显示第一行
[root@localhost ruby] # sed -n '$p' ab #显示最后一行
[root@localhost ruby] # sed -n '1,2p' ab #显示第一行到第二行
[root@localhost ruby] # sed -n '2,$p' ab #显示第二行到最后一行
使用模式进行查询
[root@localhost ruby] # sed -n '/ruby/p' ab #查询包括关键字ruby所在所有行
[root@localhost ruby] # sed -n '/\$/p' ab #查询包括关键字$所在所有行，使用反斜线\屏蔽特殊含义
增加一行或多行字符串
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1a drink tea' ab #第一行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,3a drink tea' ab #第一行到第三行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
drink tea
end
drink tea
[root@localhost ruby] # sed '1a drink tea\nor coffee' ab #第一行后增加多行，使用换行符\n
Hello!
drink tea
or coffee
ruby is me,welcome to my blog.
end
代替一行或多行
[root@localhost ruby] # sed '1c Hi' ab #第一行代替为Hi
Hi
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,2c Hi' ab #第一行到第二行代替为Hi
Hi
end
替换一行中的某部分
格式：sed 's/要替换的字符串/新的字符串/g' （要替换的字符串可以用正则表达式）
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby/bird/g' #替换ruby为bird
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby//g' #删除ruby
插入
[root@localhost ruby] # sed -i '$a bye' ab #在文件ab中最后一行直接输入"bye"
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
bye
4.1 sed命令基本用法
sed是一个非交互式文本编辑器，它可以对文本文件和标准输入进行编辑，标准输入可以是来自键盘输入、文件重定向、字符串、变量、来自管道的文本等等。
sed从文本的一个文本行或标准输入中读取数据，将其复制到缓存区，然后读取命令行或脚本的第一个命令，对此命令要求的行号进行编辑，重复此过程，直到命令行或脚本中所有命令都执行完了。sed可以一次性处理所有的编辑命令，非常高效
sed适用于下面三种场合：
* 编辑相对于交互式文本编辑器而言太大的场合
* 编辑命令太复杂，在交互式文本编辑器中难以输入的情况
* 对文件扫描一遍，但是需要执行多个编辑函数的情况
sed只是对缓存区中原始文件的副本进行编辑，并不编辑原始文件。因此，如果需要保存更改内容，需要将输出重定向到另一个文件，可以使用下面的命令：
sed 'sed命令' input_file > result_file
或者还有另一种方法就是 -w 选项，这个后面讲到
有三种方式调用sed：
① 直接在shell命令行上调用
# sed [选项] 'sed命令' 输入文件
② 将sed命令插入脚本文件后，通过sed命令调用脚本：
# sed [选项] -f sed脚本文件名 输入文件
③ 将sed命令写入脚本文件后，将其+x变成可执行
./sed脚本文件 输入文件
第三种方式需要在文件头部加上 #!/bin/sed
sed命令的常用选项：
-n 不打印所有行到标准输出
-e 表示将下一个字符串解析为sed编辑命令，如果只传递一个编辑命令，-e可以省略
-f 表示正在调用sed脚本文件
sed命令通常由定位文本行和sed编辑命令两部分组成，sed编辑命令对定位到的行进行各种编辑处理
sed提供两种方式定位文本行：
* 使用行号，指定一行或者行号范围
* 使用正则表达式
sed命令定位文本行的方法：
| 选项 | 意义 |
| x | x为指定行号 |
| x,y | 指定从x到y的行号范围 |
| /pattern/ | 查询包含模式的行 |
| /pattern/pattern/ | 查询包含两个模式的行 |
| /pattern/,x | 从与pattern的匹配行到x号行之间的行 |
| x,/pattern/ | 从x号行到与pattern的匹配行之间的行 |
| x,y! | 查询不包含x和y行号的行 |
===================================分割线=======================
sed编辑命令表
| 选项 | 意义 |
| p | 打印匹配行 |
| = | 打印匹配行号 |
| a\ | 在定位行之后追加文本信息 |
| i\ | 在定位行之前插入文本信息 |
| d | 删除定位行 |
| c\ | 用新文本替换定位行 |
| s | 使用替换模式替换相应的模式 |
| r | 从另一个文件中读文本 |
| w | 将文本写入到另一个文件中 |
| y | 变换字符 |
| q | 第一个模式匹配完成后退出 |
| l | 显示与八进制ASCII码等价的控制字符 |
| {} | 在定位行执行的命令组 |
| n | 读取下一个输入行，用下一个命令处理新的行 |
| h | 将模式缓存区的文本复制到保持缓存区 |
| H | 将模式缓存区的文本追加到保持缓存区 |
| x | 互换模式缓存区和保持缓存区的内容 |
| g | 将保持缓存区的内容复制到模式缓存区 |
| G | 将保持缓存区的内容追加到模式缓存区 |
========================分割线============================
各个选项和编辑命令详解：
1，sed命令的-n选项和p命令
# sed -n '1p' input
# sed '1p' input
从输出可以看出，加了-n后标准输出上只有第一行打印出来了，而不加-n时候，先打印第一行，然后打印整个文件内容。所以-n选项的意义是：不打印sed编辑内容也就是input的全部内容。只打印匹配的行
# sed -n '3,6p' input --> 打印从3到6行
# sed -n '/certificate/p' input --> 打印匹配模式行，注意大小写是敏感的
2，sed命令的-e选项
由于sed不支持同时带多个编辑命令的用法，因此需要用-e选项指定每个编辑命令
# sed -n -e '/Certificate/p' -e '/Certificate/=' input
3，sed命令的-f选项
-f选项只有调用sed脚本文件时才起作用，追加文本、插入文本、修改文本、删除文本和替换文本等功能往往需要几条sed命令才能完成，所以，往往将这些命令写入sed脚本，然后调用sed脚本来完成。
下面是这个sed的脚本：
- #!/bin/sed -f
- /file:/a\
- We append a new line.\
- We append another line.
注：上面的/file:/a\中的\表示在换新行后添加内容，而下面内容中的\也表示换行。
4.2.2 sed文本定位的一组例子
1. 匹配元字符
如果目标字符串中包含元字符，需要使用转义符\屏蔽其特殊意义。
# sed -n '/\./p' input --> 打印含有.的行
2. 使用元字符进行匹配
sed可以灵活使用正则表达式的元字符进行匹配，不过注意的是：$在正则表达式中表示行尾，但是在sed命令中却表示最后一行，而写在//中间的$就表示行尾了，哈哈。
# sed -n '$p' input --> 打印最后一行
# sed -n '/^$/p' input -> 打印空行
3. !符号
!表示取反，也就是不满足条件的时候就处理
# sed -n '/.*this/!p' input --> 打印不包含this的行
# sed -n '3,6!p' input --> 打印不在3至6行间的行
4.2.3 sed基本编辑命令的一组例子
1. 插入文本
插入文本和追加文本类似，区别仅仅是追加文本是在匹配行的后面插入，而插入文本是在匹配行的前面插入
sed插入文本符号位i\，插入文本的格式为：
sed '指定地址 i\text' 输入文件
新建名为insert.sed的脚本，内容如下：
- #!/bin/sed -f
- # this is comment
- # date : 2013/06/02
- # author : xiongneng
- /this is/i\
- We insert a new line #插入的文本内容
2. 修改文本
修改文本是指将所匹配的问本行用新文本代替，也就是只能整行替换，sed修改文本符号位c\
sed '指定行 c\text' 输入文件
3. 删除文本
sed删除文本命令可以将指定行或指定行范围进行删除，sed的删除文本符号为d
sed '指定行 d' 输入文件
4.替换文本
sed替换文本将所匹配的文本行中找到的字符串用新的字符串去代替，常用。而上面的修改文本只能整行，sed替换文本符号为s
sed -n 's/被替换的字符串/新的字符串/p' --> 只替换每行中第一次找到的
sed -n 's/被替换的字符串/新的字符串/gp' --> 替换每行中所有找到的
sed -n 's/被替换的字符串/新的字符串/np' --> 替换每行中第n次找到的
sed替换文本中有个重要的符号&，它表示保存被替换的字符串以供调用。
比如下面两条命令等级：（都是将this字符串用括号括起来）
# sed -n 's/this/(&)/gp' input
# sed -n 's/this/(this)/gp' input
5. 写入到一个新文件
上面提到的都是对缓存区中输入文件的复制内容进行编辑，如果要保存编辑结果，需要将编辑后的文本重定向到另一个文件，sed写入文件符号为w，基本格式为：
# sed -n '1,5 w output' input
# sed -n '/this/2 output' input
# sed -n 's/this/(&)/gw output' input --> 将this加上括号后，匹配行写入到output中去
注：这里写到新文件中的只有匹配的行修改后的数据，如果要整个文件内容都写进去，使用重定向>> 或者>
6. 从文件中读入文本内容
sed命令还可以将其他文件中的内容读入，并附加在指定地址后，sed读入文件的符号为r
# sed '/this/r otherfile' input
7. 退出命令
sed命令的q选项表示完成指定地址匹配后立即退出
# sed -n '/this/p' input --> 打印出匹配的全部字符串
# sed -n -e '/this/p' -e '/this/q' test.txt --> 找到第一个匹配的打印后就立即退出
8. 变换命令
sed命令的y选项表示字符变换，它将一系列的字符变换为相应的字符，逐个处理的
# sed 'y/被变换的字符序列/变换的字符序列/' 输入文件
# sed 'y/12345/ABCDE' input --> 将input中1变成A，2变成B，3变成C，4变成D，5变成E
9. 显示控制字符
sed 1命令可以显示出文件中的控制字符，比如退格键、F1键、Shift键等
# sed -n '1,$1' input
10. 在定位行执行命令组
sed编辑命令中的{}可以指定在定位行上所执行的命令组，它的作用与sed的-e选项类似，都是为了在定位行执行多个编辑命令。
下面的命令等价：
# sed -n -e '/this/p' -e '/this/q' test.txt
# sed -n '/this/{p;q}' test.txt -->显然这个更NB点
4.2.4 sed高级编辑命令的一组例子
1. 处理匹配行的下一行
sed编辑命令n的意义是读取下一个输入行，用n后面的一个命令处理该行，由于此时通常有个多个编辑命令，所以命令n需要与{}配合使用
# sed '/this is/{n;s/her/him/;}' input --> 找到this is关键词那行，然后将它下一行的her替换成him
2. sed缓存区的处理
前面提到的所有编辑命令都是将输入文件复制到缓存区，对缓存区的复制内容进行处理。实际上，sed有两个缓存区，模式缓存区 Pattern Buffer 和保持缓存区 Hold Buffer。前面都是Pattern Buffer，而保持缓存区是另一个内存空间，sed的一些编辑命令可以对保持缓存区进行处理，并与模式缓存区的内容互换
# sed h、x、G命令的用法
# sed '/subject/h; /object/x; $G' input
解释下：
第一个h命令是将模式缓存区内容复制到保持缓存区，也就是说当找到subject的行的时候，就将该行复制到Hold Buffer，如果该行有object关键词就将模式缓存区和保持缓存内容互换后输出模式缓存区内容，第三条命令表示如果是到了最后一行，就直接输出保持 缓存区内容。
h和H、g和G是两组对应的命令
h和H命令是将模式缓存区内容替换掉保持缓存区内容，不过h是副本，即将保持缓存区的就内容覆盖掉，而H是追加，即在保持缓存区内容上增加新的内容
g和G是将保持缓存区内容替换掉模式缓存区内容，同样，g是副本、G是追加。
3.利用分号;分割多个编辑命令，这个比起-e选项更NB一点。^_^
# sed '/subject/h; /object/x; $G' input
1. Sed简介
sed是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。
2. 定址
可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定 。
3. Sed命令
调用sed命令有两种形式：
sed [options] 'command' file(s)
sed [options] -f scriptfile file(s)
在当前行后面加入一行文本。
b lable
分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
c\
用新的文本改变本行的文本。
d
从模板块（Pattern space）位置删除行。
D
删除模板块的第一行。
i\
在当前行上面插入文本。
h
拷贝模板块的内容到内存中的缓冲区。
H
追加模板块的内容到内存中的缓冲区
g
获得内存缓冲区的内容，并替代当前模板块中的文本。
G
获得内存缓冲区的内容，并追加到当前模板块文本的后面。
l
列表不能打印字符的清单。
n
读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
N
追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
p
打印模板块的行。
P（大写）
打印模板块的第一行。
q
退出Sed。
r file
从file中读行。
t label
if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
T label
错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
w file
写并追加模板块到file末尾。
W file
写并追加模板块的第一行到file末尾。
!
表示后面的命令对所有没有被选定的行发生作用。
s/re/string
用string替换正则表达式re。
=
打印当前行号码。
#
把注释扩展到下一个换行符以前。
以下的是替换标记
g表示行内全面替换。
p表示打印行。
w表示把行写入一个文件。
x表示互换模板块中的文本和缓冲区中的文本。
y表示把一个字符翻译为另外的字符（但是不用于正则表达式）
4. 选项
允许多台编辑。
-h, --help
打印帮助，并显示bug列表的地址。
-n, --quiet, --silent
取消默认输出。
-f, --filer=script-file
引导sed脚本文件名。
-V, --version
打印版本和版权信息。
5. 元字符集
锚定行的开始 如：/^sed/匹配所有以sed开头的行。
$
锚定行的结束 如：/sed$/匹配所有以sed结尾的行。
.
匹配一个非换行符的字符 如：/s.d/匹配s后接一个任意字符，然后是d。
*
匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[]
匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^]
匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
\(..\)
保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers。
&
保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
\<
锚定单词的开始，如:/\<love/匹配包含以love开头的单词的行。
\>
锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
x\{m\}
重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
x\{m,\}
重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
x\{m,n\}
重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
6. 实例
$ sed '2d' example-----删除example文件的第二行。
$ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
$ sed '$d' example-----删除example文件的最后一行。
$ sed '/test/'d example-----删除example文件所有包含test的行。
替换：s命令
$ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
$ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
$ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加localhost，变成192.168.0.1localhost。
$ sed -n 's/\(love\)able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
$ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
选定行的范围：逗号
$ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
$ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
$ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
多点编辑：e命令
$ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
$ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
从文件读入：r命令
$ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
写入文件：w命令
$ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。
追加命令：a命令
$ sed '/^test/a\\--->this is a example' example<-----'this is a example'被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
插入：i命令
$ sed '/test/i\\
new line
-------------------------' example
如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
下一个：n命令
$ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
变形：y命令
$ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
退出：q命令
$ sed '10q' example-----打印完第10行后，退出sed。
保持和获取：h命令和G命令
$ sed -e '/test/h' -e '$G example-----在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保 持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中 的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
保持和互换：h命令和x命令
$ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
7. 脚本
Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
8. 小技巧
在sed的命令行中引用shell变量时要使用双引号，而不是通常所用的单引号。下面是一个根据name变量的内容来删除named.conf文件中zone段的脚本：
name='zone\ "localhost"'
sed "/$name/,/};/d" named.conf
- 1. Sed简介
- sed 是 一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处 理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输 出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。
- 2. 定址
- 可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定 。
- 3. Sed命令
- 调用sed命令有两种形式：
- *
- sed [options] 'command' file(s)
- *
- sed [options] -f scriptfile file(s)
- a\
- 在当前行后面加入一行文本。
- b lable
- 分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
- c\
- 用新的文本改变本行的文本。
- d
- 从模板块（Pattern space）位置删除行。
- D
- 删除模板块的第一行。
- i\
- 在当前行上面插入文本。
- h
- 拷贝模板块的内容到内存中的缓冲区。
- H
- 追加模板块的内容到内存中的缓冲区
- g
- 获得内存缓冲区的内容，并替代当前模板块中的文本。
- G
- 获得内存缓冲区的内容，并追加到当前模板块文本的后面。
- l
- 列表不能打印字符的清单。
- n
- 读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
- N
- 追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
- p
- 打印模板块的行。
- P（大写）
- 打印模板块的第一行。
- q
- 退出Sed。
- r file
- 从file中读行。
- t label
- if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
- T label
- 错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
- w file
- 写并追加模板块到file末尾。
- W file
- 写并追加模板块的第一行到file末尾。
- !
- 表示后面的命令对所有没有被选定的行发生作用。
- s/re/string
- 用string替换正则表达式re。
- =
- 打印当前行号码。
- #
- 把注释扩展到下一个换行符以前。
- 以下的是替换标记
- *
- g表示行内全面替换。
- *
- p表示打印行。
- *
- w表示把行写入一个文件。
- *
- x表示互换模板块中的文本和缓冲区中的文本。
- *
- y表示把一个字符翻译为另外的字符（但是不用于正则表达式）
- 4. 选项
- -e command, --expression=command
- 允许多台编辑。
- -h, --help
- 打印帮助，并显示bug列表的地址。
- -n, --quiet, --silent
- 取消默认输出。
- -f, --filer=script-file
- 引导sed脚本文件名。
- -V, --version
- 打印版本和版权信息。
- 5. 元字符集^
- 锚定行的开始 如：/^sed/匹配所有以sed开头的行。
- $
- 锚定行的结束 如：/sed$/匹配所有以sed结尾的行。
- .
- 匹配一个非换行符的字符 如：/s.d/匹配s后接一个任意字符，然后是d。
- *
- 匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
- []
- 匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
- [^]
- 匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
- \(..\)
- 保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers。
- &
- 保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
- \<
- 锚定单词的开始，如:/\<love/匹配包含以love开头的单词的行。
- \>
- 锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
- x\{m\}
- 重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
- x\{m,\}
- 重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
- x\{m,n\}
- 重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
- 6. 实例
- 删除：d命令
- *
- $ sed '2d' example-----删除example文件的第二行。
- *
- $ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
- *
- $ sed '$d' example-----删除example文件的最后一行。
- *
- $ sed '/test/'d example-----删除example文件所有包含test的行。
- 替换：s命令
- *
- $ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
- *
- $ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
- *
- $ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加 localhost，变成192.168.0.1localhost。
- *
- $ sed -n 's/\(love\)able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
- *
- $ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
- 选定行的范围：逗号
- *
- $ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
- *
- $ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
- *
- $ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
- 多点编辑：e命令
- *
- $ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执 行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
- *
- $ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
- 从文件读入：r命令
- *
- $ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
- 写入文件：w命令
- *
- $ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。
- 追加命令：a命令
- *
- $ sed '/^test/a\\--->this is a example' example<-----'this is a example'被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
- 插入：i命令
- $ sed '/test/i\\
- new line
- -------------------------' example
- 如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
- 下一个：n命令
- *
- $ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
- 变形：y命令
- *
- $ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
- 退出：q命令
- *
- $ sed '10q' example-----打印完第10行后，退出sed。
- 保持和获取：h命令和G命令
- *
- $ sed -e '/test/h' -e '$G example----- 在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式 空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保 持缓存区的特殊缓冲区 内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中 的行的末尾。在这个 例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
- 保持和互换：h命令和x命令
- *
- $ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
- 7. 脚本
- Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
sed是一个很好的文件处理工具，本身是一个管道命令，主要是以行为单位进行处理，可以将数据行进行替换、删除、新增、选取等特定工作，下面先了解一下sed的用法
sed命令行格式为：
sed [-nefri] ‘command’ 输入文本
常用选项：
-n∶使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN的资料一般都会被列出到萤幕上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。
-e∶直接在指令列模式上进行 sed 的动作编辑；
-f∶直接将 sed 的动作写在一个档案内， -f filename 则可以执行 filename 内的sed 动作；
-r∶sed 的动作支援的是延伸型正规表示法的语法。(预设是基础正规表示法语法)
-i∶直接修改读取的档案内容，而不是由萤幕输出。
常用命令：
a ∶新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～
c ∶取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！
d ∶删除，因为是删除啊，所以 d 后面通常不接任何咚咚；
i ∶插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)；
p ∶列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起运作～
s ∶取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g 就是啦！
举例：（假设我们有一文件名为ab）
删除某行
[root@localhost ruby] # sed '1d' ab #删除第一行
[root@localhost ruby] # sed '$d' ab #删除最后一行
[root@localhost ruby] # sed '1,2d' ab #删除第一行到第二行
[root@localhost ruby] # sed '2,$d' ab #删除第二行到最后一行
显示某行
. [root@localhost ruby] # sed -n '1p' ab #显示第一行
[root@localhost ruby] # sed -n '$p' ab #显示最后一行
[root@localhost ruby] # sed -n '1,2p' ab #显示第一行到第二行
[root@localhost ruby] # sed -n '2,$p' ab #显示第二行到最后一行
使用模式进行查询
[root@localhost ruby] # sed -n '/ruby/p' ab #查询包括关键字ruby所在所有行
[root@localhost ruby] # sed -n '/\$/p' ab #查询包括关键字$所在所有行，使用反斜线\屏蔽特殊含义
增加一行或多行字符串
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1a drink tea' ab #第一行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,3a drink tea' ab #第一行到第三行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
drink tea
end
drink tea
[root@localhost ruby] # sed '1a drink tea\nor coffee' ab #第一行后增加多行，使用换行符\n
Hello!
drink tea
or coffee
ruby is me,welcome to my blog.
end
代替一行或多行
[root@localhost ruby] # sed '1c Hi' ab #第一行代替为Hi
Hi
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,2c Hi' ab #第一行到第二行代替为Hi
Hi
end
替换一行中的某部分
格式：sed 's/要替换的字符串/新的字符串/g' （要替换的字符串可以用正则表达式）
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby/bird/g' #替换ruby为bird
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby//g' #删除ruby
插入
[root@localhost ruby] # sed -i '$a bye' ab #在文件ab中最后一行直接输入"bye"
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
bye
----------------------
进阶部分：
多行模式空间：对于多行内的数据进行匹配处理；
·N（Next）命令获取下一行到模式空间。
获取到的多行模式空间，使用\n匹配多行间的换行符，
^匹配模式空间（可多行）的首字符，$匹配模式空间（可多行）的末字符.
·对于一行内满足条件的先进行匹配，之后进行行间的匹配，
可以保证一行内有两个owner的情况下的匹配：
[root@localhost ~]# sed -f owner.sed sedtest.log
the installation guide
for xx
the installation guide shipped with xx
including the installation guide
and xx
the installation guide is xx
[root@localhost ~]# cat sedtest.log
the owner and operator
guide for xx
the owner and operator guide shipped with xx
including the owner and
operator guide and xx
the owner and operator guide is xx
[root@localhost ~]# cat owner.sed
s/owner and operator guide/installation guide/
/owner/{
N
s/ *\n/ /
s/owner and operator guide */installation guide\
/
}
·不使用脚本的第一行，将一行内全部匹配的先处理的情形时，
出现问题的分析：
[root@localhost ~]# cat owner.sed
/owner/{
N
s/ *\n/ /
s/owner and operator guide */installation guide\
/
}
#未先进行一行内先处理语句。
[root@localhost ~]# cat sedtest.log
the owner and operator
guide for xx
the owner and operator guide shipped with xx
including the owner and
operator guide and xx
the owner and operator guide is xx
[root@localhost ~]# sed -f owner.sed sedtest.log（结果中在#行加入了解释）
the installation guide
for xx
#上面处理的是源文件的1-2行，即第一次的匹配。
the installation guide
shipped with xx including the owner and
#上面处理的是源文件的3-4行，Next命令将第二个owner加入模式空间，在第一个owner匹配后，直接被打印，清除模式空间。
operator guide and xx
#该行不匹配owner，直接被打印，清除模式空间。
the installation guide
is xx
#匹配最后一个owner，并打印。
#总之，有第3个owner未匹配这个问题；以及最后空行被取消也是一个问题。
·使用Next时，最末行的注意事项。
#N在执行到最后行时，会出现错误，需要使用$!N：
[root@localhost ~]# cat sedtest.log
the owner and operator
guide for xx
the owner and operator guide shipped with xx
[root@localhost ~]# sed -f owner.sed sedtest.log
the installation guide
for xx
the installation guide
shipped with xx
[root@localhost ~]# cat owner.sed
/owner/{
$!N
s/ *\n/ /
s/owner and operator guide */installation guide\
/
}
#未使用$!时，未对最后行进行处理：
[root@localhost ~]# sed -f owner.sed sedtest.log
the installation guide
for xx
the owner and operator guide shipped with xx
[root@localhost ~]# cat owner.sed
/owner/{
N
s/ *\n/ /
s/owner and operator guide */installation guide\
/
}
·D（Delete）命令：
进行多行模式空间内的删除动作；
和d命令的区别：
d是对整个模式空间的内容进行删除处理，
而D是对模式空间的首行进行处理。
一个例子：
测试的文件，需要将大于1行的连续空行删除成1行。
[root@localhost ~]# cat -A del_test.log
1spaceline:$
$
2spaceline:$
$
$
3spaceline:$
$
$
$
end$
使用d进行多行模式空间删除：
[root@localhost ~]# cat del.sed
/^$/{
N
/^\n$/d
}
#得出的结果，出现2行连续时都被删除：
[root@localhost ~]# sed -f del.sed del_test.log
1spaceline:
2spaceline:
3spaceline:
end
#变更d为D：
[root@localhost ~]# cat del.sed
/^$/{
N
/^\n$/D
}
#结果是符合我们的要求的：
[root@localhost ~]# sed -f del.sed del_test.log
1spaceline:
2spaceline:
3spaceline:
end
·P（Print）多行模式中的打印命令：
打印多行模式空间中的第一行；
一般应用在N之后，D之前，用于输出处理行（一般时第一行），
由于替换等处理后，接着需要删除该行后处理下一行，所以不会处理输出，所以需要使用P；
一般使用N-P-D的循环，来实现逐行进行加入处理先行末尾和后行行首结合匹配的功能；
而且可实现后行可以再次开始匹配的功能，因为是逐行删除的。
一个例子：
#在行末的UNIX和下行前system间加入OS；测试文件：
[root@localhost ~]# cat ptest.log
the UNIX
system is xx,UNIX
system is yy,
the UNIX system.
#脚本：使用了N-P-D循环：
[root@localhost ~]# cat ptest.sed
/UNIX$/{
N
/\nsystem/{
s// OS&/
P
D
}
}
[root@localhost ~]# sed -f ptest.sed ptest.log
the UNIX OS
system is xx,UNIX OS
system is yy,
the UNIX system.
·保持空间：
保持空间：用于临时存储模式空间的数据；
对模式空间和保持空间进行操作的命令：
Hold：H和h，将模式空间数据追加或拷贝到保持空间；（在原有内容后先加换行符）
Get：G和g，将保持空间数据追加或拷贝到模式空间；（在原有内容后先加换行符）
Exchange：x，将模式空间数据和保持空间的数据进行交换。
一个简单的数据切换的例子：
[root@localhost ~]# sed -f space.sed spacetest.log
22
11
222
111
[root@localhost ~]# cat space.sed
/1/{
h
d
}
/2/{
G
}
[root@localhost ~]# cat spacetest.log
11
22
111
222
#将含1行和含2行进行交换；将含1行放入保持空间后删除，以禁止输出；
获取到含2行时，追加获取保持的含1行，输出；
一个替换一类字符为统一大写的字符的例子（具体字符可以不指定，只要指定具体位置即可）
[root@localhost ~]# sed -f matchspace.sed matchspace.log
find the MATCH statement
consult the GET statement
using the READ statement
[root@localhost ~]# cat matchspace.log
find the Match statement
consult the get statement
using the ReaD statement
[root@localhost ~]# cat matchspace.sed
/the .* statement/{
h
s/.* the \(.*\) statement.*/\1/
y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
G
s/\(.*\)\n\(.* the \).*\( statement.*\)/\2\1\3/
}
#先找到the .. statement相关语句，将原语句保存到保持空间内；
通过s获取到待替换单词；使用y进行小写转换为大写；
将保持空间原数据追加获取到模式空间；
通过s将多行模式空间内的需要的3段进行分别分离，再在替换部分进行重新组合。（重点）
一个进行空间内容相互交换的例子：
[root@localhost ~]# sed -f html.sed htmltest.log
<p>start line
a space line as:</p>
<p>end line
last space line as:</p>
[root@localhost ~]# cat htmltest.log
start line
a space line as:
end line
last space line as:
[root@localhost ~]# cat html.sed
/^$/!{
H
d
}
/^$/{
x
s/^\n/<p>/
s/$/<\/p>/
G
}
#将非空行保存到保持空间；遇到空行，进行x交换；进行匹配替换后，再读入空行进行输出。
以上的例子在末行不为空行时会出现不输出最后一个后的内容。
为解决这个问题：
[root@localhost ~]# sed -f html.sed htmltest.log
<p>start line
a space line as:</p>
<p>end line
last space line as:</p>
[root@localhost ~]# cat htmltest.log
start line
a space line as:
end line
last space line as:
[root@localhost ~]# cat html.sed
${
/^$/!{
H
s/.*//
}
}
/^$/!{
H
d
}
/^$/{
x
s/^\n/<p>/
s/$/<\/p>/
G
}
#加入前面的一个部分，使用$匹配文件的最后一行；
如该行不是空行，则将内容保存到保持空间；再将模式空间的内容变为空行，
则向下达到空行流程，交换内容，加入空行输出。（可以看到有一个缺陷：在原文件基础上末行后加了一个空行）
·流控制命令：
流控制命令：：标签；b分支命令；t测试命令；
：label：定义标签名；
/pattern/b <label>:匹配模式后，如有label，程序跳到label后执行；如无，直接跳到脚本末尾；
/address/t <label>:如匹配行的s命令执行成功，则执行t（可有或无label）
b的使用模式：
do-while形式：
：top
command1
/pattern/b top
command2
if(条件符合0)形式：
/pattern/b end
comand1
:end
comand2
if-else形式：
/pattern/b docmd2
comand1
b
:docmd2
comand2
·关于流控制，参考的一个例子：
#跨行将@f1(..),改为\fB..\fB
[root@localhost ~]# cat streamtest.log
start one line test:
start @f1(test1) and @f1(test2) end;
start multi line test:
start @f1(testtest
add1
add2
add3
endadd testend)
all end
[root@localhost ~]# sed -f stream.sed streamtest.log
start one line test:
start \fBtest1\fB and \fBtest2\fB end;
start multi line test:
start \fBtesttest
add1
add2
add3
endadd testend\fB
all end
[root@localhost ~]# cat stream.sed
:begin
/@f1(\([^)]*\))/{
s//\\fB\1\\fB/g
b begin
}
#查找一行内存在的所有符合模式项，使用b begin来循环匹配替换。
/@f1(.*/{
N
s/@f1(\([^)]*\n[^)]*\))/\\fB\1\\fB/g
t again
b begin
}
#查找多行上的符合模式项，如无匹配，使用b again来循环读入下一行；匹配成功走t again。
:again
P
D
#again后操作：如替换成功一次，则打印第一行，删除第一行，后续行继续进行匹配。
·一个比较综合的例子：（对于两行内的模式进行匹配）
#测试文件，需要查找关键字“I love apple”
[root@localhost ~]# cat fintest.log
the first line:test for first line,I love apple,end
the second line:test for second line,
I love apple,end
the fourth line:test for two lines,I love
apple,end
the sixth line:all end
#测试结果：
[root@localhost ~]# sed -f fin.sed fintest.log
the first line:test for first line,I love apple,end
I love apple,end
the fourth line:test for two lines,I love
apple,end
#脚本：（为了便于理解，直接在脚本内使用#号开始解释）
[root@localhost ~]# cat fin.sed
/I love apple/b
#对读入的第一行进行匹配，如匹配，跳出，打印。
$!N
#如上行未匹配，对于非最后行，读入下一行。
h
#保持到保持空间。
s/.*\n//
#去除第一行，保留第二行。
/I love apple/b
#对第二行进行匹配，如匹配，跳出，打印。
g
#如上行未匹配，读入保持空间内容。
s/ *\n/ /
#去除两行间的换行符和可能有的多余空格（类似合并为一行）
/I love apple/{
g
b
}
#对处理后的合并行进行匹配，如匹配，输出原始的两行，跳出，打印。
g
D
#如3种情况都未匹配，删除第一行，继续进行。
·题外话：
上面的例子：
修改文件：
[root@localhost ~]# cat fintest.log
xx
the second line:test for second line,
the fourth line:test for two lines,I love
apple,end
the sixth line:all end
[root@localhost ~]# sed -f fin.sed fintest.log
the fourth line:test for two lines,I love
apple,end
#感觉会有second line也被打印的问题，结果没有这样的问题，暂时不知道原因。
·参考：
sed & awk：Doughherty & Robbins.
这里直接把github上的输出拷贝过来，效果不好，可以直接点击上面的链接查看原文。
sed 简介
sed（stream editor）是一个流编辑器，一次处理流的一行内容。
sed 命令模式sed [options] 'command' file(s)sed [options] -f scriptfile file(s)
常用options
- -n 取消默认输出，只有经过sed特殊处理行(或者动作)才会被列出来。
- -e 多重编辑模式。
- -f 指定sed脚本文件名。
- -i 直接修改文件内容。
地址
地址是用来确定希望编辑的行，可以用数字、正则、美元符（$）来表示。也可以用逗号分隔的两个地址来表示希望编辑的范围，这个范围包括这两个地址所在的行。
[起始地址, 结束地址]
举例：
3 // 表示希望编辑第3行。
$ // 表示希望编辑最后那行。
4, 10 // 表示希望编辑4至10行，[4-10]。
2, $ // 表示希望编辑2至最后行，[2-$]。
/href/ // 表示希望编辑含有 href 字符的那些行。
2, /href/ // 表示希望编辑从第2行开始直到并包括第一个含有 href 字符的行。
/meta/,/link/ // 表示希望编辑从第一个含有 meta 字符的行 到 第一个含有 link 字符的行，
中间的行就算没有 meta 或 link 字符也会被命令处理。
正则元字符
因为sed用到很多正则，所以先补充点正则的知识。
^ 表示行的开头。
$ 表示行的结尾。
\ 表示词尾，如 abc\>表示以abc为尾的单词。
. 句点表示任意单个字符
* 星号表示某个字符出现了0次或多次。
[] 字符集合。如[0-9]表示数字0-9中的任意一个，[a-zA-Z]表示字母中的任意一个。
如果字符集以^开头表示非，如[^0-9]表示非数字。
这些正则跟其他编程语言中的正则差不多，除了 \< 和 \> 。
sed 命令
有了前面的基础，就可以学习sed命令并实际运行了。
几乎所有命令都是这样：[address[,address]][!]{cmd} 。address可以是前面提到的定址中的任何一个。
s 替换命令
s 的命令模式是这样的：[address[, address]]s/pattern/replacement/g
sed "s/my/you/g" file // 把file里的 my 替换为 you
sed "3,$s/my/you/g" file // 把file里 第3行 到 最后行 的 my 替换为 you
sed "3,$s/t/T/3" file // 把file里 第3行 到 最后行 的第三个 t 替换为 T
sed "3,$s/t/T/3g" file // 把file里 第3行 到 最后行 的 第三个开始 的
t 替换为 T sed "1,3s/^/head/g" file // 把file里 第1行 到 第3行 的行首加上 head
sed "1,3s/￥/tail/g" file // 把file里 第1行 到 第3行 的行首加上 tail sed "s/<[^>]*>//g" file // 去除file的html标签，标签通过正则<[^>]*> 匹配，
替换为空也就是删除了。
a 命令和 i 命令
a命令是append，i命令是insert，都可以用来添加行。区别在a是在匹配行后面添加新行，而i是在匹配行的前面添加新行。
命令模式： sed "[address[,address]]i newline" file ， sed "[address[,address]]a newline" file， i命令后面可以有任意数量的空格符。
举例：
sed "/coderbee/a add new line ." csv.txt
// 在每个包含 coderbee 的行的后面插入 newline 的新行。
sed "1,/coderbee/i add new line ." csv.txt
// 从第1行直到第1个包含 coderbee 的行，在这些行的前面插入 newline 的新行。
c 替换匹配行命令
sed "2c newline" csv.txt // 把第2行替换为 newlinesed "/coderbee/c newline" csv.txt // 把第匹配coderbee的行替换为 newline
d 删除匹配行命令
sed "2d" csv.txt // 把第2行删除sed "/coderbee/d" csv.txt // 把第匹配coderbee的行删除
p 打印匹配行命令
sed -n "2p" csv.txt // 打印第2行sed -n "/coderbee/p" csv.txt // 打印匹配coderbee的行
r/w 读写文件命令
但定位匹配行时，r命令可以读取指定的文件，并把文件的内容输出到输出流中，w命令可以把结果输出到指定的文件。
sed -n "1r tmp" csv.txt // 用 -n 属性屏蔽掉默认输出，当匹配到第1行时，读取文件tmp的内容到输出流。sed -n "3w tmp" csv.txt // 用 -n 属性屏蔽掉默认输出，当匹配到第3行时，输出文件tmp的内容。
多个匹配
sed支持匹配多个模式，可以用 -e 选项开启多个匹配。
举例，把file里 [1-3] 行的 my 替换为 you， [3-5]行的 t 替换为 T :sed "1,3s/my/you/g; 3,5s/t/T/g" file
这个也等价于：sed -e "1,3s/my/you/g" -e "3,5s/t/T/g" file
圆括号匹配与变量
圆括号括起来的正则表达式所匹配的字符串可以当成变量来使用，按定义的顺序依次为 \1, \2, ... 。
& 可以当作被匹配的变量，这样可以在被匹配的变量左右加点东西。
通过变量还可以用来从流中抽取特定的值。
echo "abc=123" | sed "s/\([^=]*\)=\(.*\)/\1==\2/g"
// 将得到 abc==123
echo "123456789" | sed "s/5/*&*/g"
// 将得到 1234*5*6789
echo "url='www.google.com'" | sed "s/url='\([^']*\)'/\1/g"
// 将得到 www.google.com
命令打包
命令可以有多个，用逗号分隔，按先后顺序执行，用大括号括起来作为嵌套命令。
echo "abc1231" | sed -n -e "s/a/A/g; s/1/++/g; p"
// 用逗号分隔多个命令，将得到 Abc++23++
echo -e "abc 1\n abc xyz" | sed -n "/abc/{/xyz/p}"
// 嵌套命令，先匹配abc，再匹配xyz，成功后打印，得到： abc xyz
echo -e "abc 1\n abc xyz" | sed -n "/abc/{/xyz/{s/^ *//g; p}}"`
// 嵌套命令，先匹配abc，再匹配xyz，成功后，删除行首的空格，最后打印，得到：abc xyz
sed是一个很好的文件处理工具，本身是一个管道命令，主要是以行为单位进行处理，可以将数据行进行替换、删除、新增、选取等特定工作，下面先了解一下sed的用法
sed命令行格式为：
sed [-nefri] ‘command’ 输入文本
常用选项：
-n∶使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN的资料一般都会被列出到萤幕上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。
-e∶直接在指令列模式上进行 sed 的动作编辑；
-f∶直接将 sed 的动作写在一个档案内， -f filename 则可以执行 filename 内的sed 动作；
-r∶sed 的动作支援的是延伸型正规表示法的语法。(预设是基础正规表示法语法)
-i∶直接修改读取的档案内容，而不是由萤幕输出。
常用命令：
a ∶新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～
c ∶取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！
d ∶删除，因为是删除啊，所以 d 后面通常不接任何咚咚；
i ∶插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)；
p ∶列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起运作～
s ∶取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g 就是啦！
举例：（假设我们有一文件名为ab）
删除某行
[root@localhost ruby] # sed '1d' ab #删除第一行
[root@localhost ruby] # sed '$d' ab #删除最后一行
[root@localhost ruby] # sed '1,2d' ab #删除第一行到第二行
[root@localhost ruby] # sed '2,$d' ab #删除第二行到最后一行
显示某行
. [root@localhost ruby] # sed -n '1p' ab #显示第一行
[root@localhost ruby] # sed -n '$p' ab #显示最后一行
[root@localhost ruby] # sed -n '1,2p' ab #显示第一行到第二行
[root@localhost ruby] # sed -n '2,$p' ab #显示第二行到最后一行
使用模式进行查询
[root@localhost ruby] # sed -n '/ruby/p' ab #查询包括关键字ruby所在所有行
[root@localhost ruby] # sed -n '/\$/p' ab #查询包括关键字$所在所有行，使用反斜线\屏蔽特殊含义
增加一行或多行字符串
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1a drink tea' ab #第一行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,3a drink tea' ab #第一行到第三行后增加字符串"drink tea"
Hello!
drink tea
ruby is me,welcome to my blog.
drink tea
end
drink tea
[root@localhost ruby] # sed '1a drink tea\nor coffee' ab #第一行后增加多行，使用换行符\n
Hello!
drink tea
or coffee
ruby is me,welcome to my blog.
end
代替一行或多行
[root@localhost ruby] # sed '1c Hi' ab #第一行代替为Hi
Hi
ruby is me,welcome to my blog.
end
[root@localhost ruby] # sed '1,2c Hi' ab #第一行到第二行代替为Hi
Hi
end
替换一行中的某部分
格式：sed 's/要替换的字符串/新的字符串/g' （要替换的字符串可以用正则表达式）
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby/bird/g' #替换ruby为bird
[root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby//g' #删除ruby
插入
[root@localhost ruby] # sed -i '$a bye' ab #在文件ab中最后一行直接输入"bye"
[root@localhost ruby]# cat ab
Hello!
ruby is me,welcome to my blog.
end
bye
一、示例文件及需求：
catfile
111111111111111111
222222222222222222
=333333333333333333
444444444444444444
如果某行以=开始，则合并到上一行并替代＝为空格
二、sed脚本执行结果：
sed-e:a-e'$!N;s/\n=//;ta'-e'P;D'file
111111111111111111
222222222222222222333333333333333333
444444444444444444
三、命令说明:
:a定义一个标签位置
$!N如果不是最后一行，就读入新行附加于patternspace之后，以“\n”分隔
s/\n=//如果发现了\n=的，替换为空格
ta如果找到了替换，从标签a处再执行，否则向下走
P打印patternspace中的第一个\n之前的内容
D删除patternspace中的第一个\n之前的内容,不打印模式空间，如果有模式空间还有数据，不会读取新行，继续开始下一循环
四、执行流程分析：
第一行执行，没有找到 \n= 打印第一行，读入第二行，脚本头部执行
第二行执行，找到 \n= ，替换为空格，从标签a处再执行
第三行执行，没有找到 \n= 打印第二三行的合并和第四行，读入新行，没有了，结束
COMM:代表命令，PATT:代表patternspace的内容，其他为sed输出的内容
PATT:111111111111111111$
COMM::a
COMM:$!N
PATT:111111111111111111\n222222222222222222$
COMM:s/\n=//
PATT:111111111111111111\n222222222222222222$
COMM:ta
COMM:P
111111111111111111
PATT:111111111111111111\n222222222222222222$
COMM:D
PATT:222222222222222222$
COMM::a
COMM:$!N
PATT:222222222222222222\n=333333333333333333$
COMM:s/\n=//
PATT:222222222222222222333333333333333333$
COMM:ta
COMM:$!N
PATT:222222222222222222333333333333333333\n444444444444444444$
COMM:s/\n=//
PATT:222222222222222222333333333333333333\n444444444444444444$
COMM:ta
COMM:P
222222222222222222333333333333333333
PATT:222222222222222222333333333333333333\n444444444444444444$
COMM:D
PATT:444444444444444444$
COMM::a
COMM:$!N
PATT:444444444444444444$
COMM:s/\n=//
PATT:444444444444444444$
COMM:ta
COMM:P
444444444444444444
PATT:444444444444444444$
COMM:D
五、参考：
http://bbs.chinaunix.net/thread-277289-1-1.html
一. SED初瞰.
- $ sed -e 'd' /etc/services
用一个编辑命令 'd' 调用 sed。sed 打开 /etc/services 文件，将一行读入其模式缓冲区，执行编辑命令（“删除行”），然后打印模式缓冲区（缓冲区已为空）。然后，它对后面的每一行重复这些步骤。这不会产生输 出，因为 "d" 命令除去了模式缓冲区中的每一行！
在该例中，还有几件事要注意。首先，根本没有修改 /etc/services。
- $ sed -e '1d' /etc/services | more
除了前面有 '1' 之外，该命令与第一个 'd' 命令十分类似。如果您猜到 '1' 指的是第一行，那您就猜对了。与第一个示例中只使用 'd' 不同的是，这一次使用的 'd' 前面有一个可选的数字地址。通过使用地址，可以告诉 sed 只对某一或某些特定行进行编辑。
- $ sed -e '1,10d' /etc/services | more
地址范围: 删除1到10的行; 再分页显示;
- sed -e '1d' shell.txt | awk -F "=" '{print $1}' >> my.ini
对shell.txt文件输入SED的缓冲区,删除第一行 | 对每行进行=拆分,取第一个元素 | 把最后的结果集输入文件my.ini
二. 规则表达式:
- $ sed -e '/^#/d' /etc/services | more
规则 表达式 描述
/./ 将与包含至少一个字符的任何行匹配
/../ 将与包含至少两个字符的任何行匹配
/^#/ 将与以 '#' 开始的任何行匹配
/^$/ 将与所有空行匹配
/}^/ 将与以 '}'（无空格）结束的任何行匹配
/} *^/ 将与以 '}' 后面跟有 零或多个空格结束的任何行匹配
/[abc]/ 将与包含小写 'a'、'b' 或 'c' 的任何行匹配
/^[abc]/ 将与以 'a'、'b' 或 'c' 开始的任何行匹配
在这些示例中，鼓励您尝试几个。花一些时间熟悉规则表达式，然后尝试几个自己创建的规则表达式。可以如下使用 regexp：
- $ sed -e '/regexp/d' /path/to/my/test/file | more
这将导致 sed 删除任何匹配的行。然而，通过告诉 sed 打印regexp 匹配并删除不匹配的内容，而不是与之相反的方法，会更有利于熟悉规则表达式。可以用以下命令这样做：
- $ sed -n -e '/regexp/p' /path/to/my/test/file | more
请注意新的 '-n' 选项，该选项告诉 sed 除非明确要求打印模式空间，否则不这样做。您还会注意到，我们用 'p' 命令替换了 'd' 命令，如您所猜想的那样，这明确要求 sed 打印模式空间。就这样，将只打印匹配部分。
目 前为止，我们已经看到了行地址、行范围地址和 regexp 地址。但是，还有更多的可能。我们可以指定两个用逗号分开的规则表达式，sed 将与所有从匹配第一个规则表达式的第一行开始，到匹配第二个规则表达式的行结束（包括该行）的所有行匹配。例如，以下命令将打印从包含 "BEGIN" 的行开始，并且以包含 "END" 的行结束的文本块：
- $ sed -n -e '/BEGIN/,/END/p' /my/test/file | more
如果没发现 "BEGIN"，那么将不打印数据。如果发现了 "BEGIN"，但是在这之后的所有行中都没发现 "END"，那么将打印所有后续行。发生这种情况是因为 sed 面向流的特性 -- 它不知道是否会出现 "END"。
替换任意字符：
sed "s/<Client-Inactivity-Timeout>.*<\/Client-Inactivity-Timeout>/<Client-Inactivity-Timeout>99<\/Client-Inactivity-Timeout>/g" agent.xml.15 > 1
将agent.xml.15 中 <Client-Inactivity-Timeout>.*<\/Client-Inactivity-Timeout> 替换为： <Client-Inactivity-Timeout>99<\/Client-Inactivity-Timeout> 并将结果文件输出到 1 中；
如果实在被文件中修改：
sed -i "s/<Client-Inactivity-Timeout>.*<\/Client-Inactivity-Timeout>/<Client-Inactivity-Timeout>99<\/Client-Inactivity-Timeout>/g" agent.xml.15
其中 .* 代表 任意字符无限次出现：
. ： 表示 任意字符
* ： 表示出现无限次
如果只写* 的话，是没有任何含义的
linux下批量替换文件内容
1、网络上现成的资料
格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径`
linux sed 批量替换多个文件中的字符串
sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir`
例如：替换/home下所有文件中的www.admin99.net为admin99.net
sed -i "s/www.admin99.net/admin99.net/g" `grep www.admin99.net -rl /home`
exp:sed -i "s/shabi/$/g" `grep shabi -rl ./`
2、自己额外附加
2.1 将文件1.txt内的文字“garden”替换成“mirGarden”
# sed -i "s/garden/mirGarden/g" 1.txt //sed -i 很简单
2.2 将当前目录下的所有文件内的“garden”替换成“mirGarden”
## sed -i "s/garden/mirGarden/g" `ls` //其实也就是ls出多个文件名而已
sed学习笔记：
-----------
·一般形式：
操作行范围（行号或模式匹配行范围）-操作符-操作对象-操作结果-行内操作方式
（在操作符前加！号，则对操作行范围外的行进行操作）
简单的例子如下：
[root@localhost ~]# cat grade.log
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
匹配含lucy的行到结尾行之外的行，进行删除操作：
[root@localhost ~]# sed '/lucy/,$!d' grade.log
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 5
匹配含lucy的行到含xx的行，但是由于到结尾行都未匹配到xx的行，所以lucy行后的行都会进行删除操作：
[root@localhost ~]# sed '/lucy/,/xx/d' grade.log
andy 86 78 99 56
lily 66 70 59 56
·分组命令：
对于操作行范围之后的操作符命令可以有多个，多个操作命令使用大括号括起来，多个命令都对操作行范围的行进行操作；
一个简单的例子如下：
[root@localhost ~]# cp grade.log grade.log.bak
对于操作行范围内，进行两个操作：删除含Steve行和修改56为xx：
[root@localhost ~]# sed -i '/lucy/,/xx/{/steve/d;s/56/xx/}' grade.log
[root@localhost ~]# cat grade.log
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 xx
ann 80 78 90 xx
[root@localhost ~]# cat grade.log.bak
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
·sed一般使用的场景：
对于一个文件的多重处理；
对于多个文件的同一套策略处理；
获取范围行，对于相应行进行分别的处理。
·替换操作：
一般形式：
行地址/s/模式/替换符/标识
其中，
分割符：
可以不是/,可以是其他字符，但是选择的分割符，不要是正则表达式符和替换文本内的字符。
替换符：
有几点特殊的字符：
1.&，使用模式匹配部分的内容进行替换；
2.\n，n为数字，代表替换在模式匹配部分第n个“\(”和"\)"括起来的部分；
3.\，作为转义符，也可以转义换行符，从而产生多行的替换符。
标识：
可以为：
1.n（1-512），表示对一行内模式识别到的第几次进行替换处理；
2.g，对于全部模式识别到的，都进行替换处理；
3.p，打印匹配到模式空间的内容；
4.w file，模式空间的内容写入file
针对以上规则的几个例子：
使用#作为分割符：
[root@localhost ~]# echo "/dev/null" |sed 's#/dev/null#devnull#'
devnull
替换符：
使用&替换模式匹配到的字符，加入|plus|便于观察：
[root@localhost ~]# echo "one:two" |sed 's/.*:/&|plus|/'
one:|plus|two
使用\n复制模式匹配的内容作为替换符的一部分（为了便于查看，下例sed使用#作为分割符）：
[root@localhost ~]# echo "one:two" |sed 's#\(.*\):\(.*\)#\2:\1#'
two:one
使用\在替换符中进行转义换行符，形成多行输出的例子；（较复杂，只想了解基本内容的话，可跳过）
[root@localhost ~]# cat nseptest.sed
{
s/one/\
\
3lineone/
s/://
s/two/\
\
5linetwo/
s/$/\
/
}
在one前加两行空行，去除：号，在two前加一行空行，在末尾再加入一行空行；
为了便于观察，将sed的结果赋予cat -A以便显示出结尾的$符：
[root@localhost ~]# echo "one:two" |sed -f nseptest.sed |cat -A -
$
$
3lineone$
$
5linetwo$
$
最后，标识符的规则比较简单，例子如下：
[root@localhost ~]# echo "one:two" |sed 's/o/x/g'
xne:twx
[root@localhost ~]# echo "one:two" |sed 's/o/x/2'
one:twx
[root@localhost ~]# echo "one:two" |sed 's/o/x/2w file'
one:twx
[root@localhost ~]# cat file
one:twx
·删除操作：
删除符合要求行，清空模式空间数据，重新读取新的数据行。
几个简单的例子：
[root@localhost ~]# cat grade.log
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
[root@localhost ~]# sed '/lily/,/steve/d' grade.log
andy 86 78 99 56
ann 80 78 90 56
删除空行：
[root@localhost ~]# cat name.log
andy,3233:xx
steve,77899:yy
end,0:z
[root@localhost ~]# sed '/^$/d' name.log
andy,3233:xx
steve,77899:yy
end,0:z
删除Steve以及之后的行：
[root@localhost ~]# sed '/steve/,$d' name.log
andy,3233:xx
·插入，追加，修改操作：
插入和追加操作只能对单行进行操作；而且加入的行对模式空间没有影响，也不会执行后面的执行语句。
修改操作可以对多行进行操作，相当于先将匹配的多行删除，然后，替换为输入数据。
一个综合的例子：
在含andy行前加入“insertline”；在含末尾行后追加“appendline”；将含82数据行，替换为“82changeline”：
[root@localhost ~]# sed -e '/andy/i insertline' -e '$a appendline' -e '/82/c 82changeline' grade.log
insertline
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
82changeline
ann 80 78 90 56
appendline
[root@localhost ~]# cat grade.log
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
·转换操作：
进行字符的转换操作，注意此操作和单词无关，只是相应位置的字符和字符的转换：
[root@localhost ~]# echo aBcde|sed 'y/abc/XYZ/'
XBZde
·next命令：
将模式空间的行移除，输入下一行，进行下一个执行命令；（和awk的next操作类似）
此操作改变了sed正常的控制流（读入一行，全部语句执行完成，再读取下一行）；
产生的结果就是模式空间中的行，不再执行next之后的语句；读入的下一行，不会执行next之前的语句。
一个简单的例子：
将含“Steve”行后面的空行删除：
[root@localhost ~]# cat name.log
andy,3233:xx
steve,77899:yy
empty
end,0:z
[root@localhost ~]# sed '/steve/{n;/^$/d}' name.log
andy,3233:xx
steve,77899:yy
empty
end,0:z
#注意：empty行后面的空行未删除。
·读入文件，写入文件操作：
读入文件（r）：适用于要将一个文件系统插入另一文件的特定行的情况：
写入文件（w）：适用于将匹配行，分别写入单独文件的情况。
读入例子如下：
使用filename文件内的内容插入到FILENAME行后，此外可以删除FILENAME行：
[root@localhost ~]# sed -e '/FILENAME/r filename' -e '/FILENAME/d' grade.log
grade.log
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
[root@localhost ~]# cat filename
grade.log
[root@localhost ~]# cat grade.log
FILENAME
andy 86 78 99 56
lily 66 70 59 56
lucy 77 78 69 56
steve 82 78 87 56
ann 80 78 90 56
写出例子如下：
[root@localhost ~]# sed -e '/Sales/w salelist.log' -e '/Support/w suptlist.log' employees.txt
Emma Thomas:100:Sales
Alex Jason:200:Sales
Madison Randy:300:Support
Sanjay Gupta:400:Support
Nisha Singh:500:Sales
[root@localhost ~]# cat salelist.log
Emma Thomas:100:Sales
Alex Jason:200:Sales
Nisha Singh:500:Sales
[root@localhost ~]# cat suptlist.log
Madison Randy:300:Support
Sanjay Gupta:400:Support
[root@localhost ~]#
退出操作命令：
用于对于大文件进行操作，操作后即返回，不再继续查找以节省时间：
节省时间的例子如下：
[root@localhost ~]# time sed '10q' /var/log/anaconda.log
10:11:15 INFO : 515308 kB are available
...
10:11:16 INFO : loaded nfs_acl from /modules/modules.cgz
real 0m0.184s
user 0m0.000s
sys 0m0.017s
[root@localhost ~]# time sed -n '1,10p' /var/log/anaconda.log
10:11:15 INFO : 515308 kB are available
...
10:11:16 INFO : loaded nfs_acl from /modules/modules.cgz
real 0m0.525s
user 0m0.005s
sys 0m0.026s
当然，正常场景可能是匹配查找关键字，然后退出。
一、sed读取行和打印行解析：
1.sed读取到模式空间的行不包括\n字符;
2.sed读取多行到模式空间时，自动以\n字符进行分隔;
3.sed打印行时并不打印以模式空间加的\n字符,而是行逐行打印除\n外的字符，然后由p或P命令添加\n字符;
4.sed默认自动打印每一个模式空间单元,其实是隐式执行-e 'p;d'命令
误解：
1.sed读取到模式空间的行包括\n字符;
2.sed读取多行到模式空间时，没有以\n字符进行分隔，而是直接读取文件中的\n;
3.sed打印一行时，直接打印模式空间行数据+\n;
二、分析：
1.示例文件：
cat file
test111
222222
2.sed处理：
sed -n -e :a -e 'N;s/\n\n/\n/;Ta' -e '/test/p'
基本流程是：一直读取新行，直到找到\n\n，并替换成\n,最后删除匹配test的行
3.误解分析：
PATT为模式空间,COMM为执行命令,OUT为标准输出
PATT:test111\n
COMM::a
COMM:$!N
PATT:test111\n\n
COMM:s/\n\n/\n/
PATT:test111
COMM:Ta
COMM:/test/p
OUT:test111
PATT:
PATT:222222\n
COMM::a
COMM:$!N
COMM:S/\n\n/\n/
COMM:Ta
COMM:/test/p
OUT:
PATT:
最终输出结果:test111
3.正解分析：
PATT:test111
COMM::a
COMM:$!N
PATT:test111\n空
COMM:s/\n\n/\n/
COMM:Ta
COMM:/$!N
PATT:test111\n\n22222
COMM:s/\n\n/\n/
PATH:test111\n22222
COMM:/test/p
OUT:test111\n22222
PATT:
最终输出结果：test111\n22222\n
一、示例文件及需求：
cat file
11111111
2222222
3333333
反序显示
二、sed处理及结果：
sed '1!G;h;$!d'
3333333
2222222
11111111
三、命令说明：
g G 复制/附加保持空间的内容到模式空间
h H 复制/附加模式空间的内容到保持空间
四、命令执行流程：
执行第一行,保存第一行保持空间,清除模式空间
执行第二行,保存第二行+第一行到保持空间，清除模式空间
执行第三行,保存第三行+第二行+第一行到保持空间，清除模式空间
COMM:代表命令，PATT:代表patternspace的内容,HOLD代表保持空间的内容，其他为sed输出的内容
PATT:11111111 <------Cycle1
HOLD:
COMM:1!G
COMM:h
HOLD:11111111
COMM:$!d
PATT:
PATT:2222222 <-------Cycle2
COMM:1!G
PATT:2222222\n11111111
COMM:h
HOLD:2222222\n11111111
COMM:$!d
PATT:
PATT:3333333 <---------Cycle3
COMM:1!G
PATT:3333333\n2222222\n11111111
COMM:h
HOLD:3333333\n2222222\n11111111
COMM:$!d
OUT:3333333\n2222222\n11111111
PATT:
Sed学习笔记
作者：Jims of 肥肥世家
Copyright © 2004，2005, 本文遵从GNU 的自由文档许可证(Free Document License)的条款，欢迎转载、修改、散布。
发布时间:2004年09月20日
最近更新:2005年12月22日，增加小技巧章节。
Table of Contents
- 1. Sed简介
- 2. 定址
- 3. Sed命令
- 4. 选项
- 5. 元字符集
- 6. 实例
- 7. 脚本
- 8. 小技巧
1. Sed简介
sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。以下介绍的是Gnu版本的Sed 3.02。
2. 定址
可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定 。
3. Sed命令
调用sed命令有两种形式：
sed [options] 'command' file(s)
sed [options] -f scriptfile file(s)
- a\
在当前行后面加入一行文本。
- b lable
分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
- c\
用新的文本改变本行的文本。
- d
从模板块（Pattern space）位置删除行。
- D
删除模板块的第一行。
- i\
在当前行上面插入文本。
- h
拷贝模板块的内容到内存中的缓冲区。
- H
追加模板块的内容到内存中的缓冲区
- g
获得内存缓冲区的内容，并替代当前模板块中的文本。
- G
获得内存缓冲区的内容，并追加到当前模板块文本的后面。
- l
列表不能打印字符的清单。
- n
读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
- N
追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
- p
打印模板块的行。
- P（大写）
打印模板块的第一行。
- q
退出Sed。
- r file
从file中读行。
- t label
if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
- T label
错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
- w file
写并追加模板块到file末尾。
- W file
写并追加模板块的第一行到file末尾。
- !
表示后面的命令对所有没有被选定的行发生作用。
- s/re/string
用string替换正则表达式re。
- =
打印当前行号码。
- #
把注释扩展到下一个换行符以前。
- 以下的是替换标记
g表示行内全面替换。
p表示打印行。
w表示把行写入一个文件。
x表示互换模板块中的文本和缓冲区中的文本。
y表示把一个字符翻译为另外的字符（但是不用于正则表达式）
4. 选项
- -e command, --expression=command
允许多台编辑。
- -h, --help
打印帮助，并显示bug列表的地址。
- -n, --quiet, --silent
取消默认输出。
- -f, --filer=script-file
引导sed脚本文件名。
- -V, --version
打印版本和版权信息。
5. 元字符集
- ^
锚定行的开始 如：/^sed/匹配所有以sed开头的行。
- $
锚定行的结束 如：/sed$/匹配所有以sed结尾的行。
- .
匹配一个非换行符的字符 如：/s.d/匹配s后接一个任意字符，然后是d。
- *
匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
- []
匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
- [^]
匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
- \(..\)
保存匹配的字符，如s/\(love\)able/\1rs，loveable被替换成lovers。
- &
保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
- \<
锚定单词的开始，如:/\<love/匹配包含以love开头的单词的行。
- \>
锚定单词的结束，如/love\>/匹配包含以love结尾的单词的行。
- x\{m\}
重复字符x，m次，如：/0\{5\}/匹配包含5个o的行。
- x\{m,\}
重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
- x\{m,n\}
重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5--10个o的行。
6. 实例
- 删除：d命令
$ sed '2d' example-----删除example文件的第二行。
$ sed '2,$d' example-----删除example文件的第二行到末尾所有行。
$ sed '$d' example-----删除example文件的最后一行。
$ sed '/test/'d example-----删除example文件所有包含test的行。
- 替换：s命令
$ sed 's/test/mytest/g' example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。
$ sed -n 's/^test/mytest/p' example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。
$ sed 's/^192.168.0.1/&localhost/' example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加 localhost，变成192.168.0.1localhost。
$ sed -n 's/\(love\)able/\1rs/p' example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。
$ sed 's#10#100#g' example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。
- 选定行的范围：逗号
$ sed -n '/test/,/check/p' example-----所有在模板test和check所确定的范围内的行都被打印。
$ sed -n '5,/^test/p' example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。
$ sed '/test/,/check/s/$/sed test/' example-----对于模板test和west之间的行，每行的末尾用字符串sed test替换。
- 多点编辑：e命令
$ sed -e '1,5d' -e 's/test/check/' example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执 行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
$ sed --expression='s/test/check/' --expression='/love/d' example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。
- 从文件读入：r命令
$ sed '/test/r file' example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。
- 写入文件：w命令
$ sed -n '/test/w file' example-----在example中所有包含test的行都被写入file里。
- 追加命令：a命令
$ sed '/^test/a\\--->this is a example' example<-----'this is a example'被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。
- 插入：i命令
$ sed '/test/i\\
new line
-------------------------' example
如果test被匹配，则把反斜杠后面的文本插入到匹配行的前面。
- 下一个：n命令
$ sed '/test/{ n; s/aa/bb/; }' example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。
- 变形：y命令
$ sed '1,10y/abcde/ABCDE/' example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。
- 退出：q命令
$ sed '10q' example-----打印完第10行后，退出sed。
- 保持和获取：h命令和G命令
$ sed -e '/test/h' -e '$G example-----在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保 持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中 的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
- 保持和互换：h命令和x命令
$ sed -e '/test/h' -e '/check/x' example -----互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。
7. 脚本
Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
8. 小技巧
在sed的命令行中引用shell变量时要使用双引号，而不是通常所用的单引号。下面是一个根据name变量的内容来删除named.conf文件中zone段的脚本：
name='zone\ "localhost"'
sed "/$name/,/};/d" named.conf
用sed命令模拟tac
- cat data
This is the header line.
This is the first data line.
This is the second data line.
This is the last line.
- tac data
This is the last line.
This is the second data line.
This is the first data line.
This is the header line.
- sed -n '{1!G;h;$p}' data
This is the last line.
This is the second data line.
This is the first data line.
This is the header line.
八、流编辑器sed
8.1 sed简介
sed是stream editor的缩写，一种流编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有 改变，除非你使用重定向存储输出。sed主要用来自动编辑一个或多个文件，简化对文件的反复操作，编写转换程序等。
8.2 sed命令格式
sed [nefri] 'command' file(s)
常用选项:
-n 使用安静（silent）模式。在一般sed的用法中，所有来自stdin的资料一般都会被列出到屏幕，但如果加上-n参数后，则只有经过sed特殊处理的那一行（或者command）才会被列出来。
-e 允许多点编辑。
-f 直接将sed的动作写在一个档案内，-f filename 则可以执行filename内的sed动作。
-r sed 的动作支援的是延伸型正规表示法的语法。(预设是基础正规表示法语法)
-i 直接修改读取的档案内容，而不是由屏幕输出。
常用command:
a\ 新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～
c\ 取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！
d 删除，因为是删除啊，所以 d 后面通常不接任何咚咚；
i\ 插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)；
p 列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起运作～
s 取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g 就是啦！
高级command:
| 命令 | 功能描述 |
| h | 拷贝pattern space的内容到holding buffer(特殊缓冲区)。 |
| H | 追加pattern space的内容到holding buffer。 |
| g | 获得holding buffer中的内容，并替代当前pattern space中的文本。 |
| G | 获得holding buffer中的内容，并追加到当前pattern space的后面。 |
| n | 读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。 |
| P | 打印pattern space中的第一行。 //大写 |
| q | 退出sed。 |
| w file | 写并追加pattern space到file的末尾。 |
| ! | 表示后面的命令对所有没有被选定的行发生作用。 |
| s/re/string | 用string替换正则表达式re。 |
| = | 打印当前行号码。 |
| 替换标记 | |
| g | 行内全面替换，如果没有g，只替换第一个匹配。 |
| x | 互换pattern space和holding buffer中的文本。 |
| y | 把一个字符翻译为另一个字符(但是不能用于正则表达式)。 |
需要说明的是，sed中的正则和grep的基本相同，完全可以参照本系列的第一篇中的详细说明。
8.3 sed实例
# cat testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 13
实例1.1：如果模板north被找到，sed除了打印所有行之外，还有打印匹配行。
# sed '/north/p' testfile
northwest NW Charles Main 3.0 .98 3 34
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 13
实例1.2：-n选项取消了sed的默认行为。在没有-n的时候，包含模板的行被打印两次，但是在使用-n的时候将只打印包含模板的行。
# sed -n '/north/p' testfile
northwest NW Charles Main 3.0 .98 3 34
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
实例：列出第5-7行
# nl testfile |sed -n '5,7p'
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
实例2.1：删除第三行，其他行默认输出到屏幕。
# nl testfile |sed '3d'
1 northwest NW Charles Main 3.0 .98 3 34
2 western WE Sharon Gray 5.3 .97 5 23
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
实例2.2：删除2~5行
# nl testfile |sed '2,5d'
1 northwest NW Charles Main 3.0 .98 3 34
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
实例2.3：从第三行删除到最后一行，其他行被打印。$表示最后一行。
# nl testfile |sed '3,$d'
1 northwest NW Charles Main 3.0 .98 3 34
2 western WE Sharon Gray 5.3 .97 5 23
实例2.4：删除最后一行，其他行打印。
# nl testfile |sed '$d'
1 northwest NW Charles Main 3.0 .98 3 34
2 western WE Sharon Gray 5.3 .97 5 23
3 southwest SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
实例2.5：删除所有包含north的行，其他行打印。
# nl testfile |sed '/north/d'
2 western WE Sharon Gray 5.3 .97 5 23
3 southwest SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
9 central CT Ann Stephens 5.7 .94 5 13
实例3.1：在第二行后（即加在第三行）加上"United States"。
# nl testfile |sed '2a United States'
1 northwest NW Charles Main 3.0 .98 3 34
2 western WE Sharon Gray 5.3 .97 5 23
United States
3 southwest SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
如果要在第二行前加，则命令为
# nl testfile |sed '2i United States'
实例3.2：在第二行后加上两行文本。
# nl testfile |sed '2a United States \
> America'
1 northwest NW Charles Main 3.0 .98 3 34
2 western WE Sharon Gray 5.3 .97 5 23
United States
America
3 southwest SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
若要新增两行，则每一行之间都必须要以反斜线“\”来进行新行的增加。
实例4.1：将第2~5行的内容取代为“No 2-5 number”。
# nl testfile |sed '2,5c No 2-5 number'
1 northwest NW Charles Main 3.0 .98 3 34
No 2-5 number
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
实例3.1：s表示替换，g表示命令作用于整个当前行。如果该行存在多个west，都将被替换为north，如果没有g，则只是替换第一个匹配。
格式：sed 's/要替换的字符串/新的字符串/g'
# nl testfile |sed 's/west/north/g'
1 northnorth NW Charles Main 3.0 .98 3 34
2 northern WE Sharon Gray 5.3 .97 5 23
3 southnorth SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
实例3.2：-n表示只打印匹配行，如果某一行的开头是west，则替换为north。
# sed -n 's/^west/north/p' testfile
northern WE Sharon Gray 5.3 .97 5 23
实例3.3：&符号表示替换字符串中被找到的部分。所有以两个数字结束的行，最后的数字都将被它们自己替换，同时追加.5。
# nl testfile |sed 's/[0-9][0-9]$/&.5/'
1 northwest NW Charles Main 3.0 .98 3 34.5
2 western WE Sharon Gray 5.3 .97 5 23.5
3 southwest SW Lewis Dalsass 2.7 .8 2 18.5
4 southern SO Suan Chin 5.1 .95 4 15.5
5 southeast SE Patricia Hemenway 4.0 .7 4 17.5
6 eastern EA TB Savage 4.4 .84 5 20.5
7 northeast NE AM Main Jr. 5.1 .94 3 13.5
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13.5
实例3.4：所有的Hemenway被替换为Jones。-n选项加p命令则表示只打印匹配行。
# nl testfile |sed -n 's/Hemenway/Jones/gp'
5 southeast SE Patricia Jones 4.0 .7 4 17
实例3.5：模板Mar被包含在一对括号中，并在特殊的寄存器中保存为tag 1，它将在后面作为\1替换字符串，Margot被替换为Marlianne。
# nl testfile |sed -n 's/\(Mar\)got/\1lianne/p'
8 north NO Marlianne Weber 4.5 .89 5 9
实例3.6：s后面的字符一定是分隔搜索字符串和替换字符串的分隔符，默认为斜杠，但是在s命令使用的情况下可以改变。不论什么字符紧跟着s命令都认为是新的分隔符。这个技术在搜索含斜杠的模板时非常有用，例如搜索时间和路径的时候。
# sed 's#3#88#g' testfile
northwest NW Charles Main 88.0 .98 88 884
western WE Sharon Gray 5.88 .97 5 288
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 88 188
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 188
# sed 's@3@88@g' testfile
northwest NW Charles Main 88.0 .98 88 884
western WE Sharon Gray 5.88 .97 5 288
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 88 188
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 188
实例3.7：所有在模板west和east所确定的范围内的行都被打印，如果west出现在east后面的行中，从west开始到下一个east，无论这个 east出现在哪里，二者之间的行都被打印，即使从west开始到文件的末尾还没有出现east，那么从west到末尾的所有行都将打印。
# nl testfile |sed -n '/south/,/east/p'
3 southwest SW Lewis Dalsass 2.7 .8 2 18
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Hemenway 4.0 .7 4 17
实例3.8：打印从第五行开始到第一个以northeast开头的行之间的所有行。
# sed -n '5,/^northeast/p' testfile
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
实例3.9：-e选项表示多点编辑。第一个编辑命令是删除第一到第三行。第二个编辑命令是用Jones替换Hemenway。
# nl testfile |sed -e '1,3d' -e 's/Hemenway/Jones/'
4 southern SO Suan Chin 5.1 .95 4 15
5 southeast SE Patricia Jones 4.0 .7 4 17
6 eastern EA TB Savage 4.4 .84 5 20
7 northeast NE AM Main Jr. 5.1 .94 3 13
8 north NO Margot Weber 4.5 .89 5 9
9 central CT Ann Stephens 5.7 .94 5 13
实例3.10：将所有匹配含有north的行写入newfile中。
# sed -n '/north/w newfile' testfile
# cat newfile
northwest NW Charles Main 3.0 .98 3 34
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
实例4.1：i是插入命令，在匹配模式行前插入文本。
# sed '/eastern/i\NEW ENGLAND REGION' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
NEW ENGLAND REGION
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 13
实例5.1：找到匹配模式eastern的行后，执行后面花括号中的一组命令，每个命令之间用逗号分隔，n表示定位到匹配行的下一行，s/AM/Archie/完成Archie到AM的替换，p和-n选项的合用，则只是打印作用到的行。
# sed -n '/eastern/{n;s/AM/Archie/;p}' testfile
northeast NE Archie Main Jr. 5.1 .94 3 13
实例：-e表示多点编辑，第一个编辑命令y将前三行中的所有小写字母替换为大写字母，-n表示不显示替换后的输出，第二个编辑命令将只是打印输出转换后的前三行。注意y不能用于正则。
# sed -n -e '1,3y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' -e '1,3p' testfile
NORTHWEST NW CHARLES MAIN 3.0 .98 3 34
WESTERN WE SHARON GRAY 5.3 .97 5 23
SOUTHWEST SW LEWIS DALSASS 2.7 .8 2 18
实例：打印完第二行后退出。
# sed '2q' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
实例：当模板Lewis在某一行被匹配，替换命令首先将Lewis替换为Joseph，然后再用q退出sed。
# sed '/Lewis/{s/Lewis/Joseph/;q;}' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Joseph Dalsass 2.7 .8 2 18
实例：在sed处理文件的时候，每一行都被保存在pattern space的临时缓冲区中。除非行被删除或者输出被取消，否则所有被处理过的行都将打印在屏幕上。接着pattern space被清空，并存入新的一行等待处理。在下面的例子中，包含模板的northeast行被找到，并被放入pattern space中，h命令将其复制并存入一个称为holding buffer的特殊缓冲区内。在第二个sed编辑命令中，当达到最后一行后，G命令告诉sed从holding buffer中取得该行，然后把它放回到pattern space中，且追加到现在已经存在于模式空间的行的末尾。
# sed -e '/northeast/h' -e '$G' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 13
northeast NE AM Main Jr. 5.1 .94 3 13
实例：如果模板WE在某一行被匹配，h命令将使得该行从pattern space中复制到holding buffer中，d命令在将该行删除，因此WE匹配行没有在原来的位置被输出。第二个命令搜索CT，一旦被找到，G命令将从holding buffer中取回行，并追加到当前pattern space的行末尾。简单的说，WE所在的行被移动并追加到包含CT行的后面。
# sed -e '/WE/{h;d;}' -e '/CT/{G;}' testfile
northwest NW Charles Main 3.0 .98 3 34
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
central CT Ann Stephens 5.7 .94 5 13
western WE Sharon Gray 5.3 .97 5 23
实例：第一个命令将匹配northeast的行从pattern space复制到holding buffer，第二个命令在读取的文件的末尾时，g命令告诉sed从holding buffer中取得行，并把它放回到pattern space中，以替换已经存在于pattern space中的。简单说就是包含模板northeast的行被复制并覆盖了文件的末尾行。
# sed -e '/northeast/h' -e '$g' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
northeast NE AM Main Jr. 5.1 .94 3 13
实例：模板WE匹配的行被h命令复制到holding buffer，再被d命令删除。结果可以看出WE的原有位置没有输出。第二个编辑命令将找到匹配CT的行，g命令将取得holding buffer中的行，并覆盖当前pattern space中的行，即匹配CT的行。简单的说，任何包含模板northeast的行都将被复制，并覆盖包含CT的行。
# sed -e '/WE/{h;d;}' -e '/CT/{g;}' testfile
northwest NW Charles Main 3.0 .98 3 34
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
north NO Margot Weber 4.5 .89 5 9
western WE Sharon Gray 5.3 .97 5 23
实例：第一个编辑中的h命令将匹配Patricia的行复制到holding buffer中，第二个编辑中的x命令，会将holding buffer中的文本考虑到pattern space中，而pattern space中的文本被复制到holding buffer中。因此在打印匹配Margot行的地方打印了holding buffer中的文本，即第一个命令中匹配Patricia的行文本，第三个编辑命令会将交互后的holding buffer中的文本在最后一行的后面打印出来。
# sed -e '/Patricia/h' -e '/Margot/x' -e '$G' testfile
northwest NW Charles Main 3.0 .98 3 34
western WE Sharon Gray 5.3 .97 5 23
southwest SW Lewis Dalsass 2.7 .8 2 18
southern SO Suan Chin 5.1 .95 4 15
southeast SE Patricia Hemenway 4.0 .7 4 17
eastern EA TB Savage 4.4 .84 5 20
northeast NE AM Main Jr. 5.1 .94 3 13
southeast SE Patricia Hemenway 4.0 .7 4 17
central CT Ann Stephens 5.7 .94 5 13
north NO Margot Weber 4.5 .89 5 9
sed: 1: “…”: invalid command code on Mac OS
~# sed -i “s/string_old/string_new/g” grep -rl string_old ./
Mac 会得到抛出这个错误
sed: 1: “…”: invalid command code .
为什么呢，在 Mac 上用 man 查看sed命令~# man sed
…
-i extensionEdit files in-place, saving backups with the specified extension. If a zero-length extension is given, no backup will be saved. It is not recommended to give a zero-length extension when in-place editing files, as you risk corruption or partial content in situations where disk space is exhausted, etc.
….
翻译：就地替换文件，根据提供的扩展名保存源文件备份。如果不提供扩展名，则不备份。建议替换操作时提供文件备份的扩展名，因为如果恰巧磁盘耗尽的话，你将冒着原文件被损坏的风险。
所以，如果我们不需要备份的话，可以这样
~# sed -i “” “s/string_old/string_new/g” grep -rl string_old ./
或者要备份原文件
~# sed -i “.bak” “s/string_old/string_new/g” grep -rl string_old ./
算是分享一下遇到的坑
使用Mac OSX上的sed的时候，如果想替换tab这个特殊字符，会出现很多奇奇怪怪的问题。当很很多其他也一样，有时候用Mac上的命令就是蛋疼蛋疼。 这个问题有很多问法，我们暂且把它转化为如何在Mac 的terminal下面输入sed可以识别的tab的字符。
How can I insert a tab character with sed on OS X?
Mac OSX's sed can't understand \t be Tab, therefore, we need to insert Tab for another way.
mac版本sed不支持\t。只需插入一个文字标签（按Ctrl- V然后Tab）。sed -i "" 's/万+ /0000+ /g' *.csv