AWK三剑客入门与进阶实践指南

2019-06-26
Linux命令

AWK三剑客入门与进阶实践指南

2019-06-26

[TOC]

0x00 快速入门

描述：awk 命令与其说它是一个命令，更不如说它是一门脚本编程语言，它是主要针对文本和数据进行处理的编程语言,是linux/unix下的一个强大编程工具。
它有三种形式 awk,gawk,nawk 平时所说的awk其实就是gawk;它在命令行中使用,但更多是作为脚本来使用,

awk特点:

它支持用户自定义函数和动态正则表达式等先进功能
awk有很多内建的功能：可以自定义变量,有条件语句,有循环,有数组,有正则,有函数等这是它和C语言的相同之处
灵活性是awk最大的优势

0x01 命令格式和选项

语法形式

awk [options] 'script' -v var=value file (s) #数据可以来自标准输入(stdin)、一个或多个文件,或其它命令的管道输出.
awk [options] -f scriptfile -v var=value file(s)

#awk脚本基本结构:{}类似一个循环体，会对文件中的每一行进行迭代，
#一个awk脚本通常由三个部分是可选的。
# - BEGIN语句块、
# - 能够使用模式匹配的通用语句块、
# - END语句块
awk 'BEGIN{ print "start" } pattern{ commands } END{ print "end" }' file

常用命令选项：

-F fs #fs指定输入分隔符，fs可以是字符串或正则表达式，如-F:
-v var=value  #赋值一个用户定义变量，将外部变量传递给awk
-f scripfile  #从脚本文件中读取awk命令
-m[fr] val    # 对val值设置内在限制，-mf选项限制分配给val的最大块数目；
-mr选项 限制记录的最大数目 #这两个功能是Bell实验室版awk的扩展功能，在标准awk中不适用。

awk模式和操作
模式可以是以下任意一个：

/正则表达式/：使用通配符的扩展集。
关系表达式：使用运算符进行操作，可以是字符串或数字的比较测试。
模式匹配表达式：用运算符~（匹配）和~!（不匹配）。
BEGIN语句块、pattern语句块、END语句块参见awk的工作原理

操作由一个或多个命令、函数、表达式组成之间由换行符或分号隔开，并位于大括号内主要部分是：

变量或数组赋值
输出命令
内置函数
控制流语句

0x02 awk的工作原理

比如：awk 'BEGIN{ commands } pattern{ commands } END{ commands }'

第一步：执行BEGIN{ commands }语句块中的语句；
第二步：从文件或标准输入(stdin)读取一行，然后执行pattern{ commands }语句块，它逐行扫描文件，从第一行到最后一行重复这个过程直到文件全部被读取完毕。
第三步：当读至输入流末尾时，执行END{ commands }语句块。

BEGIN语句块(程序初始操作)

在awk开始从输入流中读取行之前被执行，可选的语句块比如显示变量以及变量初始化、打印输出表格的表头等语句通常可以写在BEGIN语句块中。

pattern语句块中的通用命令是最重要的部分，它也是可选的。如果没有提供pattern语句块，则默认执行{ print }即打印每一个读取到的行，awk读取的每一行都会执行该语句块。

END语句块（程序结束操作）

在awk从输入流中读取完所有的行之后(程序结束之后)被执行(扫尾工作)，比如打印所有行的分析结果这类信息汇总都是在END语句块中完成，它也是一个可选语句块。
有END语句块后必须有处理的文件或者是通过管道符传入的字符串，否则会一直卡再输入状态;

注意事项：
任何在BEGIN之后列出的操作{}内,将在awk开始扫描输入之前执行,而END之后列出的操作将会在扫描完全后输入后执行;

Awk支持输出中文字符,同时也支持Print与printf命令

1.print会在每个输出之后自动加入一个换行符（Linux-shell是没有Print命令的，只有printf命令）
2.printf是标准格式的输出命令，并不会自动加入换行符,如果需要则要加上\反义字符.

基本示例：

# 示例1.任意一个部分都可以不出现在脚本中，脚本通常是被单引号或双引号中，例如：
#通常变量初始化语句（如：i=0）以及打印文件头部的语句放入BEGIN语句块中，将打印的结果等语句放在END语句块中
awk 'BEGIN{ i=0 } { i++ } END{ print i }' filename  #[推荐方式] 
awk "BEGIN{ i=0 } { i++ } END{ print i }" filename  #在awk的print语句块中双引号是被当作拼接符使用，（执行某些语句时候会出现问题）
#有END后必须在后面接上处理的文件
awk 'BEGIN {
    arr[1]="boy";
    arr[2]="girl";
    for(key in array)
      print key,array[key]
  }' /etc/hosts #毫无相关的也可以
# 1 boy
# 2 girl


#示例2.当使用不带参数的print时，它就打印当前行，当print的参数是以逗号进行分隔时，打印时则以空格作为定界符。
echo -e "A line 1\nA line 2" | awk 'BEGIN{ print "Start" } { print } END{ print "End" }'  #通过管道符号
# Start
# A line 1
# A line 2
# End


#示例3.双引号""拼接使用：
echo | awk '{ var1="v1"; var2="v2"; var3="v3"; print var1,var2,var3; }' 
#v1 v2 v3
echo | awk '{ var1="1"; var2="2"; var3="3"; print var1"=>"var2"=>"var3; }'
#1=>2=>3

借助-v选项:可以将外部值（并非来自stdin）传递给awk

#示例1.将外部变量值传递给awk,
VAR=10000;echo | awk -v VARIABLE=$VAR '{ print VARIABLE }'
# 10000
#另一种传递外部变量方法：
var1="aaa";var2="bbb"
echo | awk '{ print v1,v2 }' v1=$var1 v2=$var2  #方法中变量之间用空格分隔作为awk的命令行参数跟随在BEGIN、{}和END语句块之后
# aaa bbb


#示例2.变量传递加文件读取
var1=1024;var2="weiyigeek"
awk 'BEGIN{ print v2,"BEIGIN",v1 } { print v1,v2 } END{ print v2,v1 }' v1=$var1 v2=$var2 /etc/passwd
    BEIGIN     #BEGIN 初始化为空白此时变量还没写入
# 1024 weiyigeek  #/etc/passwd有几行就显示几行
# 1024 weiyigeek
# 1024 weiyigeek
# 1024 weiyigeek
# 1024 weiyigeek
weiyigeek 1024  #END 除开最后一行不一样

awk借助-F 选项确定分割符号进行指定列输出，默认的字段定界符是空格：

#示例1.passwd文件分割
awk -F: '{ print $NF }' /etc/passwd
awk -F ":" '{ print $1 }' /etc/passwd
# root
# daemon
# bin
# sys
awk -F '{ print $1 }' /etc/passwd
#补充可以采用正则的方式进行指定分隔符进行分割（及多个分隔符）
# netstat -an | grep "EST"
#   TCP    127.0.0.1:5354         127.0.0.1:49155        ESTABLISHED
#   TCP    127.0.0.1:5354         127.0.0.1:49156        ESTABLISHED
#值得学习
netstat -an | grep "EST" | grep -v "127.0.0.1" | awk -F "[ :]+" '{print $5}' | sort | uniq -c
netstat -an | grep "EST" | awk -F "[ :]+" '{print $5}' | sort |uniq -c
      6 127.0.0.1
      1 183.232.94.216




#示例2.统计一个文本文件中url出现的次数，并且去重复
cat >> test.txt <<END
http://www.weiyigeek.github.io/1.path
http://www.weiyigeek.github.io/1.html
http://bbs.weiyigeek.github.io/1.jsp
http://www.weiyigeek.github.io/1.php
http://blog.weiyigeek.github.io/1.jsp
http://bbs.weiyigeek.github.io/1.jsp
END
workspace> awk -F "/" '{ print $3 }' test.txt | sort -r | uniq -c 
  3 www.weiyigeek.github.io
  2 bbs.weiyigeek.github.io
  1 blog.weiyigeek.github.io
#补从示例2,注意字符串默认从0加整数自加1（值得学习）
awk -F "/" '{S[$3]+=1}END{ for(item in S) print item":"S[item]}' test.txt  #借鉴与学习
awk -F "/" '{S[$3]++}END{ for(item in S) print item":"S[item]}' test.txt | sort -t ":" -k2  #排序
blog.weiyigeek.github.io:1
bbs.weiyigeek.github.io:2
www.weiyigeek.github.io:3


#示例3.统计服务器中不同网络连接状态的对应数量 （借鉴学习）
$ NETSTAT.EXE -an | awk '/^tcp/ {print $NF}' | sort | uniq -c | sort -rn |head   #$NF 代表最后一行
$ NETSTAT.EXE -an | awk -F " " '{ if($4 == "" || $4 == " "){next}else{S[$4]++}} END{ for(key in S) print key"状态数量："S[key]; }'
# LISTENING状态数量：37
# CLOSE_WAIT状态数量：12
# ESTABLISHED状态数量：15


#示例4.统计apache.logs日志数量 (访问次数*文件大小) 文件名称
awk '{ print $7"\t" $10}' access_2018-12.log | sort | uniq -c | awk '{print $1*$3,$1,$2}' | sort -rn | head  #方式1
awk '{namenum[$7]++;size[$7]+=$10} END {for x in name{ print(size[x],namenum[x],x)}}' access_2018-12.log | sort -rn -k1 | head -10  #方式2 （自带统计数量）
# 57254 1 /static/js/jquery-juquey-1.3.2min.js

0x03 awk内置变量（预定义变量）

说明：[A][N][P][G]表示第一个支持变量的工具

[A]=awk
[N]=nawk
[P]=POSIXawk
[G]=gawk 

#内置变量
$n 当前记录的第n个字段，比如n为1表示第一个字段，n为2表示第二个字段。 
$0 这个变量包含执行过程中当前行的文本内容。
[N] ARGC 命令行参数的数目。
[G] ARGIND 命令行中当前文件的位置（从0开始算）。
[N] ARGV 包含命令行参数的数组。
[G] CONVFMT 数字转换格式（默认值为%.6g）。
[P] ENVIRON 环境变量关联数组。
[N] ERRNO 最后一个系统错误的描述。
[G] FIELDWIDTHS 字段宽度列表（用空格键分隔）。
[A] FILENAME 当前输入文件的名。
[P] FNR 同NR，但相对于当前文件。
[A] FS 字段分隔符（默认是任何空格）。
[G] IGNORECASE 如果为真，则进行忽略大小写的匹配。
[A] NF 表示字段数，在执行过程中对应于当前的字段数。常用
[A] NR 表示记录数，在执行过程中对应于当前的行号。 常用
[A] OFMT 数字的输出格式（默认值是%.6g）。
[A] OFS 输出字段分隔符（默认值是一个空格）。常用
[A] ORS 输出记录分隔符（默认值是一个换行符）。
[A] RS 记录分隔符（默认是一个换行符）。
[N] RSTART 由match函数所匹配的字符串的第一个位置。
[N] RLENGTH 由match函数所匹配的字符串的长度。
[N] SUBSEP 数组下标分隔符（默认值是34）。

输出字段$0~{$1.$n}开始(类似于shell的位置参数变量):

#示例1.输出第几列的数据，类似shell从cmd传入到脚本程序的参数
echo -e "1 2 3\n4 5 6\n7 8 9" | awk '{print $0," ==",$1,"-",$2,"-",$3}'
# 1 2 3  == 1 - 2 - 3
# 4 5 6  == 4 - 5 - 6
# 7 8 9  == 7 - 8 - 9

#示例2.打印每一行的第二和第三个字段：
echo -e "1 2 3\n4 5 6\n7 8 9" | awk '{ print $2,$3 }'
# 2 3
# 5 6
# 8 9

#示例3.文件处理传入输出字符,把文件内容第一列作为下标,第二列作为值，放入数组然后输出
cat >> demo1.txt <<END
1 WeiyiGeek
2 Weiy_
END

$awk '{S[$1]=$2 } END{ for(key in S) print key":"S[key] }' demo1.txt
# 1:WeiyiGeek
# 2:Weiy_

对于传入的文件进行字段数NF处理：

# 示例1.使用print $NF可以打印出一行中的最后一个字段，使用$(NF-1)则是打印倒数第二个字段，其他以此类推：
echo -e "line1 f2 f3\n line2 f4 f5" | awk '{print $NF}'
# f3
# f5
echo -e "line1 f2 f3\n line2 f4 f5" | awk '{print $(NF-1)}'
# f2
# f4

统计文件中的行数NR

# 示例0：统计行数
$ awk 'END{print NR}' /etc/passwd
24

# 示例1:输出字段$0~$1~$n开始(类似于shell的位置参数变量)，
echo -e "line1 f2 f3\nline2 f4 f5\nline3 f6 f7" | awk '{print "Line No:" NR ", No of fields:" NF , "$0="$0, "$1="$1, "$2="$2, "$3="$3}' 
# Line No:1(关键点), No of fields:3(关键点) $0=line1 f2 f3(关键点) $1=line1(关键点) $2=f2(关键点) $3=f3(关键点)
# Line No:2, No of fields:3 $0=line2 f4 f5 $1=line2 $2=f4 $3=f5
# Line No:3, No of fields:3 $0=line3 f6 f7 $1=line3 $2=f6 $3=f7

以上命令只使用了END语句块在读入每一行的时，awk会将NR更新为对应的行号，当到达最后一行NR的值就是最后一行的行号，所以END语句块中的NR就是文件的行数。

设置字符分割定界符 FS:
描述：在BEGIN语句块中可以用FS="定界符"设置输出字段的定界符;

#示例1.指定定界符
echo "1-2-3-4-5-6" | awk 'BEGIN{ FS="-"} {print "行数:"$NR,"列数:"$NF,"\n选择分割元素:"$1,"全部元素:"$0}'
行数:1 列数:6 
选择分割元素:1 全部元素:1-2-3-4-5-6


#示例2.与-F选项同功能来提取passwd
awk 'BEGIN{ FS=":";} {print "用户名:"$1}' /etc/passwd | sort -u    
用户名:_apt
用户名:backup
用户名:bin
用户名:daemon
用户名:dnsmasq
用户名:games
用户名:gnats
用户名:irc
用户名:landscape

环境变量关联数组ENVIRON是awk常量，是子典型数组。

#示例1.获取单个环境关联数组
/tmp> awk 'BEGIN{ print ENVIRON["LOGNAME"] }'  #注意 双引号
ubuntu


#示例2.遍历打印环境数组变量
awk 'BEGIN{
  for(k in ENVIRON){
    print k"="ENVIRON[k];
  }
}'
# LESS=-R
# PAGER=less
# WSLENV=
# AWKPATH=.:/usr/share/awk
# OLDPWD=/mnt/e/githubProject/blog
# AWKLIBPATH=/usr/lib/x86_64-linux-gnu/gawk

SUBSEP 数组下标分隔符用于多维数组的分割

#注意此种方法输出无序
awk 'BEGIN{
for(i=1;i<=9;i++){
  for(j=1;j<=9;j++){
    tarr[i,j]=i*j;
  }
}
  for(m in tarr){
    split(m,tarr2,SUBSEP);
    print tarr2[1],"*",tarr2[2],"=",tarr[m];
  }
}'

OFMT 设置输出数据格式是保留3位小数。

#保留指定位数的小数点后的数字,注意此时输出的时候不能使用""进行连接awk变量否则会失效：
awk 'BEGIN{
    OFMT="%.3f";
    f1=20/3;
    f2=cos(15%4);
    f3=sin(5^2);
    print "f1=",f1, "f2=",f2, "f3=",f3;
  }'
f1= 6.667 f2= -0.990 f3= -0.132

0x04 awk运算与判断

作为一种程序设计语言所应具有的特点之一，awk支持多种运算，这些运算与C语言提供的基本相同。函数的引用大大的提高了awk的运算功能。作为对条件转移指令的一部分，关系判断是每种程序设计语言都具备的功能，

awk还提供了一系列内置的运算函数（如log、sqr、cos、sin等）和一些用于对字符串进行操作（运算）的函数（如length、substr等等）
awk中允许进行多种测试，作为样式匹配，还提供了模式匹配表达式~（匹配）和~!（不匹配）。
awk也支持用逻辑运算符作为对测试的一种扩充

运算符优先级列表：

运算符示例：

#算数运算符
awk 'BEGIN{a="a";print a++,++a;}'  #字母默认都是为0 
0 2
awk 'BEGIN{a=1;print a++,++a;}'  
1 3


#赋值运算符
awk 'BEGIN{a=1;b=2; print a "+" b " =",b+=a}'  
1+2 = 3
awk 'BEGIN{a=2;b=3; print a "**" b " =",a**=b}'  #幂运算的两种形式
awk 'BEGIN{a=2;b=3; print a "^" b " =",a^=b}'  


#逻辑运算符
awk 'BEGIN{a=1;b=2; print (a>5 && b<=2),(a>5 || b<=2);}'
0 1                        # false           true


#正则运算符与逻辑判断
awk 'BEGIN{a="100testa";if(a ~ /^a/) {print "ok";}else{print "fasle";}}'
fasle
awk 'BEGIN{a="100testa";if(a !~ /^100*/){print "yes";}else{print "no"}}'
no


#关系运算符
awk 'BEGIN{a=11;if(a >= 9){print "ok";}else{printf "no";}}'  #ok
awk 'BEGIN{a=13;if(a >= 9 && 12>=a ){print "ok";}else{printf "no\n";}}' #no
awk 'BEGIN{a="weiyi";b="geek"; if(a>b){print "a字符串大于b字符串";}else{printf "a字符串小于b字符串"}}'
a字符串大于b字符串


#其他运算符
awk 'BEGIN{a="b";print a=="b"?"ok":"err";}'     #ok 三元运算符
awk 'BEGIN{a="b";arr[0]="b";arr[1]="c";print (a in arr);}' #0
awk 'BEGIN{a="b";arr[0]="b";arr["b"]="c";print (a in arr);}' #1

基础示例：

#示例0.一个每一行中第一个字段值累加的例子：
seq 5 | awk 'BEGIN{ sum=0;printf "总和：" } {printf $1"+"; sum+=$1 } END{ printf "等于"; printf sum }'  #内部定义的变量可以不加$
总和：1+2+3+4+5等于15

#示例1.AWK进行小数计算 ($类似于引用)
echo "5.5 6.6" | awk '{print ($2 - $1)}'       #计算结果：1.1
echo "5.5 6.6" | awk '{print ($2 - $1) / 3 }'  #计算结果：0.366667

注意：

所有用作算术运算符进行操作，操作数自动转为数值，所有非数值都变为0
> <可以作为字符串比较，也可以用作数值比较，关键看操作数如果是字符串就会转换为字符串比较。
两个都为数字才转为数值比较,字符串比较按照ASCII码顺序比较。

0x05 awk数组应用

数组是awk的灵魂处理文本中最不能少的就是它的数组处理，因为数组索引（下标）可以是数字和字符串在awk中数组叫做关联数组(associative arrays)。

awk 中的数组不必提前声明，也不必声明大小。
数组元素用0或空字符串来初始化，这根据上下文而定。

关联与索引数组定义：

# 数字做数组索引（下标）：awk索引下标默认是从1开始的，但您也可以设置从0开始
Array[0]="GEEK"
Array[1]="sun"
Array[2]="kai"

# 字符串做数组索引（下标）：
Array["age"]=15
Array["name"]="weiyigeek"

#使用中print Array[1]会打印出sun；
#使用print Array[2]会打印出kai；
#使用print["birth"]会得到1987。

数组示例：

#我们可以利用循环来读取索引数组与关联数组，以上面的变量为例
#方式1：{ for(i=1;i<=len;i++) {print array[i]}; }  #Len是数组的长度
#方式2：
awk 'BEGIN{
    Array[0]="GEEK";
    Array[1]="sun";
    Array[2]="kai";
    for(item in Array){
      print "第",item+1,"个元素："Array[item]
    }
  }'
# 第 1 个元素：GEEK
# 第 2 个元素：sun
# 第 3 个元素：kai


#关联数组
awk 'BEGIN{
  Array["name"]="weiyigeek";
  Array["age"]=15;
  STR="";
  STR1="";
  for(item in Array)
  {
    if( item == "name" )
    {
      STR="我的姓名是:"Array[item];
    }else if( item == "age" ){
      STR1=",我的年龄是:"Array[item];
    }
  }
  print STR,STR1
  }'
#我的姓名是:weiyigeek ,我的年龄是:15


#删除键值：delete array[key]可以删除，对应数组key的，序列值。

$ awk 'BEGIN{
  tB["a"]="a1";tB["b"]="b1";
  delete tB["a"];
  for(k in tB){
    print k,tB[k];
    }
  }'                     
b b1

二维、多维数组使用

awk的多维数组在本质上是一维数组，但是awk在存储上并不支持多维数组;
awk提供了逻辑上模拟二维数组的访问方式。
例如array[2,4]=1这样的访问是允许的。

awk多维数组新特点：

类似一维数组的成员测试，多维数组可以使用if ( (i,j) in array)这样的语法，但是下标必须放置在圆括号中。
类似一维数组的循环访问，多维数组使用for ( item in array )这样的语法遍历数组
与一维数组不同的是多维数组必须使用split()函数来访问单独的下标分量。

基础示例：

#方法1.九九乘法表, 可以通过array[k,k2]引用获得数组内容。
awk 'BEGIN{
for(i=1;i<=9;i++){
  for(j=1;j<=9;j++){
    tarr[i,j]=i*j; printf i"*"j"="tarr[i,j]" ";
    if( j == 9){
      print ""
    }
  }
}
}'
# 1*1=1 1*2=2 1*3=3 1*4=4 1*5=5 1*6=6 1*7=7 1*8=8 1*9=9 
# 2*1=2 2*2=4 2*3=6 2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
# 3*1=3 3*2=6 3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
# 4*1=4 4*2=8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
# 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
# 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54
# 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63
# 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72
# 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

注意事项：

awk数组是关联数组，只要通过数组引用它的key，就会自动创建改序列，所以当Array[“c”]没有定义但是循环时候，发现已经存在该键值并且它的值为空

0x06 awk流程控制

在linux中awk里面也能进行流程控制，流程控制语句/语法结构与C语言类似，有了这些语句很多shell程序都可以交给awk进行,而且性能非常的快;

条件分支：if
循环判断：while, do…while, for
其他语句：break, Continue, exit
- break 当 break 语句用于 while 或 for 语句时，导致退出程序循环。
- continue 当 continue 语句用于 while 或 for 语句时，使程序循环移动到下一个迭代。
- next 能能够导致读入下一个输入行，并返回到脚本的顶部。这可以避免对当前输入行执行其他的操作过程。
- exit 语句使主输入循环退出并将控制转移到END,如果END存在的话。如果没有定义END规则或在END中应用exit语句，则终止脚本的执行。

条件判断

#示例1.判断优良差
awk 'BEGIN{
test=100;
if(test>90){
  print "very good - 优";
  }
  else if(test>60){
    print "good";
  }
  else{
    print "no pass";
  }
}'

#very good - 优


#示例2.指定普通用户按照终端显示 (每条命令语句后面可以用;分号结尾)。 
awk 'BEGIN{ FS=":"} { if( "/bin/zsh" == $7){ print $0":"$7; }else if ("/usr/sbin/nologin" == $7){ print $1":nologin";} }' /etc/passwd | sort -t ":" -k 
3 -r
# ubuntu:x:1000:1000:,,,:/home/ubuntu:/bin/zsh:/bin/zsh
# root:x:0:0:root:/root:/bin/zsh:/bin/zsh
# www-data:nologin
# uuidd:nologin
# uucp:nologin
# messagebus:nologin
# man:nologin
# mail:nologin
# lp:nologin
# list:nologin
# landscape:nologin
# irc:nologin
# gnats:nologin
# games:nologin
# dnsmasq:nologin
# daemon:nologin
# bin:nologin
# backup:nologin
# _apt:nologin

循环语句

#示例1.采用awk的while语句,进行1加到100百;
awk 'BEGIN{
test=100;
total=0;
while(i<=test){
  total+=i;
  i++;
}
print "1+..+100=",total;
}'
#1+..+100= 5050


#示例2.采用awk的for语句,进行1加到100百;
awk 'BEGIN{
  TOTAL=0;
  for(i=0;i<=100;i++){
    total+=i
  }
  print "1+...+100="total
}'
#1+...+100=5050

#for格式2.遍历环境变量数组输出
awk 'BEGIN{
  for(k in ENVIRON){
    print k"="ENVIRON[k];
  }
}'


#示例3.采用awk的do..while语句,进行1加到100百;
awk 'BEGIN{
  TOTAL=0
  num=0
  do
  {
    TOTAL+=num
    num++
  } while(num<=100)
  printf "1+...+100="TOTAL
}'
#1+...+100=5050

实际案例：

#判断键值存在以及删除键值,注意awk关联数组的特点;
#错误的判断方法：
awk 'BEGIN{tB["a"]="a1";tB["b"]="b1";if(tB["c"]!="1"){print "no found";};for(k in tB){print k,tB[k];}}' 
#正确判断方法： if(key in array)通过这种方法判断数组中是否包含key键值。
awk 'BEGIN{tB["a"]="a1";tB["b"]="b1";if( "c" in tB){print "ok";};for(k in tB){print k,tB[k];}}'  
a a1
b b1

注意事项：

for…in输出，因为数组是关联数组，默认是无序的;所以通过for…in得到是无序的数组。如果需要得到有序数组，需要通过下标获得。

0x07 awk函数

awk内置函数，主要分以下3种类似：算数函数、字符串函数、其它一般函数、时间函数。

算数函数

格式描述

atan2( y, x ) 返回 y/x 的反正切。
cos( x ) 返回 x 的余弦；x 是弧度。
sin( x ) 返回 x 的正弦；x 是弧度。
exp( x ) 返回 x 幂函数。
log( x ) 返回 x 的自然对数。
sqrt( x ) 返回 x 平方根。
int( x ) 返回 x 的截断至整数的值。
rand( ) 返回任意数字 n，其中 0 <= n < 1。
srand( [expr] ) 将 rand 函数的种子值设置为 Expr 参数的值，或如果省略 Expr 参数则使用某天的时间。返回先前的种子值。

示例说明：

# 算数函数的使用(注意输出的时候不能有""拼接)
awk 'BEGIN{OFMT="%.3f";fs=sin(1);fe=exp(10);fl=log(10);fi=int(3.1415);print fs,fe,fl,fi;}'
0.841 22026.466 2.303 3


# 获得随机数srand
$awk 'BEGIN{srand();fr=int(100*rand());print fr;}'
78
$awk 'BEGIN{srand();fr=int(100*rand());print fr;}'
31
$awk 'BEGIN{srand();fr=int(100*rand());print fr;}'
41

字符串函数

格式	描述
gsub( Ere, Repl, [ In ] )	除了正则表达式所有具体值被替代这点，它和 sub 函数完全一样地执行。
sub( Ere, Repl, [ In ] )	用 Repl 参数指定的字符串替换 In 参数指定的字符串中的由 Ere 参数指定的扩展正则表达式的第一个具体值。sub 函数返回替换的数量。出现在 Repl 参数指定的字符串中的 &（和符号）由 In 参数指定的与 Ere 参数的指定的扩展正则表达式匹配的字符串替换。如果未指定 In 参数，缺省值是整个记录（$0 记录变量）。
index( String1, String2 )	在由 String1 参数指定的字符串（其中有出现 String2 指定的参数）中，返回位置，从 1 开始编号。如果 String2 参数不在 String1 参数中出现，则返回 0（零）。
length [(String)]	返回 String 参数指定的字符串的长度（字符形式）。如果未给出 String 参数，则返回整个记录的长度（$0 记录变量）。
blength [(String)]	返回 String 参数指定的字符串的长度（以字节为单位）。如果未给出 String 参数，则返回整个记录的长度（$0 记录变量）。
substr( String, M, [ N ] )	返回具有 N 参数指定的字符数量子串。子串从 String 参数指定的字符串取得，其字符以 M 参数指定的位置开始。M 参数指定为将 String 参数中的第一个字符作为编号 1。如果未指定 N 参数，则子串的长度将是 M 参数指定的位置到 String 参数的末尾的长度。
match( String, Ere )	在 String 参数指定的字符串（Ere 参数指定的扩展正则表达式出现在其中）中返回位置（字符形式），从 1 开始编号，或如果 Ere 参数不出现，则返回 0（零）。RSTART 特殊变量设置为返回值。RLENGTH 特殊变量设置为匹配的字符串的长度，或如果未找到任何匹配，则设置为 -1（负一）。
split( String, A, [Ere] )	将 String 参数指定的参数分割为数组元素 A[1], A[2], . . ., A[n]，并返回 n 变量的值。此分隔可以通过 Ere 参数指定的扩展正则表达式进行，或用当前字段分隔符（FS 特殊变量）来进行（如果没有给出 Ere 参数）。除非上下文指明特定的元素还应具有一个数字值，否则 A 数组中的元素用字符串值来创建。
tolower( String )	返回 String 参数指定的字符串，字符串中每个大写字符将更改为小写。大写和小写的映射由当前语言环境的 LC_CTYPE 范畴定义。
toupper( String )	返回 String 参数指定的字符串，字符串中每个小写字符将更改为大写。大写和小写的映射由当前语言环境的 LC_CTYPE 范畴定义。
sprintf(Format, Expr, Expr, . . . )	根据 Format 参数指定的 printf 子例程格式字符串来格式化 Expr 参数指定的表达式并返回最后生成的字符串。

常用函数使用：

# gsub,sub使用利用正则匹配
# 在 info中查找满足正则表达式，/[0-9]+/用"!"替换，并且替换后的值赋值给info未给info值默认是$0
awk 'BEGIN{
  info="this is a test2010test!";
  gsub(/[0-9]+/,"!",info);print info
  sub(/test!+/,"[replace]",info);print info
  }'
this is a test!test!
this is a [replace]test!


# 查找字符串（index使用）,并且采用三元运算符
awk 'BEGIN{info="this is a test2010test!";print index(info,"test")?"ok":"no found";}'
ok

#正则表达式匹配查找(match使用）
awk 'BEGIN{info="this is a test2010test!";print match(info,/[0-9]+/)?"ok":"no found";}'
ok

# 截取字符串(substr使用）
$awk 'BEGIN{info="this is a test2010test!";print substr(info,4,10);}'
s is a tes
echo "WeiyiGeek LIVE Computer" | awk '{print  substr($0,0,9)}'
WeiyiGeek

split函数
描述：把变量out转化成数组mon然后打印数组mon的第二个元素，并且返回数组长度工作中非常有用;

#split()函数分割成的数组是从1开始的
awk 'BEGIN{ "date" | getline out; split(out,mon); print mon[2] }'
Jul
# Fri Jul 19 12:25:12 CST 2019 

#指定分隔符进行分割
awk 'BEGIN{ "id" | getline out; split(out,mon,","); print mon[3] }'
20(dialout)
# groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(lxd),114(netdev)


#输出数组与下标（有序for() 和无序 in）
awk 'BEGIN{info="it is a test";tlen=split(info,tA," ");for(k=1;k<=tlen;k++){print k,tA[k];}}'
# 1 it
# 2 is
# 3 a
# 4 test
awk 'BEGIN{info="it is a test";split(info,tA," ");for(k in tA){print k,tA[k];}}'
# 4 test
# 1 it
# 2 is
# 3 a

length函数
描述：利用length函数可以得到数组的元素的个数

# length返回字符串以及数组长度，split进行分割字符串为数组，也会返回分割得到数组长度。
awk 'BEGIN{
  info="it is a test";
  lens=split(info,tA," ");
  print "数组长度："length(tA),lens;
  }'
#tA 为数组名称 
#数组长度：4 4

sprintf函数
sprintf主要用于返回格式化后的字符串;其中格式化字符串包括两部分内容：

一部分是正常字符，这些字符将按原样输出;
另一部分是格式化规定字符，以”%”开始，后跟一个或几个规定字符,用来确定输出内容格式。

基础示例：

#printf与sprintf的不同
awk 'BEGIN{n1=124.113;n2=-1.224;n3=1.2345; printf("%.2f,%.2u,%.2g,%X,%on",n1,n2,n3,n1,n1);}'
124.11,18446744073709551615,1.2,7C,174

awk 'BEGIN{n1=124.113;n2=-1.224;n3=1.2345; S1=sprintf("%.2f,%.2u,%.2g,%X,%on",n1,n2,n3,n1,n1);print S1}'
124.11,18446744073709551615,1.2,7C,174n

一般函数

格式	描述
close( Expression )	用同一个带字符串值的 Expression 参数来关闭由 print 或 printf 语句打开的或调用 getline 函数打开的文件或管道。如果文件或管道成功关闭，则返回 0；其它情况下返回非零值。如果打算写一个文件，并稍后在同一个程序中读取文件，则 close 语句是必需的。
system(command )	执行 Command 参数指定的命令，并返回退出状态。等同于 system 子例程。
Expression	getline [ Variable ]	从来自 Expression 参数指定的命令的输出中通过管道传送的流中读取一个输入记录，并将该记录的值指定给 Variable 参数指定的变量。如果当前未打开将 Expression 参数的值作为其命令名称的流，则创建流。创建的流等同于调用 popen 子例程，此时 Command 参数取 Expression 参数的值且 Mode 参数设置为一个是 r 的值。只要流保留打开且 Expression 参数求得同一个字符串，则对 getline 函数的每次后续调用读取另一个记录。如果未指定 Variable 参数，则 $0 记录变量和 NF 特殊变量设置为从流读取的记录。
getline [ Variable ] < Expression	从 Expression 参数指定的文件读取输入的下一个记录，并将 Variable 参数指定的变量设置为该记录的值。只要流保留打开且 Expression 参数对同一个字符串求值，则对 getline 函数的每次后续调用读取另一个记录。如果未指定 Variable 参数，则 $0 记录变量和 NF 特殊变量设置为从流读取的记录。
getline [ Variable ]	将 Variable 参数指定的变量设置为从当前输入文件读取的下一个输入记录。如果未指定 Variable 参数，则 $0 记录变量设置为该记录的值，还将设置 NF、NR 和 FNR 特殊变量。

asort函数
描述：asort对数组进行排序，并且返回数组长度。

awk 'BEGIN{
  info="it is a test";
  split(info,tA," ");
  print asort(tA);
  }'
#4

getline函数
用法：输出重定向需用到getline函数。getline从标准输入、管道或者当前正在处理的文件之外的其他输入文件获得输入。它负责从输入获得下一行的内容，并给NF/NR和FNR等内建变量赋值。

getline语法：

1 2	awk getline getline var #变量var包含了特定行的内容。

返回值：

如果得到一条记录getline函数返回1，
如果到达文件的末尾就返回0，
如果出现错误，例如打开文件失败，就返回-1。

用法说明：

当其左右无重定向符|或<时：getline作用于当前文件，读入当前文件的第一行给其后跟的变量var或$0（无变量），应该注意到，由于awk在处理getline之前已经读入了一行，所以getline得到的返回结果是隔行的。
-当其左右有重定向符|或<时：getline则作用于定向输入文件，由于该文件是刚打开，并没有被awk读入一行，只是getline读入，那么getline返回的是该文件的第一行而不是隔行。

基础示例：

#示例1.执行shell的date命令，并通过管道输出给getline，然后getline从管道中读取并将输入赋值给out： 
/tmp> awk 'BEGIN{ "date" | getline out; print out }' test
Fri Jul 19 12:22:37 CST 2019
/tmp> awk 'BEGIN{ "id" | getline out; print out }' test
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(lxd),114(netdev)


#示例2.命令ls的输出传递给geline作为输入，循环使getline从ls的输出中读取一行，并把它打印到屏幕。
awk 'BEGIN{ while( "ls" | getline) print }' #没有输入文件，因为BEGIN块在打开输入文件前执行，所以可以忽略输入文件。
# npm-252-6a2b6463
# test.txt
awk 'BEGIN{ while( "cat /etc/passwd" | getline) print }' | head -5
# root:x:0:0:root:/root:/bin/zsh
# daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
# bin:x:2:2:bin:/bin:/usr/sbin/nologin
# sys:x:3:3:sys:/dev:/usr/sbin/nologin
# sync:x:4:65534:sync:/bin:/bin/sync


#示例3.接受来之stdin的输入(值得学习)
awk 'BEGIN{printf "Enter your name:";getline name;print "My name is "name;}'
Enter your name:WeiyiGeek
My name is WeiyiGeek

close函数
描述:awk中允许在程序中关闭一个输入或输出文件，方法是使用awk的close语句。
filename可以是getline打开的文件:close("filename")

也可以是stdin，包含文件名的变量或者getline使用的确切命令。
或一个输出文件可以是stdout，包含文件名的变量或使用管道的确切命令。

基础示例：

$awk 'BEGIN{while("cat /etc/passwd"|getline){print $0;};close("/etc/passwd");}'
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin


# 逐行读取外部文件(getline使用方法）
awk 'BEGIN{while(getline < "/etc/passwd"){print $0;};close("/etc/passwd");}'
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin

system函数
描述：主要运用于调用外部应用程序，非常有用值得借鉴学习;

#示例1
awk 'BEGIN{b=system("ls -al");print b;}'
# total 42092
# drwxr-xr-x 14 chengmo chengmo     4096 09-30 17:47 .
# drwxr-xr-x 95 root   root       4096 10-08 14:01 ..

#示例2:补充案例修改 (去除![] 和 ()),变量处有$符号   
git ls-files | grep ".md" | xargs sed -i "s#wxx.com#xxx.cn#g"
git ls-files | grep ".md" | xargs grep "xxx.myqcloud.com" | awk -F "[:/]"  '{if($NF >= 2019072515){print $0}}' > text.txt
awk -F ":" '{ $cmd="sed s#"$2"#1/"$2"#g " $1; print $cmd;}' text.txt
awk -F ":" '{ $cmd="sed -i s#"$2"#1/"$2"#g " $1; system($cmd); }' text.txt

时间函数

mktime( YYYY MM dd HH MM ss[ DST]) 生成时间格式
strftime([format [, timestamp]]) 格式化时间输出，将时间戳转为时间字符串具体格式，见下表.
systime() 得到时间戳,返回从1970年1月1日开始到当前时间(不计闰年)的整秒数

strftime日期和时间格式说明符

格式	描述
%a	星期几的缩写(Sun)
%A	星期几的完整写法(Sunday)
%b	月名的缩写(Oct)
%B	月名的完整写法(October)
%c	本地日期和时间
%d	十进制日期
%D	日期 08/20/99
%e	日期，如果只有一位会补上一个空格
%H	用十进制表示24小时格式的小时
%I	用十进制表示12小时格式的小时
%j	从1月1日起一年中的第几天
%m	十进制表示的月份
%M	十进制表示的分钟
%p	12小时表示法(AM/PM)
%S	十进制表示的秒
%U	十进制表示的一年中的第几个星期(星期天作为一个星期的开始)
%w	十进制表示的星期几(星期天是0)
%W	十进制表示的一年中的第几个星期(星期一作为一个星期的开始)
%x	重新设置本地日期(08/20/99)
%X	重新设置本地时间(12：00：00)
%y	两位数字表示的年(99)
%Y	当前月份
%Z	时区(PDT)
%%	百分号(%)

基础示例：

#建指定时间(mktime使用）
awk 'BEGIN{
  tstamp=mktime("2001 01 01 12 12 12");
  print strftime("%c",tstamp);
}'
2001年01月01日 星期一 12时12分12秒

#返回两个时间只差利用mktime与systime
awk 'BEGIN{tstamp1=mktime("2001 01 01 12 12 12");tstamp2=mktime("2001 02 01 0 0 0");print tstamp2-tstamp1;}'
2634468
awk 'BEGIN{tstamp1=mktime("2001 01 01 12 12 12");tstamp2=systime();print tstamp2-tstamp1;}' 
308201392

#strftime使用
awk 'BEGIN{ print strftime("%c",systime()) }'
# Fri 19 Jul 2019 05:06:09 PM CST
awk 'BEGIN{tstamp=systime();print strftime("%c",tstamp);}'
awk 'BEGIN{tstamp=systime();print strftime("%j",tstamp);}'


ls | awk '{ len=split($1,images,".");
filename=images[1];
suffix=images[len];
tstamp=systime();
datetime=strftime("%Y%m%d%H%M%S",tstamp)"."suffix;
cmd="echo "$1" "datetime">> 1.txt & mv "$1" "datetime" & sleep 1";
system(cmd);
print cmd;
}'

while read line 
do
old=$(echo ${line}|cut -f1 -d " ")
new=$(echo ${line}|cut -f2 -d " ")
sed -i "s#index_files/${old}#https://cdn.jsdelivr.net/gh/WeiyiGeek/blogimage/2019/wiz1/${new}#g" 常见编程语言对字符编码解码一览表.md
done < 1.txt

0x08 awk高级利用

实践扩展

1.读取下一条记录-{next}
awk中在循环逐行匹配里如果遇到next语句就会直接跳入到下一行，一般用于多行合并;

#示例0.当记录行号除以2余1，就跳过当前行下面的print NR,$0也不会执行
#下一行判断NR%2值,这个时候记录行号是：2 ，就会执行下面语句块：'print NR,$0'.
$blog> seq 5 | awk 'NR%2==1{next}{print "第"NR"行",$0;}'
第2行 2
第4行 4

#示例2
$cat test.txt
web01[192.168.2.100]
httpd            ok
tomcat               ok
sendmail               ok
web02[192.168.2.101]
httpd            ok
postfix               ok
web03[192.168.2.102]
mysqld            ok
httpd               ok

# next是关键注意单算引号得使用,如果存在web字符串的行则将值赋给T，然后进入下一次循环
awk '/^web/{T=$0;next;}{print T":"$0;}' test.txt  
web01[192.168.2.100]:httpd            ok
web01[192.168.2.100]:tomcat           ok
web01[192.168.2.100]:sendmail         ok
web02[192.168.2.101]:httpd            ok
web02[192.168.2.101]:postfix          ok
web03[192.168.2.102]:mysqld           ok
web03[192.168.2.102]:httpd            ok

2.记录输出

1
2
3

#示例1.输出内容到一个文件
echo | awk '{print("Hello World!\n") >> "date"}';cat date
Hello World!

3.利用awk进行xml文件解析

cat <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>top.weiyigeek</groupId>
  <artifactId>Platform</artifactId>
  <version>1.0.0</version>
  <packaging>jar</packaging>
</project>
EOF

# 使用示例
awk '/<\/*name\/*>/{gsub(/[[:space:]]*<\/*name\/*>/,"");print $0}' pom.xml | head -n 1
awk '/<\/*artifactId\/*>/{gsub(/[[:space:]]*<\/*artifactId\/*>/,"");print $0}' pom.xml | head -n 1
awk '/<\/*version\/*>/{gsub(/[[:space:]]*<\/*version\/*>/,"");print $0}' pom.xml | head -n 1
awk '/<\/*packaging\/*>/{gsub(/[[:space:]]*<\/*packaging\/*>/,"");print $0}' pom.xml | head -n 1

3.shell去除字符串中最后一个字符

# 方式1.awk
echo "www.weiyigeek.top-" | awk '{sub(/.$/,"")}1'
www.weiyigeek.top

# 方式2.sed
echo "www.weiyigeek.top-" | sed 's/.$//'
www.weiyigeek.top

awk脚本

采用awk -f选项来指定脚本文件，注意蛇棒是#/bin/awk

示例1：采用脚本文件输出数组

cat >> awk.script <<END
BEGIN {
  array[1]="Weiyi";
  array[2]="geek";

  for(item in array)
  {
    print "Key:"item,"Value:"array[item]
  }
    print "arr = "arr;
}
END

# 执行命令及其效果
$ awk -f awk.script -v arr="add"  #注意后面设置的变量
Key:1 Value:Weiyi
Key:2 Value:geek
arr = add  #关键点

# 检查是否设置除 root 之外 UID 为 0 的用户, 其条件值得学习。
cat /etc/passwd | awk -F: '($3 == 0) { print $1 }'

欢迎各位志同道合的朋友一起学习交流，如文章有误请在下方留下您宝贵的经验知识，个人邮箱地址【master#weiyigeek.top】或者个人公众号【WeiyiGeek】联系我。

更多文章来源于【WeiyiGeek Blog - 为了能到远方，脚下的每一步都不能少】, 个人首页地址( https://weiyigeek.top )

扫描Follow(关注)WeiyiGeek公众号与Visit(浏览)极客全栈修炼小程序

专栏书写不易，如果您觉得这个专栏还不错的，请给这篇专栏 【点个赞、投个币、收个藏、关个注、转个发、赞个助】，这将对我的肯定，我将持续整理发布更多优质原创文章！。

最后更新时间：2023-03-13 12:02:59
文章原始路径：_posts/系统运维/Linux/常用命令/脚本常用类命令/awk三剑客入门与进阶实践指南.md
转载注明出处，原文地址：https://blog.weiyigeek.top/2019/6-26-175.html
本站文章内容遵循知识共享署名 - 非商业性 - 相同方式共享 4.0 国际协议

WeiyiGeek