sed [-options] 'script' [文件]		# script由地址定界和编辑命令组成，二者不能有空格

awk [options]  'scripts' var=value file		# scripts由匹配模式和操作命令组成

# 一个通用的awk脚本语句
awk 'BEGIN{ commands } pattern{ commands } END{ commands }'

-v var=value

[root@along ~]# cat awkdemo
hello:world
linux:redhat:lalala:hahaha
along:love:youou
[root@along ~]# awk -v FS=':' '{print $1,$2}' awkdemo  #FS指定输入分隔符
hello world
linux redhat
along love
[root@along ~]# awk -v FS=':' -v OFS='---' '{print $1,$2}' awkdemo  #OFS指定输出分隔符
hello---world
linux---redhat
along---love
[root@along ~]# awk -v RS=':' '{print $1,$2}' awkdemo
hello
world linux
redhat
lalala
hahaha along
love
you
[root@along ~]# awk -v FS=':' -v ORS='---' '{print $1,$2}' awkdemo
hello world---linux redhat---along love---
[root@along ~]# awk -F: '{print NF}' awkdemo
2
4
3
[root@along ~]# awk -F: '{print $(NF-1)}' awkdemo  #显示倒数第2列
hello
lalala
love
[root@along ~]# awk '{print NR}' awkdemo awkdemo1
1
2
3
4
5
[root@along ~]# awk END'{print NR}' awkdemo awkdemo1
5
[root@along ~]# awk '{print FNR}' awkdemo awkdemo1
1
2
3
1
2
[root@along ~]# awk '{print FILENAME}' awkdemo
awkdemo
awkdemo
awkdemo
[root@along ~]# awk 'BEGIN {print ARGC}' awkdemo awkdemo1
3
[root@along ~]# awk 'BEGIN {print ARGV[0]}' awkdemo awkdemo1
awk
[root@along ~]# awk 'BEGIN {print ARGV[1]}' awkdemo awkdemo1
awkdemo
[root@along ~]# awk 'BEGIN {print ARGV[2]}' awkdemo awkdemo1
awkdemo1

# 先定义变量，后执行动作print
[root@along ~]# awk -v name="along" -F: '{print name":"$0}' awkdemo
along:hello:world
along:linux:redhat:lalala:hahaha
along:along:love:you

# 在执行动作print后定义变量
[root@along ~]# awk -F: '{print name":"$0;name="along"}' awkdemo
:hello:world
along:linux:redhat:lalala:hahaha
along:along:love:you

# 可以把执行的动作放在脚本中，直接调用脚本 -f
[root@along ~]# cat awk.txt
{name="along";print name,$1}
[root@along ~]# awk -F: -f awk.txt awkdemo
along hello
along linux
along along

printf "FORMAT", item1,item2, ...

[root@along ~]# awk -F: '{print $1,$3}' /etc/passwd
root 0
bin 1
---第一列显示小于20的字符串；第2列显示整数并换行
[root@along ~]# awk -F: '{printf "%20s---%u\n",$1,$3}' /etc/passwd
                root---0
                 bin---1
---使用-进行左对齐；第2列显示浮点数
[root@along ~]# awk -F: '{printf "%-20s---%-10.3f\n",$1,$3}' /etc/passwd
root                ---0.000    
bin                 ---1.000
---使用printf做表格
[root@along ~]# awk -F: 'BEGIN{printf "username            userid\n-----------------------------\n"}{printf "%-20s|%-10.3f\n",$1,$3}' /etc/passwd
username            userid
-----------------------------
root                |0.000    
bin                 |1.000

string ~ pattern

awk '$0 ~ /apple/ { print "Found apple!" }'Copy

# 注释：先判断selector，如果符合执行 ? 后的操作；否则执行 : 后的操作
selector?if-true-expression:if-false-expression

# 模式匹配符

# 查询以/dev开头的磁盘信息
[root@along ~]# df -h |awk -F: '$0 ~ /^\/dev/'
/dev/mapper/cl-root   17G  7.3G  9.7G  43% /
/dev/sda1           1014M  121M  894M  12% /boot
# 只显示磁盘使用状况和磁盘名
[root@along ~]# df -h |awk '$0 ~ /^\/dev/{print $(NF-1)"---"$1}'
43%---/dev/mapper/cl-root
12%---/dev/sda1
# 查找磁盘大于40%的
[root@along ~]# df -h |awk '$0 ~ /^\/dev/{print $(NF-1)"---"$1}' |awk -F% '$1 > 40'
43%---/dev/mapper/cl-root
　　

# 逻辑操作符

[root@along ~]# awk -F: '$3>=0 && $3<=1000 {print $1,$3}' /etc/passwd
root 0
bin 1
[root@along ~]# awk -F: '$3==0 || $3>=1000 {print $1}' /etc/passwd
root
[root@along ~]# awk -F: '!($3==0) {print $1}' /etc/passwd
bin
[root@along ~]# awk -F: '!($0 ~ /bash$/) {print $1,$3}' /etc/passwd
bin 1
daemon 2
　　

# 条件表达式（三目表达式）

[root@along ~]# awk -F: '{$3 >= 1000?usertype="common user":usertype="sysadmin user";print usertype,$1,$3}' /etc/passwd
sysadmin user root 0
common user along 1000

[root@along ~]# awk -F: '{print $1}' awkdemo
hello
linux
along
[root@along ~]# awk -F: '/along/{print $1}' awkdemo
along
[root@along ~]# awk -F: '1{print $1}' awkdemo
hello
linux
along
[root@along ~]# awk -F: '0{print $1}' awkdemo
[root@along ~]# awk -F: '/^h/,/^a/{print $1}' awkdemo
hello
linux
along
[root@along ~]# awk -F: 'BEGIN{print "第一列"}{print $1} END{print "结束"}' awkdemo
第一列
hello
linux
along
结束

sort [-Options]... [File]

[root@linuxidc tmp]# cat system.txt			# 空白部分为单个制表符
1       mac     2000    500
2       winxp   4000    300
3       bsd     1000    600
4       linux   1000    200
5       SUSE    4000    300
6       Debian  600     200

# 不加任何选项时，将对整行从第一个字符开始依次向后直到行尾按照默认的字符集排序规则做升序排序。
[root@linuxidc tmp]# sort system.txt
1       mac     2000    500
2       winxp   4000    300
3       bsd     1000    600
4       linux   1000    200
5       SUSE    4000    300
6       Debian  600     200

# 以第三列为排序列进行排序。由于要划分字段，所以指定字段分隔符。指定制表符这种无法直接输入的特殊字符的方式是 $'\t'。
[root@linuxidc tmp]# sort -t $'\t' -k3 system.txt  
4       linux   1000    200
3       bsd     1000    600
1       mac     2000    500
2       winxp   4000    300
5       SUSE    4000    300
6       Debian  600     200

# 上个排序按照默认字符集进行排序，虽然 1000<2000<4000 的顺序是对了，但 600 却排在最后面，下面对第三列按数值排序规则进行排序。
[root@linuxidc tmp]# sort -t $'\t' -k3 -n system.txt
6       Debian  600     200
3       bsd     1000    600
4       linux   1000    200
1       mac     2000    500
2       winxp   4000    300
5       SUSE    4000    300

# 在对第3列按数值排序规则排序的基础上，仍有第三列重复的行，使用第四列作为决胜属性，且是以数值排序规则对第四列排序。
[root@linuxidc tmp]# sort -t $'\t' -k3 -k4 -n system.txt
6       Debian  600     200
4       linux   1000    200
3       bsd     1000    600
1       mac     2000    500
2       winxp   4000    300
5       SUSE    4000    300
# 默认情况下，在命令行中指定的排序行为结束后，sort还会做最后一次排序，这最后一次排序是对整行按照完全默认规则进行排序的，也就是按字符集升序排序。


# 在第3列按数值排序后，以第2列非数值字段作为决胜列，并且第二段按照降序排序。
[root@linuxidc tmp]# sort -t $'\t' -k3n -k2r system.txt
6       Debian  600     200
4       linux   1000    200
3       bsd     1000    600
1       mac     2000    500
2       winxp   4000    300
5       SUSE    4000    300
# 由于既要对第 3 列按数值升序排序，又要对第 2 列按默认规则降序排序，因此只能对每个字段单独分配选项。
# 紧跟在字段后的选项 (如 "-k3n" 的 "n" 和 "-k2r" 的 "r") 称为私有选项，使用短横线写在字段外的选项 (如 "-n"、"-r") 为全局选项。当没有为字段分配私有选项时，该排序字段将继承全局选项。当然，只有像 "-n"、"-r" 这样的排序性的选项才能继承和分配给字段，"-t" 这样的选项则无法分配。
# 因此，"-n -k3 -k4"、"-n -k3n -k4" 和 "-k3n -k4n" 是等价的，"-r -k3n -k4" 和 "-k3nr -k4r" 是等价的。
# 实际上，上面的命令写法并不严谨。更标准的写法应该如下：
	sort -t $'\t' -k3n -k2,2r system.txt
# "-k2,2" 表示排序对象从第 2 个字段开始到第 2 个字段结束，也就是限定了只对第二个字段排序。它的格式为 "POS1,POS2"，如果省略 POS2，将自动扩展到行尾，即 "-k2" 等价于 "-k2,4"，也就是说，对整个第 2 列到第 4 列进行排序。

# 在对第 3 列按数值排序规则排序的基础上，使用第 2 列的第 2 个字符作为决胜属性，且以默认排序规则对此列升序排序。
[root@linuxidc tmp]# sort -t $'\t' -k3n -k2.2,2.2 system.txt
6       Debian  600     200
4       linux   1000    200
3       bsd     1000    600
1       mac     2000    500
2       winxp   4000    300
5       SUSE    4000    300
# 其中 "-k2.2,2.2" 表示从第 2 个字段的第 2 个字符开始，到第 2 个字段的第 2 个字符结束，即严格限定为第 2 个字段第 2 个字符。如果需要对此字符降序排序，则 "-k2.2,2.2r"。

# 使用 "-u" 去除重复字段所在的行。例如第 3 列有两行 1000，两行 4000，去除字段重复的行时，将只保留排在前面的第一行。
[root@linuxidc tmp]# sort -t $'\t' -k3n -u system.txt
6       Debian  600     200
3       bsd     1000    600
1       mac     2000    500
2       winxp   4000    300
# 由于需要去除重复字段的行，因此使用 "-u" 时将禁止 sort 做 "最后一次排序"。至于字段重复的行中，如何判断哪一行是排在最前面的行，需要搞懂 sort 的整个工作机制。
# "sort -u" 和 "sort | uniq" 是等价的，但是如果多指定几个选项，它们将不等价。例如，"sort -n -u" 只会检查排序字段数值部分的唯一性，但 "sort -n | uniq" 在 sort 对行中字段按数值排序后，uniq 将检查整个行的唯一性。

# 将排序结果保存到文件中。即可以使用重定向，也可以使用 "-o" 选项，但使用重定向不可保存到原文件，因为在 sort 开始执行前，原文件先被重定向截断。而使用 "-o" 则没有这样的问题，因为 sort 在打开文件前先完成数据的读取。但 "-o" 和 "-m" 一起使用时，同样不安全。
[root@linuxidc tmp]# sort -t $'\t' -k3n -o system1.txt system.txt

# 使用 "-c" 或 "-C" 检测文件是否排过序
[root@linuxidc tmp]# sort -c -k3n system.txt ;echo $?
sort: system.txt:3: disorder: 3 bsd     1000    600		# 说明 system.txt 中的第 3 行开始出现乱序，且退出状态码为 1。
1
[root@linuxidc tmp]# sort -C -k3n system.txt ;echo $?
1

$ cut [-Options]... [File]

-c : 提取指定的字符，可以是以逗号分隔的数字的列表，也可以是以连字符分隔的数字的范围。char

-f : 提取指定的字段，cut 命令使用 Tab 作为默认的分隔符。搭配 -d 指定字段分隔符

-b : 提取指定的字节，也可以指定一个范围。搭配 -n 不要分割多字节字符。

–complement : 不输出选中的部分，即反选。

–output-delimiter : 指定输出时使用的分隔符。

--only-delimited : 不输出不包含分隔符的列

# 演示文本内容
$ cat content.txt 
Ubuntu Linux
Microsoft Windows
OsX El Capitan
Unix
FreeBSD

# 按照字段输出并且指定分隔符为空格
$ cut -d " " -f 1 content.txt 
Ubuntu
Microsoft
OsX
Unix
FreeBSD

# 以字符的方式切割内容，输出1-7个字符，
$ cut -c 1-7 content.txt
Ubuntu
Microso
OsX El
Unix
FreeBSD
# 第一个和第七个：1,7
# 第二个到最后一个：2-
# 第一个到第四个：-4

# 根据字节选取，如果只有英文和数字等单字节字符，-b和-c的作用相同
# 如果内容中有中文（两个字节），搭配-b选项使用： 表示不要分割多字节字符。如果字符的最后一个字节落在由 -b 标志的 List 参数指示的范围之内，该字符将被写出；否则，该字符将被排除。