[toc]

awk每日练

先熟练一些操作

1、以空格做为分格符，打印passwd 文件的第一列

#  awk '{print $1}' /etc/passwd

2、以冒号做分格符，打印passwd 文件的第一列,即获取当前系统中存在的所有用户

 # awk -F: '{print $1}' /etc/passwd

3、以管道方式，打印passwd 文件的第三列，即共获取当前系统中所有用户的id号

#  cat /etc/passwd | awk -F : '{print $3}'

4、以输入重定向方式，打印 passwd 文件的第1列，即获取当前系统中存在的所有用户

# awk -F: '{print $1}' < /etc/passwd

5、用awk 自带BEGIN打印 hello awk 字符串

#  awk 'BEGIN{print "hello awk"}' 执行只办输出hello awk

6、用awk 获取df 命令的filesystem 与userd %

# df | awk '{print $1,$5}'  
# df | awk '{print $1 $5}'  # 注意这样输出信息就连接到一块了
    FilesystemUse%
    /dev/vda113%
    devtmpfs0%
    tmpfs0%
    tmpfs1%
    tmpfs0%
    tmpfs0%
# df | awk '{print $1"==="$5}' #  在两个位置变量的中间加入三个=== 号
    Filesystem===Use%
    /dev/vda1===13%
    devtmpfs===0%
    tmpfs===0%
    tmpfs===1%
    tmpfs===0%
    tmpfs===0%
 # df | awk '{print $1"\t"$5}'  # 在两个位置变量的中间加入一个tab 键
    Filesystem      Use%
    /dev/vda1       13%
    devtmpfs        0%
    tmpfs   0%
    tmpfs   1%
    tmpfs   0%
    tmpfs   0%

7、结合tail 命令来进行字符串切割

#  tail -4 /etc/fstab | awk '{print $3,$4}'

8、手动指定分隔符为: ，打印第一列:第三列，FS 即指定分隔符

# awk -v FS=":" '{print $1,FS,$3}' /etc/passwd

9、将列出分符，改为其它的字符

#  awk -v FS=":" -v OFS="uid is " '{print $1,FS,$3}' /etc/passwd

10 、以空格做为换行符，取其第一个字段

# awk -v RS=" " '{print $1}' text.txt

11、将记录输出分隔符默认值”\n”，换成”===”

#  awk -v FS=":" -v ORS"===" '{print $1}' /etc/passwd

12、截取/etc/passwd 的登录shell

# awk -v FS=":" '{print $NF-1}' /etc/passwd

13、截取 /etc/passwd 的家目录

#  awk -v FS=":" '{print $(NF-1)}' /etc/passwd

14、截取指定字段并打印awk 内置变量

# awk -v RS=":" '{print RS,NR,$0}' /etc/passwd

15、以冒号分隔记录当前字段个数并进行计算

 # awk -v FS=":" '{print NF*5}' /etc/passwd

16、统计当前输入文件的个数

# awk -F: '{print FNR}' /etc/passwd /etc/shadow

17、打印两文件输出的行数

# awk -F: '{print FNR,$1}' /etc/passwd /etc/shadow

18、输出两文件的文件名行号及对应用的用户名

#  awk -F: '{print FILENAME,FNR,$1}' /etc/passwd /etc/shadow

19、统计命令行参数的个数

# awk -F: 'BEGIN{print ARGC}' /etc/passwd /etc/group 
    3

20、打印命令行参数的内容

 # awk -F: 'BEGIN{print ARGV[2]}' /etc/passwd /etc/group 
    /etc/group

awk变量自定义变量区分大小写

21、指定变量调用打印

# awk -F: -v name="username" '{print name":"$1}' /etc/passwd

22 、指定多个变量调用打印，并加入制表符

# awk -F: -v name="username" -v uid="uid " '{print name":"$1"\t"uid":"$3}' /etc/passwd
# awk -F: '{n="username";uid="userid"; print n ":"$1"\t"uid":"$3}' /etc/passwd

了解一下以下的练习
awk -F: ‘{n=”haha”; print n,m;m=”xixi”}’ /etc/passwd 变量后定义也行（表面上可用，但实际上有问题：第一次循环）
awk -F: ‘BEGIN{n=”haha”;hehe=100;m=200;print n,m}’ /etc/passwd

23、 printf 指定输出格式

# awk -F: '{printf "%s == %d\n",$1,$3}' /etc/passwd %格式与$字符必须一一对应
# awk -F: '{printf "%s20s == %d\n",$1,$3}' /etc/passwd 右对齐
# awk -F: '{printf "%s-20s == %d\n",$1,$3}' /etc/passwd 左对齐
# awk -F: '{printf "%s-20s == %10.3f\n",$1,$3}' /etc/passwd 小数位的宽度
# awk -F: '{printf "%s-20s == %+df\n",$1,$3}' /etc/passwd
# awk -F : '{printf "%s\n",$1}' /etc/passwd 
# awk -F : '{printf "Username: %s\n",$1}' /etc/passwd

24、awk 数术运算操作

# awk 'BEGIN{print 2^10}'
# awk 'BEGIN{n=1;m=2;print m+=n}' 
# awk 'BEGIN{n=1;m=2;print m++;print m}' 
# awk 'BEGIN{n=1;m=2;print ++m;print m}' 
# awk -F: '$3 > 1000{print $1,$3}' /etc/passwd 
# awk -F: '$3==0{print $1,$3}' /etc/passwd 
# awk -F: '$0~"root"{print $1,$3}' /etc/passwd ~包涵
# awk -F: '$0~/root/{print $0}' /etc/passwd 
# awk -F: '$0~/^root/{print $0}' /etc/passwd 
# awk -F: '$0 !~/^root/{print $0}' /etc/passwd 
# awk -F : '$0 ~ /root/' /etc/passwd

25、操作符 && 两都执行 ||

# awk -F: '$3==0 || $3 >=1000 {print $1}' /etc/passwd 
# awk -F: !('$3==0 || $3 >=1000) {print $1}' /etc/passwd  or 
# awk -F : '$3>1 && $3 <1000 {print $1}' /etc/passwd

26、条件表达式三目

# awk -F: '$3<1000?var="sysuser": var="commonuser"{print var":"$1,$3}' /etc/passwd

27、常用语法练习

# awk -F: '{print $1}' /etc/passwd 
# awk -F: '/^root/{print $0}' /etc/passwd 
# awk '/^U/{print $1}' /etc/fstab 
# awk '!/^U/{print $1}' /etc/fstab 
# awk '" "{print $0}' /etc/fstab 
# awk 'i=1;j=1{print i,j}' /etc/fstab 把文件打印两次
# awk ‘i=1;j=0{print i,j}’ /etc/fstab 
# awk 'i=1;j=1{print i,j}' /etc/fstab 
# awk '!2' /etc/fstab 
# awk '"abc"' /etc/fstab 
# awk -F: '$NF=="/bin/bash"' /etc/passwd 
# awk -F: '$NF~"/bin/bash"  /etc/passwd 
# awk -F: '$NF!~"/bin/bash"  /etc/passwd 
# awk -F: '/^root/,/^ftp/' /etc/passwd 
# awk -F: '/^root\>/,/^ftp/' /etc/passwd  注：\b 不行
# awk -F: 'NR>=10&&NR<=30{print NR}' /etc/passwd

28、比较绕的练习

# awk -F: 'NR>=10&&NR<=30{print NR,$0}' /etc/passswd 
# awk -F: 'BEGIN{print "linenumber usernmae"}NR>=10&&NR<=30{print NR,$1}' /etc/passwd 
# awk -F: 'BEGIN{print "linenumber username"}NR>=10&&NR<=30{print NR,$1} END print "end"}' /etc/passwd 
# awk -F: '{print "linenumber username";print NR,$1}END{print "end"}' /etc/passwd
# awk -F: '{print "linenumber username\n-------------";print $1}END{print "end"}' /etc/passwd 
# seq 10 | awk '{i=!i;print i}'
# seq 10 | awk 'i=!i'
# seq 10 | awk '!(i=!i)'
# seq 10 | awk -v -i=1 'i=!i'

29、常见循环与用法

# awk 'BEGIN{for(i=1;i<=100;i++)sum+=i;print sum}'
# echo {1..100}|sed 's/ /+/g'|bc
# echo {1..100}| tr " " "+" |bc 
#!/bin/bash
num=0
for i in `seq 100`; do 
    num=$[$num+$i]
    echo $i
done
echo $num
#!/usr/bin/env python2.7
num=0
for i in range(1,101):
    print i
    num = num + i
print num

AWK 基础

awk：Aho, Weinberger, Kernighan，报告生成器，格式化文本输出
有多种版本：New awk（nawk）,GNU awk（gawk）
gawk：模式扫描和处理语言

基本用法

# awk [options] 'program' var=value file…
# awk [options] -f programfile var=value file…
# awk [options] 'BEGIN{ action;… } pattern{ action;… } END{ action;… }' file ...

awk程序通常由：BEGIN语句块、能够使用模式匹配的通用语句块、END语句块，共3部分组成
program通常是被单引号或双引号中
选项：
-F:指明输入时用到的字段分隔符
-v var=value:自定义变量

awk语言

基本格式：awk [options] ‘program’ file…
program:pattern{action statements;..}
pattern和action：
pattern部分决定动作语句何时触发及触发事件
```
  BEGIN,END
```
action statements 对数据进行处理，放在{}内指明
print, printf

分割符、域和记录
awk执行时，由分隔符分隔的字段（域）标记$1,$2..$n称为域标识。$0为所有域，注意：和shell中变量$符含义不同
文件的每一行称为记录
省略action行，则默认执行print $0的操作

awk工作原理

第一步：执行BEGIN{action;… } 语句块中的语句
第二步：从文件或标准输入(stdin)读取一行，然后执行pattern{ action;
… } 语句块，它逐行扫描文件，从第一行到最后一行重复这个过程，直到文件全部被读取完毕。
第三步：当读至输入流末尾时，执行END{action;…}语句块
BEGIN语句块在awk开始从输入流中读取行之前被执行，这是一个可选的语句块，比如变量初始化、打印输出表格的表头等语句通常可以写在BEGIN语句块中
END语句块在awk从输入流中读取完所有的行之后即被执行，比如打印所有行的分析结果这类信息汇总都是在END语句块中完成，它也是一个可选语句块
pattern语句块中的通用命令是最重要的部分，也是可选的。如果没有提供pattern语句块，则默认执行{ print }，即打印每一个读取到的行，awk读取的每一行都会执行该语句块

awk 格式

要点：
(1)逗号分隔符
(2)输出的各item可以字符串，也可以是数值；当前记录的字段、变量或awk的表达式
(3)如省略item，相当于print $0

示例:

# awk '{print "hello,awk"}'
# awk -F: '{print}' /etc/passwd
# awk -F: '{print "wang"}' /etc/passwd
# awk -F: '{print $1}' /etc/passwd
# awk -F: '{print $0}' /etc/passwd
# awk -F: '{print $1"\t"$3}' /etc/passwd
# tail -3 /etc/fstab |awk  '{print $2,$4}'

awk 变量

变量：内置和自定义变量

模式	例子	匹配
BEGIN	BEGIN	输入被读取之前
END	END	所有输入被读取之后
expression	$3>100	第三个字段大于100
string-matching	/Asia/	含有Asia的行
compound	$3<100 && $4 ==”Asia”	第三个字段小于100且第四个字段含有Asia的行
range	NR == 10,NR==20	输入的第10行到20行

变量	意义	默认值
FS	控制输入行的字段分隔符	“ “
OFS	输出字段分隔符	“ “
RS	控制着输入行的记录分隔符	“\n”
NF	当前记录的字段个数	-
NR	到目前为止读的记录数量	-
FNR	当前输入文件的记录个数	-
ARGC	命令行参数的个数	-
ARGV	命令行参数数组	-
FILENAME	当前输入文件名	-
OFMT	数值的输出格式	“%.6g”
RLENGTE	被函数match匹配的字符串的长度	-
RSTART	被函数match匹配的字符串的开始	-
SUBSEP	下标分隔符	“\034”

FS：输入字段分隔符，默认为空白字符

# awk -v FS=':' '{print $1,FS,$3}' /etc/passwd
# awk -F: '{print $1,$3,$7}' /etc/passwd
# s=:;awk -v FS=$s '{print $1 FS $3}' /etc/passwd

OFS：输出字段分隔符，默认为空白字符

# awk -v FS=':' -v OFS=':' '{print $1,$3,$7}' /etc/passwd

RS：输入记录分隔符，指定输入时的换行符，原换行符仍有效

#  awk -v RS=' ' '{print }' /etc/passwd

ORS：输出记录分隔符，输出时用指定符号代替换行符

# awk -v RS=' ' -v ORS='###'‘{print}’ /etc/passwd

NF：字段数量

# awk -F:'{print NF}' /etc/fstab, 引用内置变量不用$
# awk -F: '{print $(NF-1)}' /etc/passwd

NR：行号

# awk '{print NR}' /etc/fstab; awk END'{print NR}' /etc/fstab

FNR：各文件分别计数, 行号

# awk '{print FNR}' /etc/fstab /etc/inittab

FILENAME：当前文件名

# awk '{print FILENAME}' /etc/fstab

ARGC：命令行参数的个数

# awk '{print ARGC}' /etc/fstab /etc/inittab
# awk 'BEGIN {print ARGC}' /etc/fstab /etc/inittab

ARGV：数组，保存的是命令行所给定的各参数

# awk 'BEGIN {print ARGV[0]}' /etc/fstab /etc/inittab
# awk 'BEGIN {print ARGV[1]}' /etc/fstab /etc/inittab

自定义变量(区分字符大小写)
(1) -v var=value
(2) 在program中直接定义

示例:

# awk -v test='hello gawk' '{print test}' /etc/fstab
# awk -v test='hello gawk' 'BEGIN{print test}'
# awk 'BEGIN{test="hello,gawk";print test}'
# awk -F:‘{sex=“male”;print $1,sex,age;age=18}’ /etc/passwd
# cat awkscript 
      {print script,$1,$2}
        awk -F: -f awkscript script=“awk” /etc/passwd

printf 参数

格式化输出：printf “FORMAT”, item1, item2, …
(1)必须指定FORMAT
(2)不会自动换行，需要显式给出换行控制符，\n
(3)FORMAT中需要分别为后面每个item指定格式符
格式符：与item一一对应

格式符	意义
%c	显示字符的ASCII码
%d,%i	显示十进制整数
%e,%E	显示科学计数法数值
%f	显示为浮点数
%g,%G	以科学计数法或浮点形式显示数值
%s	显示字符串
%u	无符号整数
%%	显示%自身

修饰符：

[.#]：第一个数字控制显示的宽度；第二个#表示小数点后精度，%3.1f
-: 左对齐（默认右对齐） %-15s
+：显示数值的正负符号 %+d

printf示例

# awk -F: '{printf "%s",$1}' /etc/passwd
# awk -F: '{printf "%s\n",$1}' /etc/passwd
# awk -F: '{printf "%-20s %10d\n",$1,$3}' /etc/passwd
# awk -F: '{printf "Username: %s\n",$1}' /etc/passwd
# awk -F: '{printf “Username: %s,UID:%d\n",$1,$3}’ /etc/passwd
# awk -F: '{printf "Username: %15s,UID:%d\n",$1,$3}' /etc/passwd
# awk -F: '{printf "Username: %-15s,UID:%d\n",$1,$3}' /etc/passwd

操作符表达式

初等表达式包括
数值与字符串常量, 变量, 字段, 函数调用, 数组元素.
可以把表达式组合起来的运算符包括
赋值运算符 = += -= = /= %= ^= 条件表达式 ?:
逻辑运算符 || (OR), && (AND), ! (NOT)
匹配运算符 ~ 和!~
关系运算符 < <= == != > >=
拼接运算符 (没有显式的拼接运算符)
算术运算符 + - / % ^
单目运算符 +和-
自增与自减运算符++和—(包括前缀与后缀)
括号 (用于分组)

操作	运算符	例子	例子的含义
赋值	= += -= *= /= %= ^=	x *= 2	x = x * 2
条件表达式	?:	x ? y : z	若x为真,则 y,否则z
逻辑与	&&	x && y	若x与y都为真, 则为1,否则为0
数组成员	in	i in a	如果a[i]存在, 则为1,否则为0
匹配	~ !~	$1 ~ /x/	如果第一个字段包含x,则为1,否则为0
关系运算	< <= == != >= >	x == y	如果x等于y,则为1, 否则为0

拼接	“a” “bc”	“abc”	不存在显式的拼接运算符
减法, 加法	+ -	x + y	x与y的和

乘法, 除法, 取模	* / %	x % y	x除以y的余数
单目加, 单目减	+ -	-x	x的相反数
逻辑非	!	!$1	若$1为空或为0, 则为1,否则为0
指数运算	^	x ^ y	x的y次方
自增, 自减	++ —	++x, x++	为x加1
字段	$	$i+1	1加上第i个字段的值
组	( )	($i)++	给第i个字段的值加1

算术操作符：
x+y, x-y, x*y, x/y, x^y, x%y
-x:转换为负数
+x:转换为数值

字符串操作符：没有符号的操作符，字符串连接

赋值操作符：
=, +=, -=, *=, /=, %=, ^=
++, —

比较操作符：
==, !=, >, >=, <, <=

模式匹配符
~：左边是否和右边匹配包含
!~ ：是否不匹配

示例：

# awk –F: '$0 ~ /root/{print $1}‘ /etc/passwd
# awk '$0~"^root"' /etc/passwd
# awk '$0 !~ /root/' /etc/passwd
# awk -F: '$3==0' /etc/passwd

逻辑操作符：
&& 与
|| 或
！非

示例：

# awk -F: '$3>=0 && $3<=1000 {print $1}' /etc/passwd
# awk -F: '$3==0 || $3>=1000 {print $1}' /etc/passwd
# awk -F: ‘!($3==0) {print $1}' /etc/passwd
# awk -F: ‘!($3>=500) {print $3}' /etc/passwd
# awk -F: '$3 > 100 && $3<1000 {print $1,$3}' passwd

函数调用

function_name(argu1, argu2, ...)
条件表达式（三目表达式）   
    selector?if-true-expression:if-false-expression

示例：

awk -F: '{$3>=1000?usertype="Common User":usertype="Sysadmin or SysUser";printf "%15s:%-s\n",$1,usertype}' /etc/passwd
awk -F: '{$3>1000?username="common user:":username="sysuser:";
printf "%s %-30s %d\n",username,$1,$3}' passwd

正则表达式

正则表达式的元字符包括：
\ ^ $ . [] | () * + ?
一个基本的正则表达式包括以下几种：
一个不是元字符的字符，例如A，这个正则表达式匹配的就是它本身；
一个匹配特殊字符的转义字符：\t匹配一个制表符
一个被引用的元字符，例如*，按字面意义匹配元字符
^ 匹配一行的开始
$ 匹配一行的结束
. 匹配任意一个字符
一个字符类:[ABC]匹配字符A、B或C
字符类可能包能包含缩写格式：[A-Za-z]匹配单个字母
一个互补的字符类:^0-9 匹配任意一个字符，但除了数字
运算符组合起来使用
选择：A|B 匹配A或B
拼接：AB匹配后面紧跟着B的A
闭包：A*匹配0个或多个A
正必包：A+匹配一个或多个A
零或一：A？匹配空字符串或A
括号：被(r)匹配的字符串，与r所匹配的字符串相同
优先级
选择运算符|优先级最低，然后是拼接运算，最后是重复运算+，*与？；
转义序列

序列	意义
\b	退格
\f	换页
\n	换行
\r	回车
\t	制表符
\ddd	八进制数ddd.ddd含有1到3个数字，每个数字的值在0-7之间
\c	其他字面意义上的c（如\表示,”表示双引号）

示例

^[^^] 匹配不以脱字符开始的字符串
/^[0-9]+$/ 匹配含有且只含有数字的输入行
/^[0-9][0-9][0-9]$/ 输入行有且仅有 3 个数字.
/^(\+|-)?[0-9]+\.?[0-9]*$/ 十进制小数, 符号与小数部分是可选的.
/^[+-]?[0-9]+[.]?[0-9]*$/ 也是匹配十进制小数, 带有可选的符号与小数部分.
/^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eE][+-]?[0-9]+)?$/ 浮点数, 符号与指数部分是可选的.
/^[A-Za-z][A-Za-z0-9]*$/ 一个字母, 后面再跟着任意多个字母或数字 (比如awk的变量名).
/^[A-Za-z]$|^[A-Za-z][0-9]$/ 一个字母, 又或者是一个后面跟着一个数字的字母 (比如 Basic 的变量名).
/^[A-Za-z][0-9]?$/ 同样是一个字母, 又或者是一个后面跟着一个数字的字母

awk PATTERN

PATTERN: 根据pattern条件，过滤匹配的行，再做处理
(1) 如果未指定：空模式，匹配每一行
(2) /regular expression/ ：仅处理能够模式匹配到的行，需要用/ / 括起来
```
  awk '/^UUID/{print $1}' /etc/fstab
  awk '!/^UUID/{print $1}' /etc/fstab
```
(3) relational expression: 关系表达式，结果为“真”才会被处理
```
  真：结果为非0值，非空字符串
  假：结果为空字符串或0值
```

示例

# awk -F: 'i=1;j=1{print i,j}' /etc/passwd
# awk ‘!0’ /etc/passwd ; awk ‘!1’ /etc/passwd
# awk –F: '$3>=1000{print $1,$3}' /etc/passwd
# awk -F: '$3<1000{print $1,$3}' /etc/passwd
# awk -F: '$NF=="/bin/bash"{print $1,$NF}' /etc/passwd
# awk -F: '$NF ~ /bash$/{print $1,$NF}' /etc/passwd

(4) line ranges：行范围

startline,endline
        /pat1/,/pat2/
# awk -F: '/^root\>/,/^nobody\>/{print $1}' /etc/passwd
注意：不支持直接给出数字格式
# awk -F: '(NR>=10&&NR<=20){print NR,$1}' /etc/passwd

(5) BEGIN/END 模式
BEGIN{}: 仅在开始处理文件中的文本之前执行一次
END{}：仅在文本处理完成之后执行一次

示例

# awk -F : 'BEGIN {print "USER USERID"} {print $1":"$3} END{print "end file"}' /etc/passwd
# awk -F : '{print "USER USERID“;print $1":"$3} END{print "end file"}' /etc/passwd
# awk -F: 'BEGIN{print " USER UID \n--------------- "}{print $1,$3}' /etc/passwd
# awk -F: 'BEGIN{print " USER UID \n--------------- "}{print $1,$3}'END{print "=============="} /etc/passwd 
#  seq 10 |awk ‘i=0’
# seq 10 |awk ‘i=1’
# seq 10 | awk 'i=!i‘
# seq 10 | awk '{i=!i;print i}‘
# seq 10 | awk ‘!(i=!i)’
# seq 10 |awk -v i=1 'i=!i'

模式总结

模式	例子	匹配
BEGIN	BEGIN	输入被读取之前
END	END	所有输入被读取之后
expression	$3>100	第三个字段大于100
string-matching	/Asia/	含有Asia的行
compound	$3<100 && $4 ==”Asia”	第三个字段小于100且第四个字段含有Asia的行
range	NR == 10,NR==20	输入的第10行到20行

awk action

常用的action分类
    (1) Expressions: 算术，比较表达式等
    (2) Control statements：if,while等
    (3) Compound statements：组合语句
    (4) input statements
    (5) output statements：print等

awk控制语句

{ statements;… }  组合语句
    if(condition) {statements;…}
    if(condition) {statements;…} else {statements;…}
    while(conditon) {statments;…}
    do {statements;…} while(condition)
    for(expr1;expr2;expr3) {statements;…}
    break
    continue
    next 开始输入主循环的下一次迭代
    delete array[index]
    delete array
        exit
    exit expression 马上执行END 动作; 如果已经在END动作内, 那就退出程序. 将expression作为程序的退出状态返回.

if-else

 语法：
        if(condition){statement;…}[else statement]
        if(condition1){statement1}else if(condition2){statement2}
            else{statement3}
    使用场景：对awk取得的整行或某个字段做条件判断
    示例：
    # awk -F: '{if($3>=1000)print $1,$3}' /etc/passwd
    # awk -F: '{if($NF=="/bin/bash") print $1}' /etc/passwd
    # awk '{if(NF>5) print $0}' /etc/fstab
    # awk -F: '{if($3>=1000) {printf "Common user: %s\n",$1} else {printf "root or Sysuser: %s\n",$1}}' /etc/passwd
    # awk -F: '{if($3>=1000) printf "Common user: %s\n",$1;
            else printf "root or Sysuser: %s\n",$1}' /etc/passwd
        df -h|awk -F% '/^\/dev/{print $1}'|awk '$NF>=80{print $1,$5}‘
    # awk 'BEGIN{ test=100;if(test>90){print "very good"}
            else if(test>60){ print "good"}else{print "no pass"}}'

while循环

语法：
        while(condition){statement;…}
    条件“真”，进入循环；条件“假”， 退出循环
    使用场景：
        对一行内的多个字段逐一类似处理时使用
        对数组中的各元素逐一处理时使用
    示例：
        awk '/^[[:space:]]*linux16/{i=1;while(i<=NF) {print $i,length($i); i++}}' /etc/grub2.cfg

do-while循环

语法：
        do {statement;…}while(condition)
        意义：无论真假，至少执行一次循环体
    示例：
    # awk 'BEGIN{ total=0;i=0;do{ total+=i;i++;}while(i<=100);print total}'
    思考：下面两语句有何不同？
    # awk 'BEGIN{i=0;print ++i,i}'
   # awk 'BEGIN{i=0;print i++,i}'

for循环

语法：
        for(expr1;expr2;expr3) {statement;…}
    常见用法：
        for(variable assignment;condition;iteration process) 
            {for-body}
    特殊用法：能够遍历数组中的元素
        语法：for(var in array) {for-body}
    示例：
        awk '/^[[:space:]]*linux16/{for(i=1;i<=NF;i++) {print $i,length($i)}}' /etc/grub2.cfg
空语句     
单独一个分号表示一个空语句

    在下面这个程序里, for的循环体是一个空语句.
        BEGIN { FS = "\t" }
            { for (i = 1; i <= NF && $i != ""; i++);
                if (i <= NF)
                    print
            }
    这个程序打印所有的, 包含空字段的行.

循环性能比较

time (awk 'BEGIN{total=0;for(i=0;i<=10000;i++){total+=i;};print total;}')
time(total=0;for i in {1..10000};do total=$(($total+i));done;echo $total)
time(for ((i=0;i<=10000;i++));do let total+=i;done;echo $total)
time(seq -s ”+” 10000|bc)

switch语句

语法：
        switch(expression) {case VALUE1 or /REGEXP/: statement1; case VALUE2 or /REGEXP2/: statement2; ...; default: statementn}

break 和continue

# awk ‘BEGIN{sum=0;for(i=1;i<=100;i++) {if(i%2==0)continue;sum+=i}print sum}‘
# awk ‘BEGIN{sum=0;for(i=1;i<=100;i++) {if(i==66)break;sum+=i}print sum}‘

break [n]
continue [n]
next:提前结束对本行处理而直接进入下一行处理（awk自身循环）

# awk -F: '{if($3%2!=0) next; print $1,$3}' /etc/passwd

awk数组

关联数组：array[index-expression]

  index-expression:
  (1)可使用任意字符串；字符串要使用双引号括起来
  (2)如果某数组元素事先不存在，在引用时，awk会自动创建此元素，并将其值初始化为“空串”
  若要判断数组中是否存在某元素，要使用“index in array”格式进行遍历

示例：

weekdays[“mon”]="Monday“
# awk 'BEGIN{weekdays["mon"]="Monday";weekdays["tue"]="Tuesday";print weekdays["mon"]}''
# awk 'BEGIN{weekdays["mon"]="Monday";weekdays["tue"]="tuesday";for(i in weekdays) print weekdays[i]}'    
# awk ‘!arr[$0]++’ dupfile   重复的行只显示一次
# awk '{!arr[$0]++;print $0, arr[$0]}' dupfile

若要遍历数组中的每个元素，要使用for循环
for(var in array) {for-body}
注意：var会遍历array的每个索引
示例：

# awk 'BEGIN{weekdays["mon"]="Monday";weekdays["tue"] ="Tuesday";for(i in weekdays) {print weekdays[i]}}'
#  netstat -tan | awk '/^tcp/{state[$NF]++}END {for(i in state) { print i,state[i]}}'
# awk '{ip[$1]++}END{for(i in ip) {print i,ip[i]}}' /var/log/httpd
/access_log

awk函数

数值处理:
rand()：返回0和1之间一个随机数
awk ‘BEGIN{rand(); for (i=1;i<=10;i++)print int(rand()*100) }’

内建算术函数

函数	返回值
atan2(y,x)	y/x的反正切值, 定义域在 −π到π之间
cos(x)	x的余弦值, x以弧度为单位
exp(x)	x的指数函数,e x
int(x)	x的整数部分; 当x大于0时, 向 0取整
log(x)	x的自然对数(以e为底)
rand()	返回一个随机数r, 0 ≤ r < 1
sin(x)	x的正弦值, x以弧度为单位.
sqrt(x)	x的方根
srand(x)	x是rand() 的新的随机数种子

自定义函数

格式：
        function name ( parameter, parameter, ... ) {
            statements
            return expression
        }
    示例：
        cat fun.awk
            function max(v1,v2) {
                v1>v2?var=v1:var=v2
                         return var
            }
            BEGIN{a=3;b=2;print max(a,b)}
        awk -f fun.awk

awk中调用shell命令

system命令
空格是awk中的字符串连接符，如果system中需要使用awk中的变量可以使用空格分隔，或者说除了awk的变量外其他一律用""引用起来。
# awk BEGIN'{system("hostname") }'
# awk 'BEGIN{score=100; system("echo your score is " score) }'

awk脚本

将awk程序写成脚本，直接调用或执行
示例：
# cat f1.awk
{if($3>=1000)print $1,$3}
# awk -F: -f f1.awk /etc/passwd
# cat f2.awk
    #!/bin/awk -f
        #this is a awk script
        {if($3>=1000)print $1,$3}
#chmod +x f2.awk
#  f2.awk -F: /etc/passwd

向awk脚本传递参数

格式：
        awkfile var=value var2=value2... Inputfile
    注意：在BEGIN过程中不可用。直到首行输入完成以后，变量才可用。可以通过-v参数，让awk在执行BEGIN之前得到变量的值。命令行中每一个指定的变量都需要一个-v参数

示例

# cat test.awk
            #!/bin/awk -f
            {if($3 >=min && $3<=max)print $1,$3}
        chmod +x test.awk
# test.awk -F: min=100 max=200 /etc/passwd

awk 的练习