linux sed 流编辑器的一些应用实例

秒速五厘米 2022-06-13 03:11 145阅读 0赞

注意：以下很多是转载与网友博客或者论坛，很惭愧的是没有记住所有网友名字，总之感谢网友！  
  
  
1. 首先注意sed的作用是什么？本质是什么？本质就是自动的编辑器！也就是在脚本代码

中进行控制的！使编辑文件的过程自动化，以便用“批处理”方式编辑文件  
2.       sed是基于行的，因此按顺序对每一行执行命令。  
3.       参数  
       sed: invalidoption -- h  
       用法: sed\[选项\]... \{脚本(如果没有其他脚本)\} \[输入文件\]...  
  
       \-n, --quiet,--silent  
                                取消自动打印模式空间  
                                也就是所有的显示都是由自己控制的！！！  
         \-e 脚本,--expression=脚本  
                                添加“脚本”到程序的运行列表  
       \-f 脚本文件,--file=脚本文件  
                                添加“脚本文件”到程序的运行列表  
       \-i\[扩展名\],--in-place\[=扩展名\]  
                                直接修改文件(如果指定扩展名就备份文件)  
       \-l N,--line-length=N  
                                指定“l”命令的换行期望长度  
      \--posix  
                                关闭所有 GNU 扩展  
       \-r,--regexp-extended  
                                在脚本中使用扩展正则表达式  
       \-s,--separate  
                                将输入文件视为各个独立的文件而不是一个长的连续输入  
       \-u,--unbuffered  
                                从输入文件读取最少的数据，更频繁的刷新输出  
      \--help        打印帮助并退出  
      \--version   输出版本信息并退出  
  
       如果没有 -e,--expression, -f 或 --file 选项，那么第一个非选项参数被视为  
      sed脚本。其他非选项参数被视为输入文件，如果没有输入文件，那么程序将从标准  
      输入读取数据。  
  
4.       sed -e'1,10d' ping.sh >1         
        \# 将ping.sh中逐行读取到缓冲区，删除ping.sh文件中1-10行，然后重定向到1文件中  
  
5.       sed -e'/^\#/d' ping.sh > 1       
       \#将ping.sh中逐行读取到缓冲区，删除ping.sh文件中第一个字符是\#的行，然后重定向到  
       1文件中  
  
6.       sed -e'/"/d' ping.sh > 1                   
       \# 删除有 "的行，并输出到1文件  
  
7.      字符                描述  
      ^              与行首匹配  
      $              与行末尾匹配  
      \\w          与任一个字符匹配  
      \*                将与 前一个字符的零或多个出现匹配  
       \[\]              与 \[ \] 之内的所有字符匹配  
  
8.      下面是几个示例：  
      规则表达式                描述  
      /./                          将与包含至少一个字符的任何行匹配                         
      \---> 也就是说只要有一个字符的行都会输出  
       
      /../                        将与包含至少两个字符的任何行匹配                         
      \---> 也就是说只要有两个字符在一起及以上的都会删除  
       
      /^\#/                     将与以 '\#'开始的任何行匹配                                     
      \---> 匹配开头( ^ ) 以\#的行删除  
       
      /^$/                    将与所有空行匹配                                                       
      \---> 也就是开头结尾没有东西，所以就是空行删除  
      \---> sed -e '/^$/d' ping.sh | wc -l >1 将非空行的函数输入到文件1( 删除空行，剩下  
               的结果输出到文件 )  
       
      /\}$/                     将与以'\}'（无空格）结束的任何行匹配                   
      \---> sed -e '/\}$/d' ping.sh >1                   以 \}结束的行  
       
       /\}\*^/                     将与以 '\}' 后面跟有零或多个空格结束的任何行匹配       
       
      /\[abc\]/                   将与包含小写'a'、'b' 或 'c'的任何行匹配             
      \---> sed -e '/\[a-z\]/d' ping.sh >1                  将有a-z字母的行都去掉  
       
      /^\[abc\]/               将与以 'a'、'b'或 'c'开始的任何行匹配                   
      \---> sed -e '/\[a-z\]/d' ping.sh >1                  将开头是a-z的行都删除  
       
       
9.       sed -n -e'/\{/,/\}/p' ping.sh >1                                                       
      \----> 注意这是输出命令(p),是输出\{\}之间的内容  
       请注意新的 '-n'选项，该选项告诉 sed 除非明确要求打印模式空间，否则不这样做。  
       您还会注意到，我们用'p' 命令替换了 'd' 命令，如您所猜想的那样，这明确要求 sed  
      打印模式空间。就这样，将只打印匹配部分。  
       
10.       sed -n -e'/judge\[\[:space:\]\]\*(/, /^\}/p'   ping.sh>1                         
      \----> 输出judge函数的所有内容  
         
11.       如何使用 sed来执行字符串替换、创建更大的 sed 脚本以及如何使用 sed 的附加、插  
      入和更改行命令。  
  
12.       替换：  
       sed -e's/echo/oche/'         ping.sh > 1                                           
      \----> s前缀就是替换命令，就是将ping.sh中出现的echo替换为oche  
      \----> 同时注意：只替换每行第一次出现的哦～  
      \----> 请注意：这条命令没有改变源文件中的内容，而下面的就是可以的  
                                                                                                                   
       sed -e's/echo/oche/g'   ping.sh >1                                           
      \----> 将所有的出现的都替换   ( 全局替换吧 )  
       
       
      我们需要知道的是，s/// 是一个命令哦，是不可分割的呗～所以我们可以与其他的命  
       令一起使用!  
       sed -e '1,10s/echo/ohce/g'   ping.sh > 1  
      \----> 也就是只处理1-10行( 包括1和10 )  
      注意：我们要知道的是：1和10指定的行结束，我们也可使用特殊的字符串结束！如  
       下：  
      sed   \-e '/^$/, /^\}/s/echo/ohce/g'   ping.sh > 1  
      \----> 由空行开始执行，直到遇到 \} 开始的行结束  
       
        注意：我们并没有硬性规定一定是s、/组合，这只是常规的用法，当然也可以使用别的  
        字符，例如  
        sed -e 's:echo:ooo:g' ping.sh >1            也是可以的哦～  
        但是一般在替换的字符串中有/才用这样的方法  
        例如：  
        sed -e 's:pt/ss.ps:pt/ss:g' ping.sh > 1  
       
       
13.       sed -e's/<.\*>//g' ping.sh >1  
      \---->将<>形式替换成空格！注意其中有一个 ' . ',所以最少是一个字符哦～  
       
      但是你自己运行一下，这是你需要的结果吗？！！！！  
      显然不是不是吗？  
      在我的测试代码中的内容是：  
        \#  pt/ss/ps        <>    <>  <>    <sdjsdvb>    <...>    <yyyy>  
        \# <z>  
         
        那我本来想留下的结果是：  
        \#   pt/ss/ps  
        \#  
        但是很不幸的是结果是：  
        \#   pt/ss/ps  
        这就是s///的处理机制不一样呗～！那么他会寻找最长的字符串，我们需要怎么作  
        呢！？  
        sed -e's/<\[^>\]\*>//g'  ping.sh > 1  
        中间是>的后面不处理  
        注意：有一些shell是不支持的！  
         
14.       
      注意下面代码的不同：  
       对于处理这样一行：<yjasbhdcjsd>    <a>  
       sed -e's/<\[a-z\]>//g' ping.sh>1                               \#注意此处只是匹配一个字符而已  
       和  
       sed -e's/<\[a-z\]\*>//g' ping.sh>1                         \#此处匹配以字符开头的多个字符  
         
       
15.       
       这将匹配零或多个全部为'a'、'b'、'c'...'v'、'w'、'x' 的字符。另外，可以使用  
       '\[:space:\]'字符类来匹配       
      空格。以下是可用字符类的相当完整的列表：  
      字符类                       描述  
      \[:alnum:\]                     字母数字 \[a-zA-Z 0-9\]  
      \[:alpha:\]                     字母 \[a-zA-Z\]  
      \[:blank:\]                     空格或制表键  
      \[:cntrl:\]                           任何控制字符  
      \[:digit:\]                           数字\[0-9\]  
      \[:graph:\]                    任何可视字符（无空格）  
      \[:lower:\]                         小写\[a-z\]  
      \[:print:\]                           非控制字符  
      \[:punct:\]                     标点字符  
      \[:space:\]                     空格  
      \[:upper:\]                     大写\[A-Z\]  
      \[:xdigit:\]                     十六进制数字 \[0-9a-fA-F\]       
       
       
16.      高级替换功能  
      我们现在想在所有的行前面加上MM，那么怎么处理呢？是所有的行哦～       
       sed -e's/.\*/MM: &/g' ping.sh >1             
      \----> 就是 & 符号处理  
       
17.       's///'命令甚至比 '&' 更好，它允许我们在规则表达式中定义区域，然后可以在替换字  
      符串中引用这些  
       特定区域。  
       内容：ping -w 5www.baidu.com  
       改为：ssping -w5-www.baidu.com  
       
       sed -e's/\$.\*\$ \$.\*\$ \$.\*\$ \$.\*\$/ss\\1 \\2 \\3-\\4/g' ping.sh> 1  
       
       那么我们知道后面的\\1,\\2, \\3, \\4 就是再次引用！  
       
18.      组合使用  
      注意多个不同命令之间可以使用“ ; ” 进行隔开处理！  
      >:      以下命令系列使用 '=' 命令和 'p' 命令，'=' 命令告诉 sed 打印行号，'p' 命令明确告  
             诉 sed打印该       
             行（因为处于 '-n'模式）。       
             sed -n -e'=;p' ping.sh > 1  
             
             注意“ = ”是表明打印本行的行号，接着后面的p就是打印本行内容！  
            但是上面的情况‪有些时候不可以执行，那么我们更安全的做法是：  
             
             sed -n -e'='   \-e 'p'   ping.sh> 1  
            我们知道-e选项是引入脚本命令，所以是可以的是吧，呵呵～  
             
      >:      在使用更为复杂的附加和插入命令时，甚至多个 '-e' 选项也不能帮我们的忙。对于  
             复杂的多行脚  
            本，最好的方法是将命令放入一个单独的文件中。然后，用 -f 选项引用该脚本文  
             件：  
                 sed -n-f   cmds.sed  ping.sh                   \#注意cmds.sed中是存放命令的哟～  
       
      >:      一个地址的多个命令:  
             sed -e '1,20\{ s/echo/ooo/g ;s/sh/ss/g ;s/ping/ppp/g \} ' ping,sh> 1  
            也就是对于同一个文件中的多个字符串一起处理！  
            要用\{\}就好！  
             
      >:      sed -e ' i\\   insert into'  ping.sh > 1  
             中间的 \\i命令就是将后面的字符串插入到其中！  
             
             sed -e 'a\\insert too...' ping.sh > 1  
            效果差不多哦～  
             
             c\\ You'rehistory, original line! Muhahaha!  
             “更改行”命令将实际替换模式空间中的当前行，其用法如下：  
               
  
19.      文本转换  
       
      >:      第一个实例脚本将 UNIX 风格的文本转换成 DOS/Windows 格式。您可能知道，基  
             于 DOS/  
             Windows的文本文件在每一行末尾有一个 CR（回车）和 LF（换行），而 UNIX 文  
             本只有一个换  
             行。有时可能需要将某些UNIX 文本移至 Windows 系统，该脚本将为您执行必需的  
             格式转换。  
             
             sed -e's/$/\\r/' unix.txt > win.txt  
            \----> 此行代码的意思就是在unix文件结尾加上\\r的回车字符而已，匹配win下的格式  
                       哦～  
             
            那么我们会知道，if将win转化为unix，那么就是如下代码：  
             sed -e's/.$//'      win.txt > unix  
            \----> 也就是去掉最后一个字符！  
             
      >:      反转行( 与tac的命令差不多 )  
            其实也不叫反转行，就是将文件倒过来，也就是从下往上读，但是对于每一个string  
            内部的顺序是不变的哦～  
             sed -e'1!G;h;$!d' ping.sh > 1  
             此命令同：tacping.sh > 1  
             
            解释sed...：基本的原理有点想“ 压栈出栈 ”的机制，也就是从上到下将每行压入  
            到“栈”中，到了指定的最后一行，开始打印出来，最后就是倒序的咯，呵呵～  
            具体的就是，1!G就是每次只对第一行开始操作压栈  
                                    h就是压栈动作  
                                    $!d就是每次压栈后就删除的前面的行，以便处理后面的行！～  
                                     如此循环！～  
             
             
20.      下面的区别：  
       
       sed'/echo/p' ping.sh >1             \#打印所有行，if一些行有echo单词，就再打印一次  
      和       
       sed -n'/echo/p' ping.sh >1       \#只打印有echo的行！  
             
21.       
       sed '3d'datafile     删除第3行  
       sed '3,$d'datafile     删除从第3行到结束  
       sed '$d'datafile     删除最后一行  
       sed'/north/d' file    删除匹配north的行       
             
             
22.      & 是追随此行的命令  
       sed's/\[a-z\]\[a-z\]$/&.xxx/g' ping.sh >1             
       cat 1  
       与  
       sed-e   's/.\*/I say:&/g'   ping.sh >1             \# 每一行的前面加上Isay  
       与  
       sed -e's/\$echo\$/\\1-ch000/g' ping.sh >1       \#使用\\1代表echo是可以的！ echo改  
      成echo-ch000  
       此处使用的 ()可引用的参数变量！  
       
       
23.       现在我们已经知道-n 的作用了，if有了-n，那么就是只输出对应的行，if没有，那么就  
      是所有的内容都输出，if匹配，就输出2遍！  
  
  
24.      多重编辑  
      所谓多重编辑就是形如前面的：sed -e'1,3d'        \-e 's/echo/sss/g' ping.sh >1  
       
25.读入内容：( /str/r   命令 )  
      如果文件ping.sh中某一行匹配到模式echo，则在该行后读入sss文件的内容。  
       sed -e'/echo/r   sss' ping.sh > 1  
      注意：必须有一个sss的文件且有内容才可以看到现象哦～～～  
       
26.      写文件   ( /str/w   命令 )  
      如果文件ping.sh中某一行匹配到模式echo，则在该行后写入sss文件。  
       sed -e'/echo/w   sss' ping.sh  
       
      注意25和26都是针对一行而言的！！！切记！！！  
       
27.       追加( /a)  
      也就是追加到指定的匹配字符串后面！  
       sed -n'/echo/a   xiao\_sha\_gua' ping.sh  
      其实/a和/r是差不多的，不过一个是从文件中，一个是直接指定而已～～～  
       
28.       插入：( /i)       
      在指定的匹配字符串后面插入str  
       sed -e'/echo/i   sss' ping.sh  
      这个和上面的/a和/r也是差不多的哦，呵呵呵～～～  
       
29.       下一行命令：( n)       
       sed -e'/judge/   \{ n; s/echo/ooo/g \}'  ping.sh  
      请注意：仅仅是相对于judge来说的下一行哦～～～～～，if下一行有echo那么就  
      换成ooo，if没哟就算了！！！  
       
30.       转换( y)       
      sed   \-e   '1,10y/abcde/ABCDE/'ping.sh  
      注意格式：y和后面的/之间不可以有空格哟～  
      功能：将所有指定的小写字母换成了对应的答谢字母，当然你自己可以设置随便怎么替  
      换，随便怎么对应，just do it！  
       
31.       退出( q)       
       sed -e '5q'ping.sh                                                  打印5行后退出  
       sed -e'/echo/\{s/echo/oooo/;q;\}ping.sh            匹配后换，再退出！  
    某行匹配到echo时，先用oooo替换echo，然后立即退出       
       
32.       暂存和取用(h和G )       
       h:就是保存当前模式到一个缓冲区  
      G:取出保存的模式  
       sed -e'/echo/ \{ h;d; \}' -e '/judge/ G' ping.sh  
       
      相当注意：一个文件中可以有多个echo的匹配的行，那么他们的保存是按照“栈”的形式  
      保存的！！就是说，if现在匹配的行的书目比较多，而judge的数量比较少，那么按照“先  
      进后出”的原则来进行替换的哦哦 ～   而且注意由于有一个d;所以所有有echo的行都被  
       删除了！！！  
       
      注意不可以改成  
       sed -n -e'/echo/ \{ h;d; \}' -e '/judge/ G' ping.sh  
      那么我将看不到任何内容  
      因为-n只是匹配当前行，而当前行有被删除了，所以就是空白的！你可以将d去掉看看  
      之后会看到所有匹配的行！！！  
       
       我们前面有一串代码是(类似与tac )：sed -e '1!G;h;$!d' ping.sh > 1  
       
       
33.      暂存和互换命令       ( h 和x )  
       sed -e'/\{/h' -e '/\}/x' ping.sh > 1  
       
       
34.      在每一行后面增加一空行  
           sed G  
       
      将原来的空行删除再在每行后面增加一个空行，那么每一行后面就只有一个空行！  
       sed '\{/^$/d;G; \}' ping.sh   |   sed -n -e'/^$/p'   |   wc -l  
       
      上面代码的意思就是先删除所有的空行，然后每行后面增加一个空行，然后输出的结果  
      输出空行的行数  
       
      2的延伸：在每一行后面增加两行空行  
                           sed'\{G;G\}'  
       
35.       sed'n;d'  
      看看这条指令：意思就是删除每行的下一行  
      我们可以这样测试：  
       sed -e'\{/^$/d; G;\}' ping.sh   |   sed '\{n; d; \}'  
      如果没有错的话，那么就会最终没有空行，因为后面的sed '\{ n; d; \}'就是走到下一行  
      再删除，因为是“有空没空”镶嵌的，所以最终所有空行被删除，呵呵俄～  
       
       
36.      在匹配的行之前加入一个空行：  
       sed -e'/judge/ \{ x;p;x; \}'   ping.sh       
      解释：我们知道x的作用是将当前行和暂存缓冲区中的内容(也就是前面使用G取出的内  
      容)交换，由于初始化的时候是空的，所以执行了第一个x后judge行变成空行，而原本  
      的被换到暂存区，然后执行p也就是当前行，那么就是多了一个空行，然后在x，就是将  
      暂存区的内容再换回来，所以最后就多了一行，:-) ～  
       
      在匹配行之后加入一个空行：  
       sed -e'/judge/G'  ping.sh                   \#这个好理解  
       
      那么我们知道在前后各插入一行就是1和2的组合咯！  
       sed -e'/judge/ \{ x;p;x;G; \}' ping.sh  
       
37.      关于给行的编号：  
      我们在前面已经知道=可以达到效果，但是你测试一下是你希望的吗？好像不是吧，呵  
       呵～  
       sed =ping.sh  
       
       改进：  
       sed =ping.sh | sed -e'\{N;s/\\n/          /\}'  
       或者  
       sed =ping.sh | sed 'N;s/^/        /; s/ \*\$.\\\{6,\\\}\$\\n/\\1   /'  
       
      下面接着改进，只显示有内容的行的行号  
       sed -e'/./='   ping.sh  |   sed   \-e'/./N;s/\\n/      /'  
      就是前面对于=的选择进行处理，后面对于N的处理也是建立在有内容的行！  
       
38.      计算行数，模拟wc  
       sed -n '$='ping.sh  
      解释：其实是一个凑巧的做法：原理是sed -n '=' ping.sh 是输出所有的行的行号  
                  但是有了$就是只取最后一个，显然是行的数目咯～呵呵～  
       
39.      将每一行前导的“空白字符”（空格，制表符）删除：  
         使之左对齐  
       sed 's/^\[\\t\]\*//' ping.sh  
       
      将每一行拖尾的“空白字符”（空格，制表符）删除：  
       注意：  
       sed -e 's/\[\\t\]$//' ping.sh  
       和  
       sed -e 's/\[\\t\]\*$//'ping.sh                   \#上面的if有多个空格，那么只能删除一个然后剩下的  
                                                                   \#空格就不会删除！  
      的区别！                                                 
       
      那么删除前导和后缀空格和tap就是：  
       sed -e'\{s/^\[ \\t\]\*//;s/\[ \\t\]\*$//\}'  
       
40.      在每一行开头处插入5个空格（使全文向右移动5个字符的位置）  
       
      按照前面的命令，我们知道这样是可以的：  
       sed -e's/.\*/        &/'ping.sh        \# 就是对于每行的操作！YES。。。  
       或者  
       sed's/^/        /'  
       
       
41.      以79个字符为宽度，将所有文本右对齐  
         sed -e :a -e's/^.\\\{1,78\\\}$/ &/;ta'   \#78个字符外加最后的一个空格       
       
      首先我们需要知道“标签的使用”  
       就是形如：sed :aXXXX 'ta'ping.sh       \#注意只能是a作为标签，本意是“添加”作用  
      如果仅仅是执行这个代码，那么就是对于每行处理XXXX  
       
      那么再看看's/^.\\\{1,78\\\}$/ &/这是什么  
      这个很简单：就是从行头开始增加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       
       
       
42.      只替换每行的第一个echo表示法：  
       sed -e's/echo/ooooooo/' ping.sh  
       或者：  
       sed -e's/echo/ooooooo/1' ping.sh  
       
      只替换每行的第二个echo  
       sed -e's/echo/ooooooo/2'ping.sh       
       
      替换最后一个“echo”  
       sed's/\$.\*\$echo/\\1ooo/'                               
       
      替换倒数第二个“echo”  
       sed's/\$.\*\$echo\$.\*echo\$/\\1 ooo\\2/'             
  
      只在行中出现字串“baz”的情况下将“echo”替换成“ooo”  
       sed'/baz/s/echo/ooo/g'  
  
      将“echo”替换成“ooo”，并且只在行中未出现字串“baz”的情况下替换  
       sed'/baz/!s/echo/ooo/g'  
  
      替换每行最后一个echo和第一个judge为ooo  
       sed -e's/\$.\*\$echo/ooo/; s/judge/ooo/'   ping.sh  
       在GNU sed中也可以使用：  
       sed -e's/echo\\|judge/ooo/g'ping.sh             \# 使用\\|  
  
43.      将行中的字符逆序排列，第一个字成为最后一字，……（模拟“rev”）  
        sed '/\\n/!G;s/\$.\$\$.\*\\n\$/&\\2\\1/;//D;s/.//'  
       
       
44.      将每两行连接成一行（类似“paste”）  
       sed'$!N;s/\\n/ /'                                           
                                                       \#那么我们知道哦$!要不要其实没有太大的影响  
      要理解这一句那么我们要知道N的意思：      \#主要是为了本操作不影响其他的文本内容       
      man中的解释：  
       nN       Read/appendthe next line of input into the pattern space.  
       
      那么我们知道：只要不是结尾那么就读取下一行到当前的空间，  
                                每行的结束\\n使用空格代替，所以就很好理解了～       
       
45.      如果当前行以反斜杠“\\”结束，则将下一行并到当前行末尾  
      并去掉原来行尾的反斜杠             
       
       第一种：       sed -e'/\\\\$/ \{ N; s/\\n/ /; s/\\\\// \}' ping.sh > 1  
      解释：      /\\\\$/：是找到结尾是\\的行  
                          N       ：         将下一行的内容链接到本行  
                          s/\\n/ /：将本行的\\n换成 ‘ ’  
                        s/\\\\//：将\\删除  
       
      第二种：       sed -e:a -e '/\\\\$/N; s/\\\\\\n//; ta' ping.sh > 1  
                        本质是一样的就不解释了！  
       
46.      如果当前行以等号开头，将当前行并到上一行末尾( !!! )  
        并以单个空格代替原来行头的“=”  
        sed -e :a -e '$!N;s/\\n=/ /;ta' -e 'P;D' ping.sh >1  
       
47.      为数字字串增加逗号分隔符号，将“1234567”改为“1,234,567”       
      说的更清楚一点就从右向左开始以3数字为一组加上‘，’～～～  
       
      我们要回顾一下前面的所谓的标签，其实本质是循环  
       
       sed -e :a'XXXX;ta;'ping.sh             \#命令的循环直到条件不满足  
      还要知道3个怎么表示，例如3个数字：/\[0-9\]\\\{3\\\}/            yes，就是这样  
       
       所以：sed -e :a-e 's/\$.\*\[0-9\]\$\$\[0-9\]\\\{3\\\}\$/\\1,\\2/;ta;'  ping.sh > 1  
       解释：:a...   ta; 之间类似与一个循环直到条件结束  
                  \$.\*\[0-9\]\$\$\[0-9\]\\\{3\\\}\$:意思是任意个数字串+3个数字串的组合，每次处理3个  
                  \\1,\\2：就是增加‘，’的处理呗～  
       
       注意： gsed':a;s/\\B\[0-9\]\\\{3\\\}\\>/,&/;ta'      \# GNU 可以这样处理  
       
48.      在每5行后增加一空白行 （在第5，10，15，20，等行后增加一空白行）  
        gsed '0~5G'   ping.sh >1                                               \# 只对GNUsed有效  
        sed 'n;n;n;n;G;' ping.sh >1                                             \#其他sed  
       
49.      显示文件中的前10行 （模拟“head”的行为）  
        我们有自己的最古老的办法：  
        sed -n -e '1,10p' ping.sh  
        新的方法：  
        sed 10q      ping.sh  
         
        显示文件中的第一行 （模拟“head -1”命令）  
       sed -n -e'1p' ping.sh  
       或者  
       sed qping.sh  
       
50.      显示文件中的最后10行 （模拟“tail”）  
        sed -e :a -e '$q;N;11,$D;ba'  
         
        显示文件中的最后2行（模拟“tail -2”命令）  
        sed '$!N;$!D'  
      解释：前面的行我们都知道很easy的被删除，因为D是删除空间第一行  
      所以前面的被一一删除，那么到了倒数第二行的时候，依旧会N，所以到了  
      最后一行，那么后面一个指令显然此时是在最后一行，那么就不会执行D，  
      那么我们也知道现在模式空间就只有2行，按照原理都不会删除，所以  
      最终剩下2行!  
       
        显示文件中的最后一行（模拟“tail -1”）  
        sed'$!d'                            \# 本质就是：最后一行不删除，其余的在暂存  
                                              \# 空间删除，所以最后就打印了最后一行  
        sed -n'$p'                      \# 本质就是最后一行打印( -n：所以只打印相应行 )  
       
       
      到这里是应该要说说-d和-D的区别了！！！  
      \-d：删除当前行  
      \-D：仅删除模式空间的第一行  
       
51.      倒置所有行，第一行成为最后一行，依次类推（模拟“tac”）。  
      由于某些原因，使用下面命令时HHsed v1.5会将文件中的空行删除  
       sed'1!G;h;$!d'                                   \# 方法1  
       
       \#解释：首先是入栈和删除阶段，由于还没有入栈完全的时候肯定都是在  
                     第一行，所以入栈全部OK之前第一行是不会执行的！第二行都执行  
                     然后删除第一行，所以第二行又成为第一行，直到模式空间为空，  
                     那么就不是第一行了，所以第一个命令开始执行，而且此后都是指向  
                     最后一行，所以第一个指令不断执行，直到暂存空间为空！然后后面的  
                     删除命令由于是最后一行，没有内容了，所以结束。。。  
       
       sed -n'1!G;h;$p'                               \#方法2       
       
52.      显示文件中的倒数第二行  
        sed -e '$!\{h;d;\}' -ex                          \# 当文件中只有一行时，输入空行  
        sed -e '1\{$q;\}' -e '$!\{h;d;\}' -e x   \#当文件中只有一行时，显示该行  
        sed -e '1\{$d;\}' -e '$!\{h;d;\}' -e x   \#当文件中只有一行时，不输出  
  
53.      只显示匹配正则表达式的行（模拟“grep”）  
        sed -n'/regexp/p'                            \# 方法1  
        sed'/regexp/!d'                                \# 方法2  
         
      只显示“不”匹配正则表达式的行（模拟“grep -v”）  
       sed -n'/regexp/!p'                          \# 方法1，与前面的命令相对应  
       sed'/regexp/d'                                  \# 方法2，类似的语法  
   
54.      查找“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  
       
55.      显示包含“echo”或“judge”行（任意次序）  
       sed -n -e'/echo/p; /judge/p' ping.sh > 1  
       或  
       sed -e'/echo!d/; /judge/!d' ping.sh > 1  
       
      显示包含“AAA”、“BBB”和“CCC”的行（固定次序）  
       sed -n -e'/AAA.\*BBB.\*CCC.\*/p' ping.sh   >1  
       
      显示包含“AAA”“BBB”或“CCC”的行（模拟“egrep”）       
       sed -e'/AAA/b' -e '/BBB/b' -e '/CCC/b' -ed             \#多数sed  
      解释：相当于是遇到指定的字符串就back了，然后执行下一行，那么只要是有  
                  相应字符串的行就不会被删除！  
       gsed'/AAA\\|BBB\\|CCC/!d'                                                           \# 对GNUsed有效  
       
56.      显示包含“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有效  
  
57.      显示包含65个或以上字符的行  
       sed -n -e'/^.\\\{65\\\}/' ping.sh > 1  
       
      显示包含65个以下字符的行  
       sed -n -e'/^.\\\{65\\\}/!p' ping.sh > 1  
       or  
       sed -e'/^.\\\{65\\\}/d' ping.sh > 1  
       
58.      显示部分文本——从包含正则表达式的行开始到最后一行结束  
       sed -n -e'/XXX/, $ p' ping.sh >1       
       
      显示部分文本——指定行号范围（从第8至第12行，含8和12行）  
       sed -n -e'8,12 p' ping.sh > 1  
       sed =ping.sh | sed -e '\{N;s/\\n/   /\}' | sed -n -e '8,12p'     \# 此处增加显示行号  
       
      显示两个正则表达式之间的文本（包含）  
       sed -n'/echo/,/judge/p' >ping.sh            \# 区分大小写方式  
       
59.      显示第52行  
        sed -n'52p'                                        \# 方法1  
       sed'52!d'                                            \# 方法2  
        sed'52q;d'                                          \# 方法3,处理大文件时更有效率       
       
       
60.      从第3行开始，每7行显示一次     
       gsed -n'3~7p'                                    \# 只对GNU sed有效  
       sed -n'3,$\{p;n;n;n;n;n;n;\}'        \# 其他sed       
       
61.      删除文件中相邻的重复行（模拟“uniq”）  
      只保留重复行中的第一行，其他行删除  
       sed '$!N;/^\$.\*\$\\n\\1$/!P;D'       
      解释：每次都要先与下一行进行比较，主要是理解中间一段指令的意思！  
                  就是从本行开始取串，以\\n为分割标志！理论上就是唯一的一行！  
                  然后后面的\\1$就是说，如果与此行相同，那么必然是\\1后就是结尾了！  
                  那么就相当于是与上一行的重复，所以不打印！   D总是删除空间的  
                  第一行，所以执行到最后就OK 。。。  
  
62.      删除文件中的重复行，不管有无相邻。注意hold space所能支持的缓存大小，  
       或者使用GNUsed。  
       sed -n 'G;s/\\n/&&/; /^\$\[ -~\]\*\\n\$.\*\\n\\1/d;s/\\n//; h;P'       
       
63.      删除除重复行外的所有行（模拟“uniq -d”）  
       sed '$!N;s/^\$.\*\$\\n\\1$/\\1/; t; D'  
  
64.      删除8的倍数行  
       sed'n;n;n;n;n;n;n;n;d' ping.sh > 1  
       or  
       GNU: gsed'0~8d' ping,sh > 1  
       
      但是要注意的是不是：  
       sed'N;N;N;N;N;N;N;N;d' ping,sh > 1  
       
      主要是理解n和N的区别：  
      n：      是将当前的焦点行设置为下一行，那么就是真正的移向下一行  
      N：      是将下一行load到当前行！也就是说现在的两行是相当于一行的操作！  
       if 是sed'N;N;N;N;N;N;N;N;d' ping,sh >1操作，那么就是相当于是搜索到有8行  
      就一起删除！if没有8行了剩下的就剩下了！！！所以特别注意哦～！！！  
       
65.      删除文件中的所有空行（与“grep '.' ”效果相同）  
       sed'/^$/d'                                                         \# 方法1  
       sed'/./!d'                                                                 \#方法2       
       
66.      只保留多个相邻空行的第一行。并且删除文件顶部和尾部的空行。（模拟“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;\}'  
   
67.      一些优化：  
       sed -e'/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d  
       好消息是GNUsed能让命令更紧凑：  
        sed'/AAA/b;/BBB/b;/CCC/b;d'          \# 甚至可以写成  
         sed'/AAA\\|BBB\\|CCC/b;d'  
       
        速度优化：当由于某种原因（比如输入文件较大、处理器或硬盘较慢等）需要提高  
        命令执行速度时，可以考虑在替换命令（“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            \# 一样，但快得多       
       
       感谢（EricPement）,感谢其他网友的支持！