Chinaunix首页 | 论坛 | 博客

whanwhan.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

whan

  • 博客访问： 7932127
  • 博文数量： 124
  • 博客积分： 2880
  • 博客等级： 少校
  • 技术积分： 873
  • 用 户 组： 普通用户
  • 注册时间： 2009-09-16 17:08
文章分类

全部博文（124）

文章存档

2011年（28）

2010年（60）

2009年（36）

我的朋友
最近访客
推荐博文
文本编辑的一点心得--sed

分类：

2010-08-10 17:08:47

在shell版混了3年多了，文本编辑方面小有心得，写出来与大家分享，黑哥等一笑而过。

读本文之前，需要对sed有一定了解，最好看过sed1line：


本文所有用例的测试环境采用unix-center的ubuntu服务器


具体版本如下：
  1. ly5066113@ubuntu:~$ uname -a
  2. Linux ubuntu 2.6.24-22-generic #1 SMP Mon Nov 24 19:35:06 UTC 2008 x86_64 GNU/Linux
  3. ly5066113@ubuntu:~$ bash --version
  4. GNU bash, version 3.2.39(1)-release (x86_64-pc-linux-gnu)
  5. Copyright (C) 2007 Free Software Foundation, Inc.
  6. ly5066113@ubuntu:~$ sed --version
  7. GNU sed version 4.1.5
  8. Copyright (C) 2003 Free Software Foundation, Inc.
  9. This is free software; see the source for copying conditions.  There is NO
  10. warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE,
  11. to the extent permitted by law.
复制代码
下面结合实例介绍sed应用的几个方面。

一、标签

        b label ,无条件跳转到标签label,如果label没有指定,跳转到命令的结尾
        t label ,如果最后一次输入的最后一个 s/// 子命令执行成功,跳转到标签label,如果label没有指定,跳转到命令的结尾

        例1: 用标签完成 是AA就加上YES,不是AA就加NO
       

        使用t命令：
  1. ly5066113@ubuntu:~$ cat urfile
  2. AA
  3. BC
  4. AA
  5. CB
  6. CC
  7. AA
  8. ly5066113@ubuntu:~$ sed '/^AA/s/$/ YES/;t;s/$/ NO/' urfile
  9. AA YES
  10. BC NO
  11. AA YES
  12. CB NO
  13. CC NO
  14. AA YES
复制代码
如果是AA，执行s/$/ YES/，s命令执行成功，执行t命令，没有标签，跳转到命令的结尾，这样将会跳过后面的s/$/ NO/
        如果不是AA，s/$/ YES/不执行，则t命令也不执行，只执行后面的s/$/ NO/

        使用b命令：
  1. ly5066113@ubuntu:~$ sed '/^AA/ba;s/$/ NO/;b;:a;s/$/ YES/' urfile
  2. AA YES
  3. BC NO
  4. AA YES
  5. CB NO
  6. CC NO
  7. AA YES
复制代码
如果是AA，执行ba，跳转到标签a处，这样会跳过中间的s/$/ NO/;b，只执行后面的s/$/ YES/
        如果不是AA，ba不执行，执行s/$/ NO/，执行b，没有标签，跳转到命令的结尾，这样将会跳过后面的s/$/ YES/


        例2: 合并行：
       
  1. ly5066113@ubuntu:~$ cat urfile
  2. 114.113.144.2:
  3. 19ms
  4. 19ms
  5. 19ms
  6. 36ms
  7. 22ms
  8. 19ms
  9. 18ms
  10. 218.61.204.73:
  11. 0ms
  12. 0ms
  13. 0ms
  14. 0ms
  15. 0ms
  16. 0ms
  17. 0ms
  18. ly5066113@ubuntu:~$ sed ':a;$!N;/ms$/s/\n/ /;ta;P;D' urfile
  19. 114.113.144.2: 19ms 19ms 19ms 36ms 22ms 19ms 18ms
  20. 218.61.204.73: 0ms 0ms 0ms 0ms 0ms 0ms 0ms
复制代码
实现思路：
        1、读入下一行数据
        2、判断是否以ms结尾
        3、如果是，替换\n为空格，跳转到1
        4、如果不是，打印本行数据，删除本行数据，跳转到1
       
        代码实现：
        :a                   #定义标签a
        $!N                  #不是最后一行，执行N命令
        /ms$/s/\n/ /         #如果以ms结尾，将\n替换为空格
        ta                   #如果s///命令执行成功，跳转到标签a处
        P                    #打印pattern space的第一行
        D                    #删除pattern space的第一行，循环
       
        此代码是使用sed进行合并行操作的典型代码，对于不同的情况，只需要将/ms$/替换成需要的正则表达式即可，思路上是通用的。


        sed的标签类似于C语言中的goto，cjaizss兄说过，写代码的时候要有状态机的思想，代码只不过是一种实现。
        下面是他用sed写的加法，里面应用了大量的标签，有兴趣可以研究下：
       


二、记数

        sed不同于awk，内部没有数学运算，是否可以实现记数器，答案是肯定的，因为sed是图灵完备的。

        例3：如何替换文中第2次和第4次出现的指定字符串
       
        本例中采用的是这种方案：
  1. sed ':a ; N ; $!ba ;s/root/mmmm/4'
复制代码
但这个方案有2个弊端：
        1、需要将文本一次性读入到pattern space，如果文件很大，是不行的
        2、如果指定字符串在同一行内出现多次，那么这个方法也是不行的
       
        那么是否有其他的替代方案呢？让我们先从简单的开始。
        将文本中第1次出现a的行替换为b
  1. ly5066113@ubuntu:~$ cat urfile
  2. a
  3. a
  4. a
  5. a
  6. a
  7. a
  8. ly5066113@ubuntu:~$ sed '0,/a/{s//b/}' urfile
  9. b
  10. a
  11. a
  12. a
  13. a
  14. a
复制代码
我们可以利用0,/a/这样的地址区间来定位第一次出现a的行。
        好，现在提升难度，将文本中第2次出现a的行替换为b
  1. ly5066113@ubuntu:~$ sed '0,/a/b;s/a/b/;ta;b;:a;n;ba' urfile
  2. a
  3. b
  4. a
  5. a
  6. a
  7. a
复制代码
继续，将文本中第3次出现a的行替换为b
  1. ly5066113@ubuntu:~$ sed '0,/a/b;/a/ba;b;:a;n;s/a/b/;tb;ba;:b;n;bb' urfile
  2. a
  3. a
  4. b
  5. a
  6. a
  7. a
复制代码
利用0,/a/和标签，也实现了，但同时我们发现，随着次数的增加，代码将会变的越来越烦琐

        是时候另辟蹊径了，下面介绍一下我的方法，我为其命名为“打点记数法”
        主要的思路是这样的：
        利用sed的hold space，当遇到匹配行时，向hold space里面“打一个.”，使用 . 的个数来记录匹配的次数
        如果 . 的个数达到了要求，则执行相应的操作
  1. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^.\{3\}$/{x;s/a/b/;b};x}' urfile
  2. a
  3. a
  4. b
  5. a
  6. a
  7. a
  8. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^.\{4\}$/{x;s/a/b/;b};x}' urfile
  9. a
  10. a
  11. a
  12. b
  13. a
  14. a
  15. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^.\{5\}$/{x;s/a/b/;b};x}' urfile
  16. a
  17. a
  18. a
  19. a
  20. b
  21. a
复制代码
我们可以看到，对于次数的增加，我们只需要调整需要匹配的数值即可。
        /a/{                 #匹配时，开始记数
                x                #交换pattern space与hold space
                s/^/./           #向hold space打一个 .
                /^.\{3\}$/{      #判断 . 的个数是否达到要求
                        x            #如果达到要求，交换hold space与pattern space
                        s/a/b/       #进行替换
                        b            #跳转到代码结束
                }                #
                x                #交换hold space与pattern space
        }                    #


        接下来我们看看“打点记数法”的另一种应用：
        例4：提取函数
       
  1. ly5066113@ubuntu:~$ cat urfile
  2. void
  3. foo(int a, int b) {
  4. //impl. skipped
  5. }


  8. void bigfunction() {
  9. int x1, x2, y1, y2, z1, z2;

  11. // after many lines
  12. bar(); foo (x1, x2);
  13. ly5066113@ubuntu:~$ sed -n 'N
  14. > /foo/{
  15. >         :a
  16. >         /{/{
  17. >                 x
  18. >                 s/^/./
  19. >                 x
  20. >         }
  21. >         /}/{
  22. >                 x
  23. >                 s/.//
  24. >                 /^$/{
  25. >                         x
  26. >                         p
  27. >                         q
  28. >                 }
  29. >                 x
  30. >         }
  31. >         p
  32. >         n
  33. >         ba
  34. > }
  35. > D' urfile
  36. void
  37. foo(int a, int b) {
  38. //impl. skipped
  39. }
复制代码
此代码的主要思路，就是我在原贴中的回复：
        当匹配 { 时，x;s/^/./;x ，向hold space里面放一个 .
        当匹配 } 时，x;s/.//;x ，将hold space里的 . 去掉一个
        就这样，当hold space再次为空时，就表示所有的 { 和 } 都配对了


三、lookup table

        在讲lookup table技术之前，先讲一下“回溯引用”
        回溯引用对于大家来说并不陌生，会经常用于 s/REGEXP/REPLACEMENT/ 中REPLACEMENT部分
        但回溯引用并不是只能用于REPLACEMENT部分，在REGEXP中也是可以使用的。
       
        例5：找出100以内，个位与十位相同的2位数
  1. ly5066113@ubuntu:~$ seq 100 | sed -n '/^\(.\)\1$/p'
  2. 11
  3. 22
  4. 33
  5. 44
  6. 55
  7. 66
  8. 77
  9. 88
  10. 99
复制代码
我们可以看到，这个问题利用回溯引用很容易解决。
        \1表示前面\(.\)中内容，换种说法就是\1与前面\(.\)是相同的，那么就是个位与十位相同了


        在理解了REGEXP中的回溯引用之后，我们来看看lookup table技术
        lookup table就是回溯引用的方式进行前后定位，然后取出我们需要内容

        例6： AIX下怎么用DATE取上月的月份
       
        UNIX下一般都没有GNU date，即便有GNU date，在某些时间点(如3月31号)上进行取上月操作(-1 month)的时候也有问题
  1. ly5066113@ubuntu:~$ date +%m
  2. 08
  3. ly5066113@ubuntu:~$ date +%m | sed 's/$/b12a01a02a03a04a05a06a07a08a09a10a11a12/;s/^\(..\)b.*\(..\)a\1.*/\2/'
  4. 07
复制代码
我们来看看这段代码是如何工作的：
        1、构造一个列表，字母a左边的2位数字是右边2位数字的上一个月
        2、利用lookup table取出上一个月

        pattern space初始为：
        08
        第一个s命令处理后pattern space变为：
        08b12a01a02a03a04a05a06a07a08a09a10a11a12
        下面我们重点来看看第二个s命令是怎么工作的：
        s/^\(..\)b.*\(..\)a\1.*/\2/
        将pattern space里面的内容按照上面的正则表达式进行分解
        ^\(..\)              08
        b.*                  b12a01a02a03a04a05a06a
        \(..\)               07
        a\1                  a08
        .*                   a09a10a11a12
        整个过程就是通过第一个括号里面的内容 08 ，定位到后面的 a08 ，从而取出它前面的2位数字 07 ，也就是第二个括号里的内容 \2
        这种方法就称之为 lookup table


        例7：文本处理
       
  1. ly5066113@ubuntu:~$ cat urfile
  2. 172.27.38.0&1=99&2=100
  3. 192.168.9.2&1=100&3=111
  4. 202.96.64.68&1=99&2=1&3=111
  5. 202.96.69.38&1=99&3=111&4=110
  6. 202.77.88.99&1=99&2=111&3=66&4=100&5=44
  7. ly5066113@ubuntu:~$ sed -r 's/&/\n1\n2\n3\n4\n5&/;:a;s/\n(.)(.*)&\1=([^&]+)/\t\3\2/;ta;s/\n./\t0/g' urfile
  8. 172.27.38.0     99      100     0       0       0
  9. 192.168.9.2     100     0       111     0       0
  10. 202.96.64.68    99      1       111     0       0
  11. 202.96.69.38    99      0       111     110     0
  12. 202.77.88.99    99      111     66      100     44
复制代码
整体思路，用原贴中dream3401的描述：
        1、产生1,2,3,4,5的"坐标"
        2、对每天"有坐标的赋值"中的值代入坐标
        3、对没有"赋值的坐标"代入0

        我们以第一行数据为例，看看这段代码是怎么工作的：
        pattern space初始为：
        172.27.38.0&1=99&2=100
        s/&/\n1\n2\n3\n4\n5&/后：
        172.27.38.0\n1\n2\n3\n4\n5&1=99&2=100
        s/\n(.)(.*)&\1=([^&]+)/\t\3\2/后：
        172.27.38.0     99\n2\n3\n4\n5&2=100
        s命令执行成功，t命令执行，跳转到标签a处，再次执行s/\n(.)(.*)&\1=([^&]+)/\t\3\2/：
        172.27.38.0     99      100\n3\n4\n5
        s命令执行成功，t命令执行，跳转到标签a处，再次执行s/\n(.)(.*)&\1=([^&]+)/\t\3\2/，s命令执行失败，无替换
        t命令不执行，执行s/\n./\t0/g：
        172.27.38.0     99      100     0       0       0

        对于以上步骤，第一个s命令和最后一个s命令都不难理解，关键是中间的这句：
        s/\n(.)(.*)&\1=([^&]+)/\t\3\2/
        那我们以第一次的执行为例，将pattern space里面的内容按照上面的正则表达式进行分解
        \n(.)                \n1
        (.*)                 \n2\n3\n4\n5
        &\1=                 &1=
        ([^&]+)              99
        利用第一个括号的数字1，定位到后面&1=中的数字1，从而取出=号后面的数字99
        172.27.38.0                \n1\n2\n3\n4\n5&1=99                &2=100
        172.27.38.0     99\n2\n3\n4\n5                                &2=100
        此正则表达式在工作的过程中，开头的 172.27.38.0 和结尾的 &2=100 都是没有处理的，处理的只是中间的一部分


        例7和例6虽然都是用的lookup table技术，但思路梢有不同。
        例6是构造一个列表，然后从列表中lookup出想要的值
        例7也是构造一个列表，但是将外面的值填充到列表中
        无论是那种方式，lookup table技术的基本做法都是先构造一个列表，然后用回溯引用定位，从而得到我们需要的值


四、GNU拓展

        最后，介绍几个GNU sed的拓展功能，个人认为比较实用：
       
        1、\U \L \u \l
        大小写转换
  1. ly5066113@ubuntu:~$ echo 'abc' | sed 's/.*/\U&/'
  2. ABC
  3. ly5066113@ubuntu:~$ echo 'abc' | sed 's/.*/\u&/'
  4. Abc
  5. ly5066113@ubuntu:~$ echo 'ABC' | sed 's/.*/\L&/'
  6. abc
  7. ly5066113@ubuntu:~$ echo 'ABC' | sed 's/.*/\l&/'
  8. aBC
复制代码
2、/REGEXP/I
        正则匹配忽略大小写
  1. ly5066113@ubuntu:~$ echo 'AbC' | sed -n '/abc/Ip'
  2. AbC
复制代码
3、FIRST~STEP
        取出奇数行或者偶数行
  1. ly5066113@ubuntu:~$ seq 10 | sed '0~2d'
  2. 1
  3. 3
  4. 5
  5. 7
  6. 9
  7. ly5066113@ubuntu:~$ seq 10 | sed '1~2d'
  8. 2
  9. 4
  10. 6
  11. 8
复制代码
每5行合并成1行，类似 xargs -n5
  1. ly5066113@ubuntu:~$ seq 20 | xargs -n5
  2. 1 2 3 4 5
  3. 6 7 8 9 10
  4. 11 12 13 14 15
  5. 16 17 18 19 20
  6. ly5066113@ubuntu:~$ seq 20 | sed ':a;N;s/\n/ /;0~5b;ba'
  7. 1 2 3 4 5
  8. 6 7 8 9 10
  9. 11 12 13 14 15
  10. 16 17 18 19 20
复制代码
4、\%REGEXP%
        进行路径匹配时，使用此方法，可以剩去很多转义符\
  1. 16 17 18 19 20
  2. ly5066113@ubuntu:~$ echo 'a/b/c/d/e/f' | sed -n '/a\/b\/c\/d/p'
  3. a/b/c/d/e/f
  4. ly5066113@ubuntu:~$ echo 'a/b/c/d/e/f' | sed -n '\%a/b/c/d%p'
  5. a/b/c/d/e/f
复制代码
5、ADDR1,+N
        地址 +行数，可以实现类似 grep -A N 的功能
  1. ly5066113@ubuntu:~$ seq 10 | grep -A2 '5'
  2. 5
  3. 6
  4. 7
  5. ly5066113@ubuntu:~$ seq 10 | sed -n '/5/,+2p'
  6. 5
  7. 6
  8. 7
复制代码
文笔有限，如果有描述不清的地方请大家见谅。希望本文会对大家学习sed有所帮助。




        关于sed记数，补充2个例子，均来自info sed中的examples(略有改动)

        例8：实现 awk '{print NR,$0}' 的功能
  1. ly5066113@ubuntu:~$ head sed.info | awk '{print NR,$0}'
  2. 1 File: sed.info,  Node: Top,  Next: Introduction,  Up: (dir)
  3. 2
  4. 3 sed, a stream editor
  5. 4 ********************
  6. 5
  7. 6 This file documents version 4.1.5 of GNU `sed', a stream editor.
  8. 7
  9. 8    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004 Free Software
  10. 9 Foundation, Inc.
  11. 10
  12. ly5066113@ubuntu:~$ head sed.info | sed -nf test.sed
  13. 1 File: sed.info,  Node: Top,  Next: Introduction,  Up: (dir)
  14. 2
  15. 3 sed, a stream editor
  16. 4 ********************
  17. 5
  18. 6 This file documents version 4.1.5 of GNU `sed', a stream editor.
  19. 7
  20. 8    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004 Free Software
  21. 9 Foundation, Inc.
  22. 10
  23. ly5066113@ubuntu:~$ cat test.sed
  24. #! /usr/bin/sed -f
  25. x
  26. 1s/^/1/
  27. G
  28. s/\n/ /p
  29. s/ .*//
  30. /^9*$/s/^/0/
  31. s/.9*$/x&/
  32. h
  33. s/.*x//
  34. y/0123456789/1234567890/
  35. x
  36. s/x.*//
  37. G
  38. s/\n//
  39. h
复制代码
x                              #交换pattern space与hold space，保存读入的内容
        1s/^/1/                        #如果是第一行，初始化行号1
        G                              #将保存的内容追加回pattern space
        s/\n/ /p                       #将换行替换为空格，并打印
        s/ .*//                        #去处空格以后的所有内容，pattern space只剩下行号
        /^9*$/s/^/0/                   #如果行号都为9，在前面补0
        s/.9*$/x&/                     #用x分隔不需要改变和需要改变的数字
        h                              #将pattern space中的内容保存到hold space
        s/.*x//                        #删除不需要改变的数字
        y/0123456789/1234567890/       #对数字进行 +1 的操作
        x                              #交换pattern space与hold space
        s/x.*//                        #删除需要改变的数字
        G                              #将改变后的数字追加回pattern space
        s/\n//                         #删除换行，得到新的行号
        h                              #保存新行号到hold space

        整体的思路：
        每读入一行记录，将保存在hold space中的行号(如果是第一行，需要初始化)，和本行记录合并输出
        然后将行号 +1 ，保存至hold space

        代码的核心部分就是实现“行号 +1”，具体做法：
        将行号分为2个部分，一部分保持不变(此部分可能没有)，一部分进行改变，然后将需要改变的部分进行处理
        将处理后的结果与前面不变的部分拼接在一起，形成新的行号，但这里有个情况需要考虑，就是进位
        我们已实际的例子来看看
        如果行号是 123
        那么首先将其分成2个部分变为  12x3
        x左边的12不需要改变，x右边的3需要变成4
        那么就对3进行y/0123456789/1234567890/的操作，将其变成4
        然后拼上前面的12变为 124
        如果行号是129(需要进位)
        那么首先将其分成2个部分变为  1x29
        x左边的1不需要改变，x右边的29需要变成30
        那么就对29进行y/0123456789/1234567890/的操作，将其变成30
        然后拼上前面的1变为 130
        这里面有个特殊情况需要考虑，就是如果行号都为9
        9， 99， 999 之类的情况，那么我们需要在前面加数字0用做进位用

        例9：实现 wc -c 的功能
  1. ly5066113@ubuntu:~$ wc -c urfile
  2. 254 urfile
  3. ly5066113@ubuntu:~$ sed -nf test.sed urfile
  4. 254
  5. ly5066113@ubuntu:~$ cat test.sed
  6. #! /usr/bin/sed -f
  7. s/./a/g
  8. H
  9. x
  10. s/\n/a/
  11. : a;  s/aaaaaaaaaa/b/g; t b; b done
  12. : b;  s/bbbbbbbbbb/c/g; t c; b done
  13. : c;  s/cccccccccc/d/g; t d; b done
  14. : d;  s/dddddddddd/e/g; t e; b done
  15. : e;  s/eeeeeeeeee/f/g; t f; b done
  16. : f;  s/ffffffffff/g/g; t g; b done
  17. : g;  s/gggggggggg/h/g; t h; b done
  18. : h;  s/hhhhhhhhhh//g
  19. : done
  20. $! {
  21.         h
  22.         b
  23. }
  24. : loop
  25. /a/! s/[b-h]*/&0/
  26. s/aaaaaaaaa/9/
  27. s/aaaaaaaa/8/
  28. s/aaaaaaa/7/
  29. s/aaaaaa/6/
  30. s/aaaaa/5/
  31. s/aaaa/4/
  32. s/aaa/3/
  33. s/aa/2/
  34. s/a/1/
  35. y/bcdefgh/abcdefg/
  36. /[a-h]/ b loop
  37. p
复制代码
此段代码虽然看起来烦琐，但思路却比上一例好理解。
        每读一行数据，将里面所有的字符都替换成字母a，因为sed读数据时会将换行符(\n)去掉
        所以我们利用H命令产生的\n将其补充回来，也替换成字母a，统一做字符统计
        为了节省内存开销，提高效率，这里做了进位的处理，就是将10个a替换成1个b，10个b替换成1个c 。。。
        这样到最后，字母a的个数就代表个位数字，字母b的个数就代表十位数字，字母c的个数代表百位数字。。。
        如果最后剩下是这样一串字符：
        ccbbbbbaaaa
        那么就表示总共的字符数为：254
        本段代码的统计是有上限的，如果字符数量超过1亿，将无法得到正确结果
        可以通过增加替换的次数来增加统计上限，如 s/hhhhhhhhhh/i/g ， s/iiiiiiiiii/j/g 。。。
阅读(1567) | 评论(0) | 转发(0) |
0

上一篇：网络进阶：VMware三种网络模式根本区别

下一篇：抛砖引玉----翻译加注sed1line

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6