1-awk入门.md

AWK入门指南

安装AWK

# 使用yum安装
yum install gawk

# 安装后检查是否安装ok
which awk
## 一般输出安装路径是在： /bin/awk

AWK 起步示例

假设存在一个文件 emp.data，其中包含员工的姓名、薪资（美元/小时）以及小时数，一个员工一行数据,其内容如下:

Beth	4.00	0
Dan	3.75	0
kathy	4.00	10
Mark	5.00	20
Mary	5.50	22
Susie	4.25	18

如果想打印出 工作时长超过0小时的员工姓名和工资(薪资乘以时间)，以下命令可以完成:

awk '$3>0 {print $1, $2*$3}'  emp.data

得到如下输出：

kathy 40
Mark 100
Mary 121
Susie 76.5

该命令告诉系统执行括号内的awk程序，从输入文件 emp.data 获取所需要的数据。引号内的部分是个完整的awk程序，包含单个 模式-动作 语句。模式 $3>0 用于匹配第三列大于0的输入行，动作： {print $1, $2*$3} 打印每个匹配行的第一个字段、第二个字段与第三个字段的乘积。

还可以打印没有工作过的员工姓名：

awk '$3==0 {print $1}'  emp.data

将会输出：

Beth
Dan

AWK程序的结构

回过头来看一下上述命令。引号之间的部分是awk编程语言写就的程序。 每个awk程序都是 一个或多个 模式-动作 语句的序列：

pattern {pattern} pattern {pattern} ...

awk 的基本操作是一行一行的扫描输入，搜索匹配任意程序中模式的行。 词语“匹配”的准确意义是视具体的模式而言，对于模式 $3>0 来说，意思是“条件为真”。 每个模式依次测试每个输入行。对于匹配到行的模式，其对应的动作（也许包含多步）得到执行，然后读取下一行并继续匹配，直到所有的输入读取完毕。

模式	动作
$3==0	{print $1}

模式-动作 语句中的 模式或动作（但不是两者同时省略）都可以省略。如果某个模式没有动作，例如：

$3==0

那么模式匹配到的每一行都会被打出来。输出如下：

Beth    4.00    0
Dan     3.75    0

如果是没有动作的模式，例如： {print $1} 则会打印第一列，输出如下：

Beth
Dan
kathy
Mark
Mary
Susie

由于模式和动作两者任一都是可选的，所以需要使用大括号包围动作用以区分其他模式。

执行 awk 程序

执行awk程序有多种，可以输入如下形式的命令行： awk 'program codes' inputfiles 从而在每个指定的输入文件上执行这个program。例如： awk '$3==0 {print $1}' file1 file2 打印 file1 和 file2 文件中第三列为0的每一行的第一个字段。

也可以省略命令行中的输入文件，仅仅输入： awk 'program codes' 在这种情况下，awk 将会应用于你在终端接着输入的任意数据行，直到你输入一个文件结束信号（Unix系统上为control-d）。示例：

awk '$3>0 {print $1}'
Mary 20 1000   #输入该行回车
Mary  # 计算机输出，匹配到了信息
Belly 30 3000  #继续输入改行
Belly #计算机输出

注意事项： 命令行中的程序是用单引号包围着的。这会防止shell解释程序中$这样的字符，也允许程序的长度超过一行。 当程序比较长的时候，可以将程序写入到一个文件，以下命令行： awk -f programfile optional list of input files

其中 -f 选项指示 awk 从指定文件中获取程序。可以使用任意文件名替换 programfile。

awk 的错误提示

如果你的 awk 程序存在错误， awk 会给你一些诊断信息。例如，如果你打错了大括号，如下所示：

awk '$3==0 [print $1}' emp.data 会提示如下错误：

awk: $3==0 [print $1}
awk:       ^ syntax error
awk: $3==0 [print $1}
awk:                ^ syntax error

简单输出

awk中仅仅只有两种类型 数值、 字符 构成的字符串。通常情况下，一个字段是一个不包含任何空格或制表符的连续字符序列。 当前输入的 行中的第一个字段被称作 $1，第二个是 $2，以此类推。 整个行的内容被定义为 $0。 每一行的字段数量可以不同。

大都数情况下，我们仅仅只是打印出其中每一行的某些字段，或者也还需要做一些计算。

打印每一行

如果一个动作没有任何模式，这个动作针对所有输入的行进行操作。 print 语句用来打印（输出）当前输入的行。 所以 {print} 等效于 {print $0}

打印特定行

{print $1,$3} 将输出：

Beth 0
Dan 0
kathy 10
Mark 20
Mary 22
Susie 18

在 print 语句中被逗号分隔的表达式，在默认情况下他们将会用一个空格分割来输出。 每一行print生成的内容都会以一个换行符作为结束。但这些默认行为都可以自定义。

NF，字段数量

AWK 会对当前输入的行有多少字段进行计数，并且将当前行的字段数量存储在一个内建的称为 NF 的变量中。因此 {print NF,$1,$NF} 会打印出 每一行的字段数量、第一个字段的值、最后一个字段的值。 输出：

3 Beth 0
3 Dan 0
3 kathy 10
3 Mark 20
3 Mary 22
3 Susie 18

打印行号

awk 提供了另一个内建变量， NR。他存储了当前已经读取了多少行的计数。可以使用 NR和$0给emp.data的每一行加上行号： {print NR,$0} 输出如下：

1 Beth  4.00    0
2 Dan   3.75    0
3 kathy 4.00    10
4 Mark  5.00    20
5 Mary  5.50    22
6 Susie 4.25    18

在输出中添加内容

还可以在字段中间或者计算的值中间打印输出想要的内容： {print "total pay for", $1, "is", $2*$3} 输出如下：

total pay for Beth is 0
total pay for Dan is 0
total pay for kathy is 40
total pay for Mark is 100
total pay for Mary is 121
total pay for Susie is 76.5

高级输出

print 语句可用于快速而简单的输出。若要严格按照你所想的格式化输出，则需要使用 printf 语句。

字段排队

printf 语句格式如下：

printf(format, value1, value2, ..., valueN)

其中 format 是字符串，包含要逐字打印的文本，穿插在 format 之后的每个值该如何打印的规格。一个规格是一个 % 符，后面跟着一些字符，用来控制一个 value 的格式。因此，有过少个 value 要打印，在 fromat 中就要有多少个 % 规格。 打印每个员工的总薪酬： {printf("total pay for %s is $%.2f\n", $1, $2*$3)} 输出如下：

awk '{printf("total pay for %s is $%.2f\n", $1, $2*$3)}'  emp.data
total pay for Beth is $0.00
total pay for Dan is $0.00
total pay for kathy is $40.00
total pay for Mark is $100.00
total pay for Mary is $121.00
total pay for Susie is $76.50

排序输出

以薪酬递增的方式输出每一行：

awk '{printf("%6.2f %s\n", $2*$3, $0)}' emp.data | sort

将awk的输出通过管道传给 **sort **命令，输出如下：

  0.00  Beth    4.00    0
  0.00  Dan     3.75    0
100.00  Mark    5.00    20
121.00  Mary    5.50    22
 40.00  kathy   4.00    10
 76.50  Susie   4.25    18

选择

awk 的模式适用于为进一步的处理从输入中选择相关的数据行。由于不带动作的模式会打印所有匹配的行，所以很多awk程序仅仅包含一个模式。本节将给出一些有用的模式示例。

通过对比选择

使用一个对比模式来选择每小时赚5美元或更多的员工记录，亦即第二个字段大于等于5的行： $2>=5

awk '$2>=5'  emp.data
Mark    5.00    20
Mary    5.50    22

通过计算选择

awk '$2*$3>50 {printf("$%.2f for %s\n", $2*$3, $1)}'  emp.data
$100.00 for Mark
$121.00 for Mary
$76.50 for Susie

通过文本内容选择

除了数值测试，还可以选择包含特定单词或短语的输入行。这个程序会打印所有第一个字段为 Susie 的行：

$1=="Susie"

操作符 == 用于测试相等性。 也可以使用正则表达式的模式查找包含任意任意字母组合，单词或短语的文本。如以下可以匹配到任意位置包含Susie的行： /Susie/

awk '/Susie/'  emp.data
Susie   4.25    18

模式组合

可以使用括号和逻辑操作符号与&&、或||，以及 非! 对模式进行组合。 $2>=4||$3>=20 会打印第二个字段大于等于4或者第三个字段大于等于20的行：

awk '$2>=4||$3>=20'  emp.data
Beth    4.00    0
kathy   4.00    10
Mark    5.00    20
Mary    5.50    22
Susie   4.25    18

BEGIN 与 END

特殊模式 BEGIN 用于匹配第一个输入文件的第一行之前的位置。END 则用于匹配处理过的最后一个文件的最后一行的位置。

这个程序使用 BEGIN 来输出一个标题：

BEGIN {print "Name RATE HOURS"; print ""}
    {print}

awk 'BEGIN {print "Name RATE HOURS"; print ""}
{print}' emp.data

## 输出如下：

Name RATE HOURS

Beth    4.00    0
Dan     3.75    0
kathy   4.00    10
Mark    5.00    20
Mary    5.50    22
Susie   4.25    18

注意事项：

• awk 可以在一行上放多个语句，步过要使用分号;进行分隔。

• 普通的 print 是打印当前输入行， print "" 则会打印一个空行。

AWK 工作流图

AWK 是按一行一行地读取输入的。

• 1.首先执行 BEGIN 块
• 2.从输入中读取一行
• 3.在这次读取的这一行中执行 AWK 命令
• 4.如果文件还没有读取完毕，则重复步骤2、3
• 5.执行 END 块中的 awk 命令

使用 AWK 进行计算

一个动作就是一个以新行或者分号分隔的语句序列。

计数

$3 > 15 {emp = emp + 1}
END {print emp, "employees worked more than 15 hours"}

awk '$3 > 15 {emp = emp + 1}
> END {print emp, "employees worked more than 15 hours"}' emp.data

## 输出结果：
3 employees worked more than 15 hours

用作数字的 awk 变量的默认初始值为0， 所以不需要初始化 emp。创建一个变量emp初始值为0，如果读入的那一行的第三个字段大于15，则emp在自身值的基础上自增1，读完最后一行后输出存在多少个员工工作时长超过15个小时的语句。

求和与平均值

为计算员工数目，可以使用内置变量 NR，保存了当前位置读取的行数；在所有输入的结尾它的值就是所读行的总行数。

END {print NR, "employees"}

awk 'END {print NR, "employees"}'  emp.data

## 输出结果为：
6 employees

如下是一个使用 NR 来计算薪酬均值的程序：

awk '{pay = pay + $2*$3}
> END {print NR, "employees"
> print "total pay is", pay
> print "average pay is", pay/NR
> }' emp.data

## 输出结果为：
6 employees
total pay is 337.5
average pay is 56.25

处理文本

awk 的优势之一是能像大多数语言处理数字一样方便地处理字符串。 awk 可以保存数字也可以保存字符。找出时薪最高的员工:

$2 > maxrate { maxrate = $2; maxemp = $1 }
END { print "highest hourly rate:", maxrate, "for", maxemp }

 awk '$2 > maxrate { maxrate = $2; maxemp = $1 }
> END { print "highest hourly rate:", maxrate, "for", maxemp }' emp.data

## 输出结果为：
highest hourly rate: 5.50 for Mary

awk '{names = names $1 " "}                    
END {print names}' emp.data

## 输出结果：
Beth Dan kathy Mark Mary Susie 

打印最后一个输入行

虽然在 END 动作中 NR 还保留着它的值， 但 $0 没有。

{last = $0}
END {print last}

awk '
> {last = $0}
> END {print last}' emp.data

## 输出结果：
Susie   4.25    18

AWK 内置函数

前面已经看到 awk 内置变量用来保存某些频繁使用的数量， NF 表示所在行的总列数， NR 表示当前是第多少行... 还有内置函数用来计算其他有用的数值。除了 平方根、对数、随机数此类的算术函数外，还有操作文本的函数。其中之一是 length 用于计算一个字符串的长度。

awk '{print $1, length($1)}'  emp.data

## 输出结果：
Beth 4
Dan 3
kathy 5
Mark 4
Mary 4
Susie 5

行、单词以及字符的计数

使用 length、NF、NR来统计输入中行、单词以及字符的数量。为了简便，将每个字段看作一个单词。

awk ' { nc = nc + length($0) + 1
>       nw = nw + NF
>     }
> END { print NR, "lines,", nw, "words,", nc, "characters" }' emp.data

## 输出结果为：
6 lines, 18 words, 82 characters

因为 $0 不会包含行末的换行符，所以另外加了个1。

AWK 控制语句

awk 为选择提供了一个 if-else 语句， 以及为循环提供了几个语句，它们仅在动作中使用。

if-else 语句

如下是一个计算时薪超过6美元的员工总薪酬与平均薪酬。它使用一个 if 来防范零除问题。

$2 > 6 { n = n+1; pay = pay + $2*$3 }
END {
    if(n > 0)
        print n, "employees, total pay is", pay,
               "average pay is", pay/n
    else
        print "no employees are paid more than $6/hour"
        
}

awk '$2 > 6 { n = n+1; pay = pay + $2*$3 }
> END {
>     if(n > 0)
>         print n, "employees, total pay is", pay,
>                "average pay is", pay/n
>     else
>         print "no employees are paid more than $6/hour"
>         
> }' emp.data

## 输出结果为：
no employees are paid more than $6/hour

注意事项： 我们可以使用一个逗号将一个长语句截断为多行来书写.

while 语句

{
    i = 1
    while ( i <=3 ){
        # while 循环体(这一行是注释内容)
        printf("\t%.2f\n", $1*(1+$2)^i)
        i = i + 1
    }
}

while 后面是圆括号，里面是布尔表达式。 循环体是条件后大括号包围的语句。 ^ 是指数操作符。 # 后面是注释。

演示1000美元，利率为6%与12%，5年的复利分别是如何增长的：

awk '
> {
>     i = 1
>     while ( i <=5 ){
>         # while 循环体(这一行是注释内容)
>         printf("\t%.2f\n", $1*(1+$2)^i)
>         i = i + 1
>     }
> }
> ' 
1000 .06 5
        1060.00
        1123.60
        1191.02
        1262.48
        1338.23
1000 .12 5
        1120.00
        1254.40
        1404.93
        1573.52
        1762.34

for 语句

使用for循环实现上述例子：

awk '
> {
>     for( i = 1; i <= $3; i = i+1 ){
>         printf("\t%.2f\n", $1*(1+$2)^i)
>     }
> }
> '
1000 .06 5
        1060.00
        1123.60
        1191.02
        1262.48
        1338.23
1000 .12 5
        1120.00
        1254.40
        1404.93
        1573.52
        1762.34

数组

awk 为存储一组相关的值提供了数组，虽然数组给予了awk很强的能力，但是在这里我们仅仅展示一个简单的例子。 第一个动作将输入行存为数组 line 的连续元素； 第一行放在line[1]，第二行放在line[2]。 END 动作使用一个while语句从后往前打印数组中的输入行：

# 反转-按行逆序打印输入

{line[NR] = $0}

END {
        i = NR
        while(i > 0){
            print line[i]
            i = i-1
        }
}

awk '
> {line[NR] = $0}
> 
> END {
>         i = NR
>         while(i > 0){
>             print line[i]
>             i = i-1
>         }
> }' emp.data

# 输出结果为：
Susie   4.25    18
Mary    5.50    22
Mark    5.00    20
kathy   4.00    10
Dan     3.75    0
Beth    4.00    0

--dump-variables 操作查看全局变量

-dump-variables[=file] 操作可以打印全局变量到文件中，默认是“awkvars.out”文件。

awk --dump-variables ''

# 查看文件awkvars.out 
cat awkvars.out 

ARGC: number (1)
ARGIND: number (0)
ARGV: array, 1 elements
BINMODE: number (0)
CONVFMT: string ("%.6g")
ERRNO: number (0)
FIELDWIDTHS: string ("")
FILENAME: string ("")
FNR: number (0)
FS: string (" ")
IGNORECASE: number (0)
LINT: number (0)
NF: number (0)
NR: number (0)
OFMT: string ("%.6g")
OFS: string (" ")
ORS: string ("\n")
RLENGTH: number (0)
RS: string ("\n")
RSTART: number (0)
RT: string ("")
SUBSEP: string ("\034")
TEXTDOMAIN: string ("messages")

--help 操作可以寻得帮助

awk --help
# 输出信息如下：

Usage: awk [POSIX or GNU style options] -f progfile [--] file ...
Usage: awk [POSIX or GNU style options] [--] 'program' file ...
POSIX options:          GNU long options:
        -f progfile             --file=progfile
        -F fs                   --field-separator=fs
        -v var=val              --assign=var=val
        -m[fr] val
        -O                      --optimize
        -W compat               --compat
        -W copyleft             --copyleft
        -W copyright            --copyright
        -W dump-variables[=file]        --dump-variables[=file]
        -W exec=file            --exec=file
        -W gen-po               --gen-po
        -W help                 --help
        -W lint[=fatal]         --lint[=fatal]
        -W lint-old             --lint-old
        -W non-decimal-data     --non-decimal-data
        -W profile[=file]       --profile[=file]
        -W posix                --posix
        -W re-interval          --re-interval
        -W source=program-text  --source=program-text
        -W traditional          --traditional
        -W usage                --usage
        -W use-lc-numeric       --use-lc-numeric
        -W version              --version

To report bugs, see node `Bugs' in `gawk.info', which is
section `Reporting Problems and Bugs' in the printed version.

gawk is a pattern scanning and processing language.
By default it reads standard input and writes standard output.

Examples:
        gawk '{ sum += $1 }; END { print sum }' file
        gawk -F: '{ print $1 }' /etc/passwd

--version 查看版本信息

awk --version
# 输出结果如下:

GNU Awk 3.1.7
Copyright (C) 1989, 1991-2009 Free Software Foundation.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses/.

-v 操作

-v 操作允许给一个变量分配值。允许在程序执行之前分配。

awk -v name=LFF 'BEGIN {printf("username=%s\n", name)}'

# 输出结果为：
username=LFF

--lint 操作提示信息

--lint 操作允许输出检查信息，比如当参数提供错误，会将警告信息当作错误。

awk --lint '' /bin/ls

# 输出结果为：
awk: warning: empty program text on command line
awk: warning: source file does not end in newline
awk: warning: no program text at all!

正则匹配

匹配输入行中包含字符a的行，全部输出。

awk '/a/ {print $0}'  emp.data

# 输出结果为：
Dan     3.75    0
kathy   4.00    10
Mark    5.00    20
Mary    5.50    22

打印输入行中包含字符a的行数：

awk '/a/ {++cnt} END {print "匹配的行数为:", cnt}' emp.data

# 输出结果为:
匹配的行数为: 4

内置变量

ARGC ：命令行中提供的参数个数

shell awk 'BEGIN {print "Arguments =", ARGC}' One Two Three Four Arguments = 5

ARGV 表示命令行入参构成的数组，索引是 0~ARGC-1

 awk 'BEGIN { 
>    for (i = 0; i < ARGC - 1; ++i) { 
>       printf "ARGV[%d] = %s\n", i, ARGV[i] 
>    } 
> }' one two three four

# 输出结果为：
ARGV[0] = awk
ARGV[1] = one
ARGV[2] = two
ARGV[3] = three

CONVFMT

表示数字的转换格式。默认值是 %.6g。

awk 'BEGIN { print "Conversion Format =", CONVFMT }'

#输出：
Conversion Format = %.6g

ENVIRON 环境变量

awk 'BEGIN { print ENVIRON["USER"] }'

# 输出当前用户
deploy

我们可以借助env命令查看linux服务器上的全部环境变量：

env

# 查看当前服务器上的所有环境变量
HOSTNAME=sz-local3
TERM=vt100
SHELL=/bin/bash
HISTSIZE=1000
SSH_CLIENT=10.89.4.224 53217 22
QTDIR=/usr/lib64/qt-3.3
OLDPWD=/data/app
QTINC=/usr/lib64/qt-3.3/include
SSH_TTY=/dev/pts/0
GREP_OPTTIONS=--color=always
USER=deploy
LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=01;05;37;41:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lz=01;31:*.xz=01;31:*.bz2=01;31:*.tbz=01;31:*.tbz2=01;31:*.bz=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=01;36:*.au=01;36:*.flac=01;36:*.mid=01;36:*.midi=01;36:*.mka=01;36:*.mp3=01;36:*.mpc=01;36:*.ogg=01;36:*.ra=01;36:*.wav=01;36:*.axa=01;36:*.oga=01;36:*.spx=01;36:*.xspf=01;36:
MAIL=/var/spool/mail/deploy
PATH=/usr/lib/jdk1.7.0_76/bin:/usr/lib64/qt-3.3/bin:/data/app/node-v4.2.4-linux-x64/bin:/usr/lib/jdk1.7.0_76/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/deploy/bin
PWD=/data/app/lff
JAVA_HOME=/usr/lib/jdk1.7.0_76
LANG=en_US.UTF-8
HISTCONTROL=ignoredups
SHLVL=1
HOME=/home/deploy
LOGNAME=deploy
QTLIB=/usr/lib64/qt-3.3/lib
CVS_RSH=ssh
CLASSPATH=/usr/lib/jdk1.7.0_76/lib:/usr/lib/jdk1.7.0_76/lib:
SSH_CONNECTION=10.89.4.224 53217 10.193.1.27 22
LESSOPEN=||/usr/bin/lesspipe.sh %s
G_BROKEN_FILENAMES=1
_=/bin/env

FILENAME 表示当前文件

awk 'END {print FILENAME}' emp.data

# 输出结果为：
emp.data

FS 表示文件分隔符

FS 表示文件分割符，默认是空白字符。也可以使用 -F 命令行变更。

awk 'BEGIN {print "FS = " FS}' | cat -vte

# 输出结果为：
FS =  $

NF 表示当前行的字段（列数）

NR 表示当前读到的行数

RLENGTH

表示匹配函数 match 到的字符串的长度。

awk '
BEGIN {
       if(match("One Two Three", "re")){
          print RLENGTH
       }
}'

# 匹配到了Three中的re，输出结果为：
2

RSTART 表示第一个match函数匹配到的字符串中的位置

awk '
BEGIN {
       if(match("One Two Three There", "re")){
          print RSTART 
       }
}'

# 从O开始，到Three的r，位置处于11，输出结果为：
11

$0 表示全部的输入记录

$n 表示第n列(第n个字段)，以文件分隔符分隔，默认是空白字符。

ARGIND 表示当前处理的 ARGV 的索引值

PROCINFO 表示进程相关信息

awk 'BEGIN {print PROCINFO["pid"]}'
5142

运算符操作

自增符操作

awk 'BEGIN {print ++a}'
# 先自增，输出结果为：
1
# 后自增，输出结果为：
awk 'BEGIN {print a++}'
0

自减符操作

awk 'BEGIN {print --a}'
-1
awk 'BEGIN {print a--}'
0

+=、 -=、 *=、/=、%=、 ^=、**=操作

awk 'BEGIN {print cnt+=10; print cnt}'
10
10

awk 'BEGIN {cnt=10 ;print cnt*=10; print cnt}'
100
100

awk 'BEGIN {cnt=10 ;print cnt-=10; print cnt}'
0
0
awk 'BEGIN {cnt=10 ;print cnt/=10; print cnt}'
1
1
awk 'BEGIN {cnt=10 ;print cnt%=10; print cnt}'
0
0
awk 'BEGIN {cnt=10 ;print cnt^=10; print cnt}'
10000000000
10000000000
awk 'BEGIN {cnt=10 ;print cnt**=10; print cnt}'
10000000000
10000000000

关系运算符

• ==
• !=
• <
• <=
• >
• >=

逻辑运算符

• &&
• ||
• !

三目运算符

• ? :

字符串连接符

空白字符是字符串连接符

awk 'BEGIN {a="hello, "; b="world!"; c= a b; print(c)}'

# 输出连接结果
hello, world!

数组关系操作符

for in 操作常用于遍历数组。

awk '
> BEGIN { arr[1] = "a"; arr[2] = "b"; arr[3] = "c";  
> for(i in arr){
>     print("a[", i, "]=", arr[i])
> }
> }'

# 遍历输出数组元素：
a[ 1 ]= a
a[ 2 ]= b
a[ 3 ]= c

正则表达式操作符

• 点符**.** ： 匹配任意单个字符

示例：

echo -e "cat\nbat\nfun\nfin\nfan" | awk '/f.n/'

fun
fin
fan

• **^**符：匹配开头

匹配 The 开头的字符串：

echo -e "This\nThat\nThere\nTheir\nthese" | awk '/^The/'

There
Their

• **$**符：匹配结尾

匹配 n 结尾的字符串：

echo -e "knife\nknow\nfun\nfin\nfan\nnine" | awk '/n$/'

fun
fin
fan

• [] 符 ：匹配字符集多选一

匹配 Call 或者 Tall：

echo -e "Call\nTall\nBall" | awk '/[CT]all/'
 
Call
Tall

• 排除匹配

使用^排除，匹配不是 Call且不是Tall的字符串：

echo -e "Call\nTall\nBall" | awk '/[^CT]all/'

Ball

• 可选匹配

匹配 Call 或者 Tall

echo -e "Call\nTall\nBall\nSmall\nShall" | awk '/Call|Ball/'

Call
Ball

• ？ 符号 ：0 或 1次匹配

echo -e "Colour\nColor" | awk '/Colou?r/'

Colour
Color

• * 符号： 表示0或多个匹配

echo -e "ca\ncat\ncatt" | awk '/cat*/'

ca
cat
catt

• () 分组匹配

echo -e "Apple Juice\nApple Pie\nApple Tart\nApple Cake" | awk 
   '/Apple (Juice|Cake)/'
   
Apple Juice
Apple Cake

数组

awk 'BEGIN {
   fruits["mango"] = "yellow";
   fruits["orange"] = "orange"
   print fruits["orange"] "\n" fruits["mango"]
}'

orange
yellow

delete 删除数组元素

awk 'BEGIN {
   fruits["mango"] = "yellow";
   fruits["orange"] = "orange";
   delete fruits["orange"];
   for(i in fruits){print fruits[i]}
}'

# 删除orange后，只剩下yello
yellow

多维数组

100   200   300
400   500   600
700   800   900

array[0][0] 存储 100，array[0][1] 存储 200。 正确的语法是 array["0,0"] = 100

awk 'BEGIN {
   array["0,0"] = 100;
   array["0,1"] = 200;
   array["0,2"] = 300;
   array["1,0"] = 400;
   array["1,1"] = 500;
   array["1,2"] = 600;

   # print array elements
   print "array[0,0] = " array["0,0"];
   print "array[0,1] = " array["0,1"];
   print "array[0,2] = " array["0,2"];
   print "array[1,0] = " array["1,0"];
   print "array[1,1] = " array["1,1"];
   print "array[1,2] = " array["1,2"];
}'

字符串函数

index(str, substr)

子串 substr 出现在字符串 str 中的开始位置，从1开始计数。

awk 'BEGIN {print index("Hello", "ll")}'
3

gsub(regex, sub, string)

正则匹配 regex，将其替换为 sub指定的内容， string是所选的字符串。

awk 'BEGIN { str = "Hello,World！"; gsub("World", "Lily", str); print str}'
Hello,Lily！

match(str, regex)

匹配则返回regex在str中的起始位置，否则返回0表示没有匹配到。

awk 'BEGIN {str = "Hello,world!"; ret = match(str, "wo"); print str, ret}'
Hello,world! 7

split(str, arr, regex)

将 str 按 regex 匹配拆分，得到的每个拆分作为元素保存在 arr 数组中。

awk 'BEGIN {str = "Hello,Hellokitty"; split(str, arr, ",");  
for(ele in arr){
    print arr[ele]
}}'

Hello
Hellokitty

strtonum(str)

将字符串强转成数值类型， str开头是0的话会转为八进制， 是0x或0X开头的话会转为十六进制。

 awk 'BEGIN {
>    print "Decimal num = " strtonum("123")
>    print "Octal num = " strtonum("0123")
>    print "Hexadecimal num = " strtonum("0x123")
> }'
Decimal num = 123
Octal num = 83
Hexadecimal num = 291

substr(str, start, l)

获取字串，从字符串 str 中的 start位置开始截取长度为 L 的字符串。

awk 'BEGIN {str = "nihaoya!"; print substr(str, 1, 2)}'
ni

tolower(str)

将字符串 str 小写化。

awk 'BEGIN{ print tolower("HeLLo")}'
hello

toupper(str)

将字符串 str 大写化。

awk 'BEGIN{ print toupper("HeLLo")}'
HELLO

时间函数

systime()

获取自 1970-01-01 00:00:00 至今的unix时间戳

awk 'BEGIN {print systime()}'
1545742584

mktime(datespec)

将指定的日期格式串转换为时间戳，datespec 格式是 YYYY mm dd HH MM SS

awk 'BEGIN {print mktime("2018 12 25 21 07 00")}'
1545743220

strftime(format, timestamp)

将时间戳 timestamp 转换成指定格式format的字符串

 awk 'BEGIN {
>    print strftime("Time = %m/%d/%Y %H:%M:%S", systime())
> }'
Time = 12/25/2018 21:11:09

位操作函数

and

按位与

awk 'BEGIN {
   num1 = 10
   num2 = 6
   printf "(%d AND %d) = %d\n", num1, num2, and(num1, num2)
}'

# 输出结果为：
(10 AND 6) = 2

lshift(num, size)

将num按位左移size位数, 左移一位相当于乘以2

awk 'BEGIN {print lshift(10, 1)}'
20

rshift(num, size)

将num按位右移size位数, 右移一位相当于除以2

awk 'BEGIN {print rshift(10, 1)}'
5

or 按位或

awk 'BEGIN {
   num1 = 10
   num2 = 6
   printf "(%d OR %d) = %d\n", num1, num2, or(num1, num2)
}'

# 输出结果为：
(10 OR 6) = 14

xor 异或

awk 'BEGIN {
   num1 = 10
   num2 = 6
   printf "(%d XOR %d) = %d\n", num1, num2, xor(num1, num2)
}'

# 输出结果为：
(10 XOR 6) = 12

自定义函数

语法形式:

function function_name(argument1, argument2, ...) { 
   function body
}

示例：

# Returns minimum number
function find_min(num1, num2){
   if (num1 < num2)
   return num1
   return num2
}
# Returns maximum number
function find_max(num1, num2){
   if (num1 > num2)
   return num1
   return num2
}
# Main function
function main(num1, num2){
   # Find minimum number
   result = find_min(10, 20)
   print "Minimum =", result
  
   # Find maximum number
   result = find_max(10, 20)
   print "Maximum =", result
}
# Script execution starts here
BEGIN {
   main(10, 20)
}

输出转移操作

重定向数据到文件

我们还可以将数据导入到文件中。在 print 或者 printf 后增加重定向的文件语句。 语法：

print data > outputfile

将数据 data 写入到 outputfile，如果 outputfile 不存在则创建。当指定重定向时，文件 output 会清除所有内容，然后写入数据。顺序写操作则不会提前清除文件内容，只是追加。

# 将 "Old data" 写入 message.txt 文件中，没有则创建 message.txt 文件。
echo "Old data" > message.txt
# 查看文件内容
cat message.txt 
# 输出结果：
Old data

然后执行：

awk 'BEGIN {print "Hello,World!" > "message.txt"}'
cat message.txt 
# 文件的旧内容清楚了，内容已经被替换
Hello,World!

追加内容到文件中

print DATA >> output-file

echo "Old data" > /tmp/message.txt
cat /tmp/message.txt
# 查看文件内容
Old data

# 追加内容到文件中
awk 'BEGIN { print "Hello, World !!!" >> "/tmp/message.txt" }'
cat /tmp/message.txt

#  输出内容：
Old data
Hello, World !!!

管道 pipe

可能需要发送输出数据到其它程序，通过管道而不是文件。 这种转移方式会打开一个管道命令，并且会通过管道将数据项通过管道传到另一个进程去执行命令。 转移参数是一个 awk 表达式。

管道的语法如下：

print items | command

示例：使用 tr 命令将小写转换为大写

awk 'BEGIN { print "hello, world !!!" | "tr [a-z] [A-Z]" }'
HELLO, WORLD !!!

更过关于 tr 的使用方法，可以使用 tr --help 查看帮助信息。

双向通信

awk 可以通过 |& 跟外部进程通信。

awk 'BEGIN {
>    cmd = "tr [a-z] [A-Z]"
>    print "hello, world !!!" |& cmd
>    close(cmd, "to")
>    
>    cmd |& getline out
>    print out;
>    close(cmd);
> }'
HELLO, WORLD !!!

说明：

• 第一条语句，cmd="tr [a-z] [A-Z]" ，是我们建立双向通信的命令。
• 接下来的语句，print 命令提供输入到 tr 命令。 这里的 |& 表示双向通信。
• 第三条语句，close(cmd,"to") ，在完成执行后，关闭 to 进程。
• cmd |& getline out 借助getline函数将结果输出 到 out 变量中。
• 最后打印out，并使用close函数关闭命令。

整齐打印

awk 'BEGIN { printf "Hello\nWorld\n" }'

# 输出结果为：
Hello
World

水平tab间隔打印

awk 'BEGIN { printf "Sr No\tName\tSub\tMarks\n" }'

Sr No   Name    Sub Marks

垂直tab打印

awk 'BEGIN { printf "Sr No\vName\vSub\vMarks\n" }'

# 输出结果为：
Sr No
     Name
         Sub
            Marks

回车打印

awk 'BEGIN { printf "Field 1\rField 2\rField 3\rField 4\n" }'

输出：
Field 4

换页打印

awk 'BEGIN { printf "Sr No\fName\fSub\fMarks\n" }'
Sr No
     Name
         Sub
            Marks

格式说明符

• %c ： 表示一个单个字符

awk 'BEGIN { printf "ASCII value 65 = character %c\n", 65 }'
ASCII value 65 = character A

• %d and %i : 表示十进制的整数

awk 'BEGIN { printf "Percentags = %d\n", 80.66 }'

输出结果为：
Percentags = 80

• %e and %E ： 科学记数法

awk 'BEGIN { printf "Percentags = %E\n", 80.66 }'

输出结果为：
Percentags = 8.066000e+01

• %f : 浮点数

awk 'BEGIN { printf "Percentags = %f\n", 80.66 }'

输出结果为：
Percentags = 80.660000

• %s ： 表示字符串

awk 'BEGIN { printf "Name = %s\n", "Sherlock Holmes" }'

输出结果为：

Name = Sherlock Holmes

• %nd : 指定宽度打印

awk 'BEGIN { 
   num1 = 10; num2 = 20; printf "Num1 = %10d\nNum2 = %10d\n", num1, num2 
}'

# 输出结果为：
Num1 =         10
Num2 =         20

AWK 概览

AWK 是一种解释性编程语言。是专门为处理文本而设计的。名字是来自于设计者的名字 —— Alfred Aho, Peter Weinberger, and Brian Kernighan.

AWK 的类型

• AWK ： AT&T 实验室
• NAWK ：AWK 的新的改进版本
• GAWK ： GNU AWK。 所有GNU/Linux发行版都是GAWK。它与AWK和NAWK完全兼容。

AWK 的典型应用场景

• 文本处理
• 生成格式化的文本报告
• 处理算术操作
• 处理字符串操作

AWK 环境

描述如何在 GNU/Linux 系统中安装 AWK 环境。

安装包管理器

一般情况下， AWK 默认在大都数 GNU/Linux 系统中都是安装发行的。 你可以使用 which 命令，检查awk在系统中是否安装好了。 如果没有安装 awk， 可以按如下命令借助 高级安装包 APT安装 AWK：

sudo apt-get update
sudo apt-get install gawk

yum install gawk

# 查看
which awk

# 输出结果为：
/bin/awk

从源代码中安装：

• wget http://ftp.gnu.org/gnu/gawk/gawk-4.1.1.tar.xz
• tar xvf gawk-4.1.1.tar.xz
• ./configure
• make
• make check
• sudo make install
• which awk