cat命令

很多时候我们通过cat命令来查看文件内容,它会将文件的所有内容显示出来。当然,cat也可以通过管道接收数据,它主要完成的是将从管道接收的输入导到输出。

more跟less命令

有时候用cat命令来显示一个较大的文件并不方便,整个文件内容一次性显示出来简直就是刷屏了。如果需要一页页的显示内容,可以使用more或者less命令,这两个命令会以分页的形式显示文件内容,至于使用哪个命令完全看个人习惯了。此外,这两个命令不仅可以分页显示,而且在分页模式下,你可以用快捷键方便的浏览及搜索:

1
2
3
4
5
6
* 按`d`下翻页
* 按空格下翻页
* 按回车下移一行
* 按`/`进入搜索模式,输入要搜索的关键字,按回车搜索。
* 按`n`搜索下一个
* 按`q`退出查看

tee命令

tee命令一般从管道接收数据,这点与cat类似,将stdin导到stdout。不同的是,tee同时还可以指定一个文件作为输出。这点非常有用,有时候我们想一般看到命令的输出,同时又希望将输出保存到文件中,这时候用tee最为合适。

1
2
3
4
# date | tee time.log
Mon Nov 20 14:05:02 EST 2017
# cat time.log
Mon Nov 20 14:05:02 EST 2017

date命令

date命令用来显示时间跟时区,比较常见的用法有:

  • 默认显示

    1
    2
    3
    4
    
    # date
    Sun Nov 19 20:08:21 EST 2017
    # date -u
    Mon Nov 20 01:08:28 UTC 2017

    其中,-u参数表示显示UTC标准时间,即时区为0的时间。

  • 指定显示格式

    除了默认输出,我们也可以指定显示的格式:

    1
    2
    
    # date +'%A %d-%m-%Y UTC %:z'
    Sunday 19-11-2017 UTC -05:00

    date支持非常多元化的格式,具体可以参考这里

  • 显示当前时间的秒数

    通常,在计算当前时间的秒数的时候,我们通常会以Unix Epoch Time为基准,用date命令可以非常方便的显示当前时间的秒数:

    1
    2
    3
    4
    
    # date +%s
    1511141040
    # date +%s --date='2017/11/19 09:56:00'
    1511103360

    其中,也可以通过参数--date指定时间来计算。反过来,如果我们知道了时间的秒数,需要显示其相对于Unix Epoch Time的时间,可以这么做:

    1
    2
    3
    4
    5
    
    # date; date +%s
    Mon Nov 20 10:33:07 EST 2017
    1511191987
    # date --date=@1511191987
    Mon Nov 20 10:33:07 EST 2017
  • 时间偏移计算

    有时候需要知道多少天前是什么时间,这时候需要用到时间偏移计算了:

    1
    2
    3
    4
    5
    6
    
    # date --date='100 seconds ago'
    Sun Nov 19 20:35:44 EST 2017
    # date --date='100 hours ago'
    Wed Nov 15 16:37:28 EST 2017
    # date --date='100 days ago'
    Fri Aug 11 21:37:34 EDT 2017

    date命令可以识别多种时间偏移写法,除了示例中的,还有minutes months years等,当然,也可以这样写:

    1
    2
    3
    4
    5
    6
    
    # date --date='+ 1000 seconds'
    Sun Nov 19 20:56:28 EST 2017
    # date --date='- 1000 seconds'
    Sun Nov 19 20:23:41 EST 2017
    # date --date='2017-11-19 00:00:00 + 1000 seconds'
    Sat Nov 18 09:00:01 EST 2017

    直接用+或者-表示以后或者以前的时间,也可以指定某个时间点然后偏移。

  • 设置时间

    当然,你也可以通过date命令来设置时间:

    1
    2
    3
    4
    5
    6
    
    # date
    Sun Nov 19 20:44:11 EST 2017
    # date --set='Sun Nov 19 20:44:30 EST 2017'
    Sun Nov 19 20:44:30 EST 2017
    # date
    Sun Nov 19 20:44:31 EST 2017

    其中--set也可以简写为-s,时间格式非常灵活:

    1
    2
    
    # date -s '2017/11/20 10:19:50'
    Mon Nov 20 10:19:50 EST 2017

cal命令

我们用date可以显示时间,同时咱们还可以通过cal命令来显示日历:

1
2
3
4
5
6
7
8
# cal
    November 2017
Su Mo Tu We Th Fr Sa
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30

当然,你也可以指定要显示的日期,比如1949年10月的日历:

1
2
3
4
5
6
7
8
9
# cal 10 1949
    October 1949
Su Mo Tu We Th Fr Sa
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31

time命令

有时候我们需要知道一个命令运行了多少时间,这时候我们可以用time命令来计时:

1
2
3
4
5
# time sleep 1

real	0m1.018s
user	0m0.001s
sys  	0m0.002s

其中sleep 1用来睡眠1秒,real表示实际用了多少时间,user表示在用户态花了多少时间,sys则表示在内核花了多少时间。详细可以参考这篇问答

wc命令

wc命令是Word Count的简称,顾名思义就是用来统计单词的。

1
2
3
4
# cat test.log
Nov 17 00:27:20 traffic-base1 named[1212]: managed-keys-zone: Unable to fetch DNSKEY set .: timed out
# cat test.log | wc -w
14

参数-w表示统计单词数,这里的单词实际上指的是被空格分开的字符串。下面列举出wc命令的有关参数:

参数 说明
-w 统计多少单词
-l 统计多少行
-c 统计有多少个字节
-m 统计有多少个字符
-L 统计长度最长的行的长度

注意,这里的字节跟字符的差别,在英文中基本上是一样的,但是在多字节语言中,其意义就不一样了:

1
2
3
4
# echo '你好' | wc -c
7
# echo '你好' | wc -m
3

find命令

find命令用来查找文件或目录,这又是一个非常强大的且常用的命令,这里只介绍几种常见的用法:

  • 根据名字查找

    这是基本且常见的用法:

    1
    2
    3
    
    # find . -name "test*"
    ./test.log
    ./test2

    示例中表示在当前目录(用.表示)下包括其子目录,查找文件名以test开头的文件或者目录。默认情况下,find命令是大小写敏感的,如果需要忽略大小写,则可以改用参数-iname

  • 根据路径查找

    -name参数会根据名字查找,如果需要对路径进行匹配查找,则可以用-path参数:

    1
    2
    3
    4
    5
    6
    
    # find . -path "./tmp/*"
    ./tmp/Test1
    ./tmp/test2
    ./tmp/test.log
    ./tmp/test.cpp
    ./tmp/time.log
  • 根据类型查找

    可以根据类型查找文件:

    1
    2
    3
    4
    
    # find . -type f
    ./Test1
    ./test.log
    ./test2

    当然,也可以同时根据类型跟文件名一起查找:

    1
    2
    3
    
    # find . -type f -name "test*"
    ./test.log
    ./test2

    f表示文件,如果是查找目录的话则用d

  • 根据时间查找

    find命令还可以根据时间来查找文件目录,其中一个用法如下:

    1
    
    find . -newer base_file

    表示在当前目录下查找比base_file文件更新的文件或者目录。此外,find还可以根据文件的atime, ctime, mtime来查找文件,如下,根据修改时间来查找:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    
    # date
    Fri Nov 17 20:34:52 EST 2017
    # ll
    total 20
    drwxr-xr-x.  2 root root   45 Nov 17 02:46 ./
    dr-xr-x---. 48 root root 8192 Nov 17 02:46 ../
    -rw-r--r--.  1 root root    0 Nov 16 00:17 Test1
    -rw-r--r--.  1 root root   34 Nov 17 02:46 test2
    -rw-r--r--.  1 root root  102 Nov 17 00:30 test.log
    # find . -mtime -1
    .
    ./test.log
    ./test2

    其中-mtime表示根据修改时间查找,-1表示最近一天。find支持的时间查找总结如下:

    参数 说明
    -mtime 根据修改时间,也就是ls -l显示的时间
    -atime 根据访问时间,也就是ls -lu显示的时间
    -ctime 根据状态改变的时间,也就是ls -lc显示的时间

    时间值的表示说明:基准+0表示一天前,-1.5表示最近1.5天,+1.5表示2.5天前

  • 逻辑查找

    find支持与或非逻辑的查找,比如查找所有C++的源文件,实际上需要找出后缀为.cpp.h的文件,需要用到find的逻辑或的查找:

    1
    
    find . -name "*.cpp" -o -name "*.h"

    其中-o-or的缩写,用来表示逻辑或的关系,而-name "*.cpp"-name "*.h"为表达式,构成了EXP1 or EXP2的关系,只要文件或者目录满足其中一个表达式就会输出。find支持的逻辑关系如下:

    逻辑 参数 说明
    -a -and的缩写,逻辑与的关系,如find . -type f -a -name "*.log"
    -o -or的缩写,逻辑或的关系, 如find . -name "*.cpp" -o -name "*.h"
    ! -not的缩写,逻辑非的关系, 如find . ! -name "*.cpp"

此外,find命令还有一个非常重要且常见的用法,就是在找到文件后执行某个命令,改用法如下:

1
find . -name "*.log" -exec rm {} \;

表示删除当前目录包括子目录中以.log为后缀的所有文件。其中,-exec表示在找到后需要执行命令,而命令为rm {} \;,实际上此命令就是一般的shell命令,其中{}用来指代找到的文件或目录,这里;必须转义,因为需要传递给find本身,如果不转义,则会直接被shell解析使用了。每找到一个文件或目录,都会执行指定的命令,其中{}部分以文件路径替代。如果需要只执行一次命令,而把所有找到的文件作为参数传递给该命令,则需要用+替代\;,如:

1
find . -name "*.log" -exec rm {} +

假定找到的文件有test.logtest1.log,用\;的方式相当于执行两次:rm test.logrm test1.log;如果使用+则只有一次命令rm test.log test1.log

sort命令

顾名思义,这个命令就是用来排序的。

1
2
3
4
5
6
# head -n 5 /etc/passwd | sort
adm❌3:4:adm:/var/adm:/sbin/nologin
bin❌1:1:bin:/bin:/sbin/nologin
daemon❌2:2:daemon:/sbin:/sbin/nologin
lp❌4:7:lp:/var/spool/lpd:/sbin/nologin
root❌0:0:root:/root:/bin/bash

默认情况下,sort命令以字典顺序对每行进行排序,如果不带参数,会将整行作为一个字符串进行比较。当然,你也可以指定以第几列进行排序:

1
2
3
4
5
6
# head -n 5 /etc/passwd | tr : " " | sort -k 3
root x 0 0 root /root /bin/bash
bin x 1 1 bin /bin /sbin/nologin
daemon x 2 2 daemon /sbin /sbin/nologin
adm x 3 4 adm /var/adm /sbin/nologin
lp x 4 7 lp /var/spool/lpd /sbin/nologin

这里先将:换成空格(关于tr命令,请参照本文关于tr命令的章节),然后以-k为参数,指定以第三列进行排序。下面列举其常用的一些参数:

参数 说明
-k 以第几列排序,列以空格为分隔
-r 默认sort以升序输出,-r参数则可以以降序输出
-n 在指定第几列的时候,可以强制sort把列的值以数字值进行排序,如下面的例子
-t 默认情况下认为列是以空格为分隔,-t参数则可以指定分隔符,这样,上面的例子其实可以直接写成sort -t : -k 3
-f 忽略大小写
-u 如果排序后出现重复的行,加上这个参数将只显示一行
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# cat test2
10
3
5
3
# cat test2 | sort
10
3
3
5
# cat test2 | sort -n
3
3
5
10
# cat test2 | sort -n -u
3
5
10

uniq命令

uniqunique的简写,用来消除sort排序后重复的行,即相当于sort命令中的-u参数。但是,uniq不仅可以消除重复行,它还可以显示分别重复了多少行:

1
2
3
4
# cat test2 | sort -n | uniq -c
      2 3
      1 5
      1 10

还有些常用的参数如下:

参数 说明
-i 忽略大小写
-d 只打印有重复的行,每组一个,如果要打印组内所有的,则用-D
-u 只打印没有重复的行
-f 比较的时候,忽略前面的N列
-s 比较的时候,忽略前面的N个字符

od命令

od可以用来显示二进制文件:

1
2
3
4
5
6
# cat test2
abcdefg
1234567
# od -t x1 test2
0000000 61 62 63 64 65 66 67 0a 31 32 33 34 35 36 37 0a
0000020

当然,也可以直接显示字符:

1
2
3
# od -c test2
0000000   a   b   c   d   e   f   g  \n   1   2   3   4   5   6   7  \n
0000020

当然,如果仅仅只是显示二进制内容,还可以使用hexdump命令了。

压缩类命令

tar命令

在Linux中,用的最多的压缩命令就是tar命令了,在介绍其用法之前,需要清楚几个概念:

  • 存档文件(Archive File)

    存档文件用来打包多个文件成一个文件,以方便在网络上传输。请注意,打包成的文件并没有被压缩。在Linux或Unix系统中,TAR文件是最为常用的存档文件(通常以.tar为文件后缀)。TAR文件的更多解释可以参考这里。用tar命令可以生产TAR文件,示例如下:

    1
    
    tar cvf tmp.tar tmp/

    具体参数在下面会具体解释,不带任何压缩格式的话,tar命令会生成一个TAR文件。相应的,如果需要解开TAR文件,可以这么做:

    1
    
    tar xvf tmp.tar
  • 压缩文件(Compressed File)

    TAR文件是没有被压缩的,大小基本保持不变。如果需要对文件进行压缩,则需要在tar命令中加入压缩格式对应的参数,具体在下面会说明。

下面来详细介绍tar命令的用法,tar的用法如下:

1
2
# tar --help
Usage: tar [OPTION...] [FILE]...

tar命令支持非常多的参数,这里列举比较常用的几种使用方式:

  • 压缩文件或目录

    1
    2
    3
    4
    5
    
    # tar czvf tmp.tgz tmp/
    tmp/
    tmp/Test1
    tmp/test.log
    tmp/test2

    其中,czvf表示参数选项;tmp.tgz表示压缩后的文件名,通常tgztar.gz的简写;tmp/表示被压缩的目录。参数的解释如下:

    参数 说明
    c Create的简写,表示生产压缩文件
    z 表示采用gzip的压缩格式,文件后缀通常为.tar.gz或者.tgz
    v 表示显示压缩的过程,会列出所有被压缩的文件
    f 指定压缩文件

    需要注意的是,tar支持不同的压缩格式,除了gzip之外,还有:

    参数 说明
    j 采用bzip2的压缩格式,文件后缀通常为.bz2
    --lzip 采用lzip的压缩格式,文件后缀通常为.lz
    --xz 采用xz的压缩格式,文件后缀通常为.xz
    --lzma 采用lzma的压缩格式,文件后缀通常为.lzma

    更多格式可以参考这里。当然,最为常用的两种格式为gzipbzip2,用法示例如下:

    1
    2
    
    tar czvf tmp.tgz tmp/
    tar cjvf tmp.bz2 tmp/

    其中v参数可选,如果不需要显示压缩过程的话。需要注意的是,tar压缩目录的时候会保持目录的结构。

  • 解压文件

    对应于不同的压缩格式,解压参数稍微不一样,对于gzipbzip2分别示例如下:

    1
    2
    
    tar xzvf tmp.tgz
    tar xjvf tmp.tgz

    与压缩不同,c换成x表示解压,其它参数含义与压缩一样。默认情况下,解压的文件会放在当前目录,如果需要解压到某个目录下,则可以用-C参数:

    1
    2
    
    tar xzvf -C /tmp/ tmp.tgz
    tar xjvf -C /tmp/ tmp.tgz
  • 列出压缩包里面的文件

    有时候我们需要先看看压缩包里面有哪些文件,但又并不想解压文件,可以采用-t参数:

    1
    2
    3
    4
    5
    6
    
    # tar czf tmp.tgz tmp/
    # tar tvf tmp.tgz
    drwxr-xr-x root/root         0 2017-11-17 02:46 tmp/
    -rw-r--r-- root/root         0 2017-11-16 00:17 tmp/Test1
    -rw-r--r-- root/root       102 2017-11-17 00:30 tmp/test.log
    -rw-r--r-- root/root        34 2017-11-17 02:46 tmp/test2

    其中,tvf会列出压缩包中的文件,不论采用何种压缩格式,甚至是没有被压缩的TAR文件。

  • 从压缩包中提取特定的文件

    在列出压缩包里面的内容后,如果只想提取里面的某些文件,可以这么做:

    1
    2
    3
    
    # tar xzvf tmp.tgz tmp/test.log tmp/test2
    tmp/test.log
    tmp/test2

    其中,根据不同的压缩格式请替换成不同的参数。请务必注意,指定的文件必须是完整的路径,而不能只是文件名。

    另外,如果想提取一组匹配某种条件的文件,可以使用--wildcards参数:

    1
    2
    
    # tar xzvf tmp.tgz --wildcards "*.log"
    tmp/test.log

split命令

split命令用来将一个文件分成多个文件,比如将一个特别大的文件分成平均大小为40M的多个文件等。

1
2
3
4
5
# split -b 40M go1.6.linux-amd64.tar.gz go1.6.linux-amd64.tar.gz.part
# ll go1.6.linux-amd64.tar.gz.part*
-rw-r--r--. 1 root root 41943040 Nov 20 15:03 go1.6.linux-amd64.tar.gz.partaa
-rw-r--r--. 1 root root 41943040 Nov 20 15:03 go1.6.linux-amd64.tar.gz.partab
-rw-r--r--. 1 root root   913400 Nov 20 15:03 go1.6.linux-amd64.tar.gz.partac

其中,go1.6.linux-amd64.tar.gz是要被拆分的文件,go1.6.linux-amd64.tar.gz.part是拆分后文件的前缀,可以看到文件被拆分为三部分了。

split非常常见的用法是来将某个被压缩的文件拆分成小的部分,正如上例所示。那么,如何将拆分的文件重新合并呢?我们可以用cat将它们合并:

1
cat go1.6.linux-amd64.tar.gz.part* > go1.6.linux-amd64.tar.gz

grep命令

过滤数据来说,用的最多的估计就是grep命令了,grep命令可以从文件或者管道中搜索数据并打印出来,当然,其也可以直接在目录中搜索所有的文件,并把其中符合条件的行打印出来。

1
2
3
4
5
6
# cat test.log | grep hello
hello
# grep hello test.log
hello
# grep hello . -r
./test.log:hello

上面就是三种方式搜索包括hello关键字的行。

grep是Linux中使用最为频繁的命令之一,其本身也有非常强大的功能,这一节咱们将详细讲述其比较常见的用法。

基本查找

查看grep的帮助可以看到:

1
2
# grep --help
Usage: grep [OPTION]... PATTERN [FILE]...

其中OPTION指的是命令参数,PATTERN指的是匹配的字符串,比如关键字搜索。FILE指的是文件,当然,没有文件的时候也可以通过管道接收数据并搜索过滤。grep提供了非常多的命令参数用来控制查找的方式跟效果,下面列举其常用的一些参数:

参数 说明
-i 默认情况下,grep命令的搜索是大小写敏感的,如果需要忽略大小写可以用这个参数
-v 该参数表示不包含的意思
-A2 其中Aafter的意思,表示同时显示搜索出来行后面两行。有时候我们需要知道匹配行后面是什么,可以用这个参数
-B2 A相反,其是before的意思,表示同时显示匹配行前两行
-C2 有时候我们想既显示前面两行也显示后面两行,这时候就用这个参数
-r 搜索目录的时候需要带上这个参数
-n 有些时候,我们需要知道匹配到的行是第几行,可以加上这个参数把行号打印出来

对于PATTERNgrep命令也支持不同的用法: * 关键字匹配

这个是最常用的基本用法,匹配是否包括该关键字的行。

  • 正则匹配

除了基本的关键字匹配,grep还支持极为强大的正则表达式的匹配。我们将在下一小节专门讲述正则表达式匹配。

  • 或匹配

有时候我们需要匹配某个PATTERN1或者PATTERN2的行,这时候可以这么写PATTERNPATTERN1\|PATTERN2。通过\|将多个PATTERN连在一起表示或的意思,只要匹配其中任一个的行都会被打印出来。

1
2
3
# grep '12306\|test' . -r
./test2:http://abcdefg.test.com
./test2:12306.com

正则表达式匹配

grep命令支持非常强大的正则匹配,支持三种不同的正则表达式:

当然,比较常用的是ERE正则表达式了。在grep命令中,采用-E参数即可以使用该表达式,正则表达式非常灵活,用法非常多,这里列举几个示例:

  • 匹配以关键字开头的行

    1
    
    grep -E "^keyword" . -r
  • 匹配以关键字结尾的行

    1
    
    grep -E "keyword$" . -r
  • 匹配包含如2017/10/11日期的行

    1
    
    grep -E "[0-9]{4}/[0-9]{2}/[0-9]{2}" . -r

    注意的是,对于数字的表示,其不支持如\d这样的表达方式,而需要[0-9]这样表达。

当然,如果需要熟练掌握grep的正则表达式匹配,你必须对正则表达式非常熟悉,这个就不在本篇的范畴了。

awk命令

要说Linux中最为强大的基本命令有哪些,那awk无疑会榜上有名,其强大的流式处理能力,很多人甚至写书来专门讲这个命令。这里咱们暂时介绍基本的功能,以后有机会将专门开辟一文来展开。

一个常见的用法就是把文件中的某几列打印出来:

1
2
3
4
# cat test.log
Nov 17 00:27:20 traffic-base1 named[1212]: managed-keys-zone: Unable to fetch DNSKEY set .: timed out
# cat test.log | awk '{print $1, $2, $3}'
Nov 17 00:27:20

如上例,空格将一行分成了不同的列,咱们希望只把时间显示出来,而时间包括了第1,2,3列,因此,通过awk '{print $1, $2, $3}'就实现了此功能,其中$1就是引用第一列。

cut命令

有时候,一行内的数据并不是通过空格分隔开的,而是通过其它分隔符,那如何显示想要的列呢?通过cut命令,咱们同样可以轻松实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# head -n 5 /etc/passwd
root❌0:0:root:/root:/bin/bash
bin❌1:1:bin:/bin:/sbin/nologin
daemon❌2:2:daemon:/sbin:/sbin/nologin
adm❌3:4:adm:/var/adm:/sbin/nologin
lp❌4:7:lp:/var/spool/lpd:/sbin/nologin
# head -n 5 /etc/passwd | cut -d: -f1
root
bin
daemon
adm
lp

/etc/passwd中的每一行基本上都是通过:进行分隔,其中第一列表示用户名,如果咱们只想把用户名输出的话,可以通过cut -d: -f1来实现,其中-d:表示以:号为分隔符,-f1表示显示第一列。可见,对于cut命令来说,咱们可以指定分隔符,那么前面通过awk实现的例子也可以通过cut来做:

1
2
3
4
# cat test.log
Nov 17 00:27:20 traffic-base1 named[1212]: managed-keys-zone: Unable to fetch DNSKEY set .: timed out
# cat test.log | cut -d" " -f1-3
Nov 17 00:27:20

其中-d" "表示以空格为分隔符(注意,这里的空格必须以引号括起来,不然会被shell展开去除多余空格),-f1-3表示输出第1到3列,这里简用了-来表示范围,当然也可以写成-f1,2,3了。

此外,cut命令还可以指定输出哪些位的字符:

1
2
3
4
# cat test.log
Nov 17 00:27:20 traffic-base1 named[1212]: managed-keys-zone: Unable to fetch DNSKEY set .: timed out
# cat test.log | cut -c1-16
Nov 17 00:27:20

其中,-c1-16表示输出第1到16个字符,当然,你同样可以以,来分别列举要输出哪几个。

tr命令

tr其实是translate的缩写,这个命令用来将某些字符翻译成另外的字符。

1
2
# tr --help
Usage: tr [OPTION]... SET1 [SET2]

这个命令就是把字符集SET1中的字符对应的转成字符集SET2中的字符。如将小写转成大写:

1
2
3
4
# cat test.log
Nov 17 00:27:20 traffic-base1 named[1212]: managed-keys-zone: Unable to fetch DNSKEY set .: timed out
# cat test.log | tr a-z A-Z
NOV 17 00:27:20 TRAFFIC-BASE1 NAMED[1212]: MANAGED-KEYS-ZONE: UNABLE TO FETCH DNSKEY SET .: TIMED OUT

这里用-来方便的表示一定范围的字符集,当然,你完全可以一个个列出来你要的字符集。通常情况下,SET1SET2的长度保持一致,因为这个转换实际上是一对一的转换,当然,SET2的长度是可以大于SET1的,多余的字符不会被使用。但是,当SET2长度小于SET1时,tr命令会将SET2中最后一个字符填充不足的位数:

1
2
3
4
# echo 'abcdefg' | tr ab wyz
wycdefg
# echo 'abcdefg' | tr abcdefg wyz
wyzzzzz

对于tr还有一个常见的用途,就是用来去除字符串中的换行符:

1
2
3
4
5
6
7
8
# head -n 5 /etc/passwd
root❌0:0:root:/root:/bin/bash
bin❌1:1:bin:/bin:/sbin/nologin
daemon❌2:2:daemon:/sbin:/sbin/nologin
adm❌3:4:adm:/var/adm:/sbin/nologin
lp❌4:7:lp:/var/spool/lpd:/sbin/nologin
# head -n 5 /etc/passwd | tr '\n' ' '
root❌0:0:root:/root:/bin/bash bin❌1:1:bin:/bin:/sbin/nologin daemon❌2:2:daemon:/sbin:/sbin/nologin adm❌3:4:adm:/var/adm:/sbin/nologin lp❌4:7:lp:/var/spool/lpd:/sbin/nologin

其中,\n表示换行符,示例中将换行符全部换成了空格。

最后,tr还有一个常见的用法,可以加上-d参数来删除字符集中的字符。

1
2
# echo abcdeWXYZ | tr -d a-z
WXYZ

示例中删除了所有小写字母。

sed命令

流式处理中,sed也是一个极为常用的命令,它可以用来替换字串,比之前的tr那是要强大无数倍了。

查看sed的帮助:

1
2
# sed --help
Usage: sed [OPTION]... {script-only-if-no-other-script} [input-file]...

它既可以直接在文件中替换字符串,也可以加收管道的数据。如基本用法:

1
2
# echo abcdefgabcd | sed 's/abc/ABC/'
ABCdefgabcd

其中's/abc/ABC/'指定了替换的规则,默认情况下只替换一次,如果需要全部替换,则需要在规则后面加入g

1
2
# echo abcdefgabcd | sed 's/abc/ABC/g'
ABCdefgABCd

规则中默认使用了/为分隔。当然,你也可以使用其他分隔符,这在要替换的字串中带有/的时候特别有用:

1
2
3
4
# echo "http://abc.test.com" | sed 's/http:\/\//https:\/\//'
https://abc.test.com
# echo "http://abc.test.com" | sed 's|http://|https://|'
https://abc.test.com

如果不指定新的分隔符|,那么就得使用转义符\//进行转义了,这样可读性就差了很多,采用|就自然多了。sed支持的分隔符还包括了:_

此外,sed不仅可以用来替换字串,还可以用来删除匹配的行:

1
2
3
4
5
# cat test2
http://abcdefg.test.com
12306.com
# cat test2 | sed '/12306/d'
http://abcdefg.test.com

高级用法

  • 后向引用(Back Referencing)

    sed规则匹配到的字符串还可以在规则定义中被引用,如下例:

    1
    2
    
    # echo "hello world" | sed 's/hello/&&/'
    hellohello world

    其中,&可以用来引用被匹配到的字串,在本例中,匹配到的字串是hello,这样通过&就可以引用被匹配到的字串了。此外,我们还可以通过()来指定匹配的字串,并用\1(数字表示第一个())来引用(实际上是正则表达式中的Grouping):

    1
    2
    3
    4
    
    # echo Sunday | sed 's/\(Sun\)/\1ny/'
    Sunnyday
    # echo Sunday | sed 's/\(Sun\)/\1ny \1/'
    Sunny Sunday
  • 正则匹配

    由上述可以看出,sed的规则使用了正则表达式规则,但是其书写跟一般的正则书写不一样,你必须将有关的字符转义,否则sed仍然会将其当做普通字符进行匹配:

    1
    2
    3
    4
    
    # echo "this is aaaa cat" | sed 's/a{4}/a/'
    this is aaaa cat
    # echo "this is aaaa cat" | sed 's/a\{4\}/a/'
    this is a cat

    可以看出,在没有转义{}之前,sed并没有匹配到目标字串aaaa,而将其转义之后,则以正则表达式a{4}匹配到了aaaa并进行了替换。

  • 递归替换

    有时候我们需要在项目目录下替换某个字串,比如把手误写错的#include<stdllib.h>全部替换成#include<stdlib.h>,希望被替换的文件包括*.cpp*.h的文件。其中的一种做法如下:

    1
    2
    3
    4
    5
    
    $ head -n 1 test.cpp
    #include <stdllib.h>
    $ sed -i 's/#include <stdllib.h>/#include <stdlib.h>/' `find . -name "*.cpp" -o -name "*.h"`
    $ head -n 1 test.cpp
    #include <stdlib.h>

    这里用到了shell嵌入的用法(可以参看这一篇博文),通过find命令找出所有的源文件,然后用sed -i进行替换,其中-i表示从文件里面替换。这一用法会将find找到的所有文件作为参数都追加到sed命令后,在项目非常大的情况下可能会导致命令执行失败(因为数量庞大的文件导致追加的参数太大了),通常我们推荐采用find的这种用法:

    1
    
    find . -name "*.cpp" -o -name "*.h" -exec sed -i 's/#include <stdllib.h>/#include <stdlib.h>/' {} \;

    具体可以参照本文中关于find命令的介绍。