1．有关本手册
这是一本AWK学习指引, 其重点着重于：
AWK 适于解决哪些问题？
AWK 常见的解题模式为何？
为使读者快速掌握AWK解题的模式及特性，本手册系由一些较具代表性的范例及其题解所构成； 各范例由浅入深，彼此间相互连贯，范例中并对所使用的AWK语法及指令辅以必要的说明。 有关AWK的指令，函数等条列式的说明则收录于附录中，以利读者日后编写程序时查阅。 如此编排，可让读者在短时间内顺畅地学会使用AWK来解决问题。建议读者循着范例上机实习以加深学习效果。
2．读者宜先具备下列背景知识：
- UNIX 环境下的简单操作及基本概念。
- C 语言的基本语法及流程控制指令。
例如 ：档案编辑，档案复制及管道（pipe），重定向（I/O Redirection） 等概念。
AWK 指令并不多，且其中之大部分与 C语言中之用法一致，本手册中对该类指令之语法及特性不再加以繁冗的说明，读者若欲深究，可自行翻阅相关的 C 语言书籍。
例如 ：printf(), while()……
3．参考书目 ：
本手册是以学习指引为主要编排方式，读者若需要有关AWK介绍详尽的参考书，可参考下列两本书 ：
Alfred V. Aho, Brian W. Kernighan and Peter J. Weinberger,
“The AWK Programming Language”,
Addison-Wesley Publishing Company
Dale Dougherty, " sed & awk '', O`Reilly & Associates, Inc
二．总括
1．Why AWK？
AWK 是一种程序语言。 它具有一般程序语言常见的功能。因AWK语言具有某些特点，如 ：使用直译器(Interpreter)不需先行编译；变量无型别之分(Typeless)，可使用文字当数组的注标(Associative Array)等特色。 因此，使用AWK编写程序比起使用其它语言更简洁便利且节省时间。 AWK还具有一些内建功能，使得AWK擅于处理具数据列(Record)，字段(Field)型态的资料； 此外，AWK内建有pipe的功能，可将处理中的数据传送给外部的Shell命令加以处理，再将Shell命令处理后的数据传回AWK程序，这个特点也使得AWK程序很容易使用系统资源。
由于AWK具有上述特色，在问题处理的过程中, 可轻易使用AWK来编写一些小工具；这些小工具并非用来解决整个大问题，它们只个别扮演解决问题过程的某些角色，可藉由Shell所提供的pipe将数据按需要传送给不同的小工具进行处理，以解决整个大问题。这种解题方式使得这些小工具可因不同需求而被重复组合及使用(reuse)；也可藉此方式来先行测试大程序原型的可行性与正确性，将来若需要较高的执行速度时再用C语言来改写。这是AWK最常被应用之处。 若能常常如此处理问题，读者可以以更高的角度来思考抽象的问题，而不会被拘泥于细节的部份。 本手册为AWK入门的学习指引，其内容将先强调如何编写AWK程序，未列入进一步解题方式的应用实例，这部分将留待UNIX进阶手册中再行讨论。
2．如何取得AWK？
一般的UNIX操作系统本身即附有AWK。不同的UNIX操作系统所附的AWK其版本亦不尽相同。 若读者所使用的系统上未附有AWK，可透过 anonymous ftp 到下列地方取得：
phi.sinica.edu.tw：/pub/gnu
ftp.edu.tw：/UNIX/gnu
prep.ai.mit.edu：/pub/gnu
3．How AWK works ？
为便于解释AWK程序架构，及有关术语(terminology)，先以一个员工薪资档(emp.dat )来加以介绍。
A125 Jenny 100 210
A341 Dan 110 215
P158 Max 130 209
P148 John 125 220
A123 Linda 95 210
档案中各字段依次为 员工ID, 姓名, 薪资率及实际工时。 ID中的第一码为部门识别码。 ''A'',''P''分别表示"组装''及"包装''部门。
本小节着重于说明AWK程序的主要架构及工作原理, 并对一些重要的名词辅以必要的解释。 由这部分内容, 读者可体会出AWK语言的主要精神及AWK与其它语程序言的差异处。为便于说明, 以条列方式说明于后。
（1）名词定义
资料列(Record)： AWK从数据文件上读取数据的基本单位。以上列档案emp.dat为例，AWK读入的第一笔资料列是 "A125 Jenny 100 210"，第二笔资料列是 "A341 Dan 110 215"。一般而言，一笔数据列相当于数据文件上的一行资料。 (参考 ： 附录 B 内建变量"RS'' )
字段(Field) ：为资料列上被分隔开的子字符串。以资料列"A125 Jenny 100 210''为例，
第一栏 第二栏 第三栏 第四栏
A125 Jenny 100 210
一般是以空格符来分隔相邻的字段。 ( 参考：附录 D 内建变量"FS'' )
（2）如何执行AWK？
在UNIX的命令列上键入诸如下列格式的指令：
$awk 'AWK程序' 数据文件文件名
( "$''表示Shell命令列上的提示符号)
则AWK会先编译该程序，然后执行该程序来处理所指定的数据文件。(上列方式系直接把程序写在UNIX的命令列上)
（3）AWK程序的主要结构 ：
AWK程序中主要语法是 Pattern { Actions }，故常见之AWK程序结构如下 ：
Pattern1 { Actions1 }
Pattern2 { Actions2 }
……
Pattern3 { Actions3 }
（4）Pattern 是什么 ?
AWK 可接受许多不同型态的 Pattern。 一般常使用 “关系判断式”(Relational Expression) 来当成 Pattern。例如 ：
x > 34 是一个Pattern，判断变量 x 与 34 是否存在 大于 的关系。
x == y 是一个Pattern，判断变量 x 与变量 y 是否存在等于的关系。上式中 x >34，x == y 便是典型的Pattern。
AWK 提供 C 语言中常见的关系操作数(Relational Operators) ，如：
>，=， 23 {print "Hello! The world!!" }
"banana" ~ /123/ { print "Good morning !" }
AWK会先判断 50>23 是否成立。 因为该式成立，所以AWK将印出"Hello! The world!!"。 而另一 Pattern 为 "banana" ~/123/，因为"banana" 内未含有任何子字符串可 match /123/，该 Pattern 之值为false，故AWK将不会印出 "Good morning !"
AWK 如何处理{ Actions } 的语法？(缺少Pattern部分)有时语法 Pattern { Actions }中，Pattern 部分被省略，只剩 {Actions}。这种情形表示 "无条件执行这个 Actions''。
（7）AWK 的字段变量
AWK 所内建的字段变量及其含义如下 ：
字段变量 含义
$0 为一字符串，其内容为目前 AWK 所读入的资料列。
$1 代表 $0 上第一个字段的数据。
$2 代表 $0 上第二栏个位的资料。
…… 其余类推
读入数据列时，AWK如何修正(update)这些内建的字段变量
当 AWK 从数据文件中读取一笔数据列时，AWK 会使用内建变量$0 予以记录。每当 $0 被移动时 (例如 ： 读入新的数据列或自行变更 $0,……)，AWK 会立刻重新分析 $0 的字段情况, 并将 $0 上各字段的数据用 $1，$2，……予以记录。
（8）AWK的内建变量(Built-in Variables)
AWK 提供了许多内建变量, 使用者于程序中可使用这些变量来取得相关信息。
常见的内建变量有 ：
内建变量 含义
NF (Number of Fields)为一整数，其值表$0上所存在的字段数目。
NR (Number of Records)为一整数，其值表AWK已读入的资料列数目。
FILENAMEAWK 正在处理的数据文件文件名。
例如 ： AWK 从资料文件 emp.dat 中读入第一笔资料列
"A125 Jenny 100 210" 之后, 程序中：
$0 之值将是 "A125 Jenny 100 210"
$1 之值为 "A125" $2 之值为 "Jenny"
$3 之值为 100 $4 之值为 210
NF 之值为 4 $NF 之值为 210
NR 之值为 1 FILENAME 之值为 "emp.dat''
（9）AWK的工作流程 ：
执行AWK时，它会反复进行下列四步骤。
1. 自动从指定的数据文件中读取一笔数据列。
2. 自动更新(Update)相关的内建变量之值。 如 ： NF，NR，$0。
3. 逐次执行程序中所有的 Pattern { Actions } 指令。
4. 当执行完程序中所有 Pattern { Actions } 时，若数据文件中还有未读取的数据。则反复执行步骤1到步骤4。AWK会自动重复进行上述4个步骤，使用者不必程序中编写这个循环 (Loop)。
三．打印档案中指定的字段数据并加以计算
AWK 处理数据时, 它会自动从数据文件中一次读取一笔记录，并会将该数据切分成一个个的字段； 程序中可使用 $1, $2, ... 直接取得各个字段的内容。这个特色让使用者易于用 AWK 编写 reformatter 来改变数据格式。
[范例] 以档案 emp.dat 为例，计算每人应发工资并打印报表。
[分析] AWK 会自行一次读入一列数据，故程序中仅需告诉 AWK 如何处理所读入的数据列。
执行如下命令 ： ( $ 表UNIX命令列上的提示符号 )
awk -F"&" '{ print $2, $3 * $4 }' emp.dat
执行结果如下，屏幕出现 ：
Jenny 21000
Dan 23650
Max 27170
John 27500
Linda 19950
说明 ：
UNIX命令列上，执行AWK的语法为：awk 'AWK程序' 欲处理的资料文件文件名。本范例中的程序部分为 {print $2, $3 * $4}。把程序置于命令列时，程序之前后须以 ‘ ’括住。
emp.dat 为指定给该程序处理的数据文件文件名。
本程序中使用：Pattern { Actions } 语法。
Pattern Actions
print $2, $3 * $4
Pattern 部分被省略，表无任何限制条件。 故AWK读入每笔资料列后都将无条件执行这个Actions。
print为AWK所提供的输出指令，会将数据输出到stdout。print 的参数间彼此以 "{ ,}'' 隔开, 印出数据时彼此间会以空白隔开。(参考 附录 D 内建变量OFS)
将上述的程序部分储存于档案 pay1.awk 中。执行命令时再指定AWK程序文件之文件名。这是执行AWK的另一种方式, 特别适用于程式较大的情况，其语法如下：
$awk -f AWK程序文件名 数据文件文件名
故执行下列两命令，将产生同样的结果。
$awk -f pay1.awk emp.dat
$awk ' { print $2, $3 * $4 } ' emp.dat
读者可使用"-f''参数让AWK主程序使用其它仅含 AWK函数的档案中的函数语法：
awk -f AWK主程序文件名 -f AWK函数文件名 数据文件文件名
(有关 AWK 中函数之宣告与使用于 7.4 中说明)
AWK也提供与 C 语言中类似用法的 printf() 函数。使用该函数可进一步控制数据的输出格式。
编辑另一个AWK程序如下，并取名为 pay2.awk
{ printf("%6s Work hours： %3d Pay： %5dn", $2,$3,$3*$4) }
执行下列命令：
$awk -f pay2.awk emp.dat
执行结果屏幕出现：
Jenny Work hours： 100 Pay： 21000
Dan Work hours： 110 Pay： 23650
Max Work hours： 130 Pay： 27170
John Work hours： 125 Pay： 27500
Linda Work hours： 95 Pay： 19950
四．选印合乎指定条件的记录
Pattern { Action }为AWK中最主要的语法。若某Pattern之值为真，则执行它后方的 Action。 AWK中常使用"关系判断式'' (Relational Expression)来当成 Pattern。 AWK中除了>,
END {for(course in Number)
printf("%10s%dn", course, Number[course] )
}
执行下列命令 ：
awk -f course.awk reg.dat
执行结果如下 ：
Discrete 3
D.S. 1
O.S. 2
六．AWK 程序中使用 Shell 命令
AWK程序中允许呼叫Shell指令，并提供pipe解决AWK与系统间数据传递的问题。 所以AWK很容易使用系统资源。 读者可利用这个特色来编写某些适用的系统工具。
范例 ：写一AWK程序来打印出线上人数。将下列程序建文件, 命名为 count.awk
BEGIN {
while ( "who" | getline ) n++
print n
}
执行下列命令 ：awk -f count.awk
执行结果将会印出目前在线人数
说明 ：
AWK 程序并不一定要处理资料文件。 以本例而言, 仅输入程序檔count.awk，未输入任何数据文件。 BEGIN 和 END 同为AWK中之一种Pattern。 以 BEGIN 为 Pattern之Actions，只有在AWK开始执行程序尚未开启任何输入檔前被执行一次。(注意： 只被执行一次 )"{ |}'' 为 AWK 中表示 pipe的符号。AWK 把 pipe之前的字符串''who''当成Shell上的命令，并将该命令送往Shell执行，执行的结果则由pipe送进AWK程序中。getline为AWK所提供的输入指令。其语法如下 ：
语法 由何处读取数据 资料读入后置于
getline var
[7.2]将 {today_rpt1} 上之数据按员工代号排序, 并加注执行当日之日期； 产生档案 today_rpt2
[7.3]
[7.4] 于 today_rpt2 每日报表上, 迟到者之前加上"*", 并加注当日平均到班时间； 产生档案 today_rpt3
[7.5] 从档案中读取当月迟到次数, 并根据当日出勤状况更新迟到累计数。
某公司其员工到勤时间档如下，取名为 arr.dat。 档案中第一栏为员工代号，第二栏为到达时间。 本范例中将使用该档案为数据文件。
1034 7：26
1025 7：27
1101 7：32
1006 7：45
1012 7：46
1028 7：49
1051 7：51
1029 7：57
1042 7：59
1008 8：01
1052 8：05
1005 8：12
7.1 将数据直接输出到档案
AWK中并未提供如 C 语言中之fopen() 指令，也未有fprintf()档案输出之指令。但AWK中任何输出函数之后皆可藉由使用与UNIX 中类似的 I/O Redirection将输出的数据 Redirect 到指定的档案； 其符号仍为 > (输出到一个新产生的档案) 或 >> ( append 输出的数据到档案末端 )。
[例：]于到班资料文件 arr.dat 之前端增加一列抬头如下 ：
"ID Number Arrival Time", 并产生报表输出到档案 today_rpt1中 建立如下档案并取名为reformat1.awk
BEGIN { print " ID Number Arrival Time'' > "today_rpt1''
print "==========================='' > "today_rpt1''
}
{ printf(" %s %sn", $1,$2 ) > "today_rpt1" } 执行：
$awk -f reformat1。awk arr.dat
执行后将产生档案 today_rpt1, 其内容如下 ：
ID Number Arrival Time
============================
1034 7：26
1025 7：27
1101 7：32
1006 7：45
1012 7：46
1028 7：49
1051 7：51
1029 7：57
1042 7：59
1008 8：01
1052 8：05
1005 8：12
说明 ：
AWK程序中，文件名称 today_rpt1 之前后须以" 括住, 表示today_rpt1 为一字符串常数。若未以"括住, 则 today_rpt1 将被AWK解释为一个变量名称。在AWK中任何变量使用之前, 并不须事先宣告。其初始值为空字符串(Null string) 或 0。因此程序中若未以 " 将 today_rpt1 括住, 则 today_rpt1 将是一变量, 其值将是空字符串, 这会于执行时造成错误(Unix 无法帮您开启一个以Null String为档名的档案)。因此在编辑 AWK程序时, 须格外留心。 因为若敲错变量名称, AWK在编译程序时会认为是一新的变量, 并不会察觉。 如此往往会造成 RuntimeError。
BEGIN 为AWK的保留字, 是 Pattern 的一种。以 BEGIN 为 Pattern 的 Actions 于AWK程序刚被执行尚未读取数据时被执行一次, 此后便不再被执行。读者或许觉得本程序中的I/O Redirection符号应使用 " >>'' (append)而非 " >''。index{ { >} } index{ { >>} }
[*] 本程序中若使用 ">'' 将数据重导到 today_rpt1, AWK第一次执行该指令时会产生一个新档 today_rpt1, 其后再执行该指令时则把数据append到today_rpt1文件末, 并非每执行一次就重开一个新档。
[*] 若采用">>"其差异仅在第一次执行该指令时, 若已存在today_rpt1则 AWK 将直接把数据append在原档案之末尾。
[*] 这一点与UNIX中的用法不同。
7.2 AWK 中如何利用系统资源
AWK程序中很容易使用系统资源。 这包括于程序中途叫用 Shell 命令来处理程序中的部分数据； 或于呼叫 Shell 命令后将其产生之结果交回 AWK 程序(不需将结果暂存于某个档案)。 这过程乃是藉由 AWK 所提供的 pipe (虽然有些类似 Unix 中的 pipe, 但特性有些不同),及一个从 AWK 中呼叫 Unix 的 Shell command 的语法来达成。
[例 ：] 承上题, 将数据按员工ID排序后再输出到档案 today_rpt2, 并于表头附加执行时的日期。
分析 ：
AWK 提供与 UNIX 用法近似的 pipe, 其记号亦为 "|''。 其用法及含义如下 ：
AWK程序中可接受下列两语法 ：
[a. 语法] AWK output 指令 | "Shell 接受的命令'' ( 如 ： print $1,$2 | "sort +1n" )
[b. 语法] "Shell 接受的命令'' |AWK input 指令 ( 如 ： "ls " | getline)
注 ： AWK input 指令只有getline 一个。AWK output 指令有 print, printf() 二个。
在 a 语法中, AWK所输出的数据将转送往 Shell, 由 Shell 的命令进行处理。以上例而言, print 所印出的数据将经由 Shell 命令 "sort +1n'' 排序后再送往屏幕(stdout)。上列AWK程序中, "print$1, $2'' 可能反复执行很多次, 其印出的结果将先暂存于 pipe 中, 等到该程序结束时, 才会一并进行 "sort +1n''。
注意二点 ： 不论 print $1, $2 被执行几次,"sort +1n'' 之 执行时间是 "AWK程序结束时'',"sort +1n'' 之 执行次数是"一次''。
在b 语法中, AWK将先叫用 Shell 命令。 其执行结果将经由 pipe 送入AWK程序以上例而言, AWK先令 Shell 执行 "ls'',Shell 执行后将结果存于 pipe, AWK指令 getline再从 pipe 中读取资料。使用本语法时应留心 ： 以上例而言 AWK "立刻''呼叫 Shell 来执行 "ls'', 执行次数是一次。getline 则可能执行多次(若pipe中存在多行数据)。
除上列 a, b 二语法外, AWK程序中它处若出现像 "date", "cls", "ls"……等字符串, AWK只当成一般字符串处理之。
建立如下档案并取名为 reformat2.awk
# 程序 reformat2.awk
# 这程序用以练习AWK中的pipe
BEGIN {
"date" | getline # Shell 执行 "date''。 getline 取得结果
并以$0记录
print " Today is " , $2, $3 >"today_rpt2"
print "=========================" > "today_rpt2"
print `` ID Number Arrival Time'' >``today_rpt2''
close( "today_rpt2" )
}
{printf( "%s %sn", $1 ,$2 )"sort +2n >>today_rpt2"}
执行如下命令：
awk -f reformat2。awk arr。dat
执行后, 系统会自动将 sort 后的数据加( Append； 因为使用 `` >>'')到档案 today_rpt2末端。 today_rpt2 内容如下 ：
Today is Sep 17
=========================
ID Number Arrival Time
1005 8：12
1006 7：45
1008 8：01
1012 7：46
1025 7：27
1028 7：49
1029 7：57
1034 7：26
1042 7：59
1051 7：51
1052 8：05
1101 7：32
说明 ：
AWK程序由三个主要部分构成 ：
[i] Pattern { Action} 指令
[ii] 函数主体。 例如 ： function double( x ){ return 2*x } (参考第11节 Recursive Program )
[iii] Comment ( 以 # 开头识别之 )
AWK 的输入指令 getline, 每次读取一列数据。 若getline之后未接任何变量, 则所读入之资料将以$0 纪录, 否则以所指定的变量储存之。
[ 以本例而言] ：
执行 "date" | getline 后,$0 之值为 "Wed Aug 17 11：04：44 EAT 1994"，当 $0 之值被更新时, AWK将自动更新相关的内建变量, 如 ： $1,$2,。。,NF。故 $2 之值将为"Aug", $3之值将为"17"。 (有少数旧版之AWK不允许即使用者自行更新(update)$0之值,或者update$0时,它不会自动更新 $1,$2,。。NF。 这情况下, 可改用gawk,或nawk。 否则使用者也可自行以AWK字符串函数split()来分隔$0上的资料)
本程序中 printf() 指令会被执行12次( 因为有arr。dat中有12笔数据), 但读者不用担心数据被重复sort了12次。 当AWK结束该程序时才会 close 这个 pipe , 此时才将这12笔数据一次送往系统, 并呼叫 "sort +2n >> today_rpt2" 处理之。
AWK提供另一个叫用Shell命令的方法, 即使用AWK函数 system("shell命令")
例如 ：
awk '
BEGIN{
system("date > date.dat")
getline "today_rpt3"
print "=========================">"today_rpt3"
print `` ID Number Arrival Time'' > ``today_rpt3''
close( "today_rpt3" )
}
{
#已更改字段切割方式, $2表到达小时数, $3表分钟数
arrival = HM_to_M($2, $3)
printf(" %s %s：%s %sn", $1,$2, $3
, arrival > 480 ? "*"： " " ) | "sort +0n>>today_rpt3"
total += arrival
END {
close("today_rpt3") #参考本节说明 5
close("sort +0n >> today_rpt3")
printf(" Average arrival time ： %d：%dn",
total/NR/60, (total/NR)%60 ) >> "today_rpt3"
}
function HM_to_M( hour, min ){
return hour*60 + min
}
' $*
并执行如下指令 ：
$ reformat3 arr。doc
执行后,档案 today_rpt3 的内容如下：
Today is Sep 21
=========================
ID Number Arrival Time
1005 8：12 *
1006 7：45
1008 8：01 *
1012 7：46
1025 7：27
1028 7：49
1029 7：57
1034 7：26
1042 7：59
1051 7：51
1052 8：05 *
1101 7：32
Average arrival time ： 7：49
{verbatim}
说明 ：
AWK 中亦允许使用者自定函数。 函数定义方式请参考本程序,function 为 AWK 的保留字。HM_to_M( ) 这函数负责将所传入之小时及分钟数转换成以分钟为单位。 使用者自定函数时, 还有许多细节须留心, 如 data scope,……( 请参考第十节 Recursive Program)
AWK中亦提供与 C 语言中相同的 Conditional Operator。 上式printf()中使用arrival >480 ? "*" ： " "}即为一例，若 arrival 大于 480 则return "*" , 否则return " "。
% 为AWK之运算子(operator), 其作用与 C 语言中之 % 相同(取余数)。
NR(Number of Record) 为AWK的内建变量。 表AWK执行该程序后所读入的纪录笔数。
AWK 中提供的 close( )指令, 语法如下(有二种) ：
close( filename )
close( 置于pipe之前的command )
为何本程序使用了两个 close( ) 指令 ：
指令 close( "sort +2n >> today_rpt3" ), 其意思为 close 程序中置于 "sort +2n >> today_rpt3 " 之前的 Pipe, 并立刻呼叫 Shell 来执行"sort +2n >> today_rpt3"。(若未执行这指令, AWK必须于结束该程序时才会进行上述动作；则这12笔sort后的数据将被 append 到档案 today_rpt3 中 "Average arrival time ： 。。。" 的后方)，因为 Shell 排序后的数据也要写到 today_rpt3, 所以AWK必须先关闭使用中的today_rpt3 以利 Shell 正确将排序后的数据 append 到today_rpt3否则2个不同的 process 同时开启一档案进行输出将会产生不可预期的结果。读者应留心上述两点,才可正确控制数据输出到档案中的顺序。
指令 close("sort +0n >> today_rpt3")中字符串 "sort +0n >> today_rpt3"
须与 pipe | 后方的 Shell Command 名称一字不差, 否则AWK将视为二个不同的 pipe。
读者可于BEGIN{}中先令变量 Sys_call = "sort +0n >> today_rpt3",
程序中再一律以 Sys_call 代替该字符串。
7.5 使用 getline 来读取数据
范例 ： 承上题，从档案中读取当月迟到次数, 并根据当日出勤状况更新迟到累计数。(按不同的月份累计于不同的档案)
分析：
程序中自动抓取系统日期的月份名称, 连接上``late.dat'',形成累计迟到次数的文件名称(如 ： Jullate.dat,……), 并以变量late_file纪录该文件名。累计迟到次数的档案中的数据格式为 ：员工代号(ID) 迟到次数
例如, 执行本程序前档案 Auglate.dat 的内容为 ：
1012 0
1006 1
1052 2
1034 0
1005 0
1029 2
1042 0
1051 0
1008 0
1101 0
1025 1
1028 0
编写程序 reformat4。awk 如下：
awk '
BEGIN {
Sys_Sort = "sort +0n >> today_rpt4"
Result = "today_rpt4"
# 改变字段切割的方式
# 令 Shell执行``date''； getline 读取结果,并以$0纪录
FS = "[t：]+"
"date" | getline
print " Today is " , $2, $3 >Result
print "=========================" > Result
print `` ID Number Arrival Time'' > Result
close( Result )
# 从文件按中读取迟到数据, 并用数组cnt[ ]记录。 数组cnt[ ]中以
员工代号为# 注标, 所对应的值为该员工之迟到次数。
late_file = $2 "late.dat"
while( getline 0 ) cnt[$1] = $2
close( late_file )
}
{
# 已更改字段切割方式, $2表小时数,$3表分钟数
arrival = HM_to_M($2, $3)
if( arrival > 480 ){
mark = "*" # 若当天迟到,应再增加其迟到次数, 且令
mark 为''*''.cnt[$1]++ }
else mark = " "
# message 用以显示该员工的迟到累计数, 若未曾迟到
message 为空字符串
message = cnt[$1] ? cnt[$1] " times" ： ""
printf("%s%2d：%2d %5s %sn", $1, $2, $3, mark,
message ) | Sys_Sort
total += arrival
}
END {
close( Result )
close( Sys_Sort )
printf(" Average arrival time ： %d：%dn", total/NR/60,
(total/NR)%60 ) >> Result
#将数组cnt[ ]中新的迟到数据写回档案中
for( any in cnt )
print any, cnt[any] > late_file
}
function HM_to_M( hour, min ){
return hour*60 + min
}
' $*
执行后, today_rpt4 之内容如下 ：
Today is Aug 17
================================
ID Number Arrival Time
1005 8：12 * 1 times
1006 7：45 1 times
1008 8： 1 * 1 times
1012 7：46
1025 7：27 1 times
1028 7：49
1029 7：57 2 times
1034 7：26
1042 7：59
1051 7：51
1052 8： 5 * 3 times
1101 7：32
Average arrival time ： 7：49
说明 ：
latefile 是一变量，用以记录迟到次数的档案之档名。 latefile之值由两部分构成, 前半部是当月月份名称(由呼叫"date"取得)后半部固定为"late.dat" 如 ： Junlate.dat。
指令 getline 0 ) {。。。。}可读入档案中的每一笔数据并予处理。 这是AWK中user自行读取档案数据的一个重要模式。
数组 late_cnt[ ] 以员工ID。 当注标(index), 其对应值表其迟到的次数。执行结束后, 利用 for(Variable in array ){。。}之语法
for( any in late_cnt ) print any, late_cnt[any]> latefile
将更新过的迟到数据重新写回记录迟到次数之档案。 该语法于第5节中曾有说明。
八．处理 Multi-line 记录
AWK每次从数据文件中只读取一笔Record, 进行处理。 AWK系依照其内建变量 RS(Record Separator) 的定义将档案中的数据分隔成一笔一笔的Record。 RS 的默认值是 "n"(跳行符号), 故平常AWK中一行数据就是一笔 Record。但有些档案中一笔Record涵盖了数行数据, 这种情况下不能再以 "n" 来分隔Records。最常使用的方法是相邻的Records之间改以 一个空白行 来隔开。 在AWK程序中, 令 RS = ""(空字符串)后, AWK把会空白行当成来档案中Record的分隔符。 显然AWK对 RS = "" 另有解释方式,简略描述如下, 当 RS = "" 时，数个并邻的空白行, AWK仅视成一个单一的Record Saparator。 (AWK不会于两个紧并的空白行之间读取一笔空的Record) AWK会略过(skip)檔首或檔末的空白行。 故不会因为档首或档末的空白行,造成AWK多读入了二笔空的数据。
请观察下例,首先建立一个数据文件 week。rpt如下： 张长弓 GNUPLOT 入门 吴国强 Latex 简介 VAST-2 使用手册 mathematica 入门 李小华 AWK Tutorial Guide Regular Expression 该档案档首有数列空白行, 各笔Record之间使用一个或数个空白行隔开。 读者请细心观察, 当 RS = "" 时, AWK读取该数据文件之方式。
编辑一个AWK程序档案 make_report如下：
awk ' BEGIN { FS = "n" RS = "" split( "一。 二。 三。 四。 五。 六。 七。 八。 九。", C_Number, " " ) } { printf("n%s 报告人 ： %s n",C_Number[NR],$1) for( i=2； i { >}= NF； i++) printf(" %d。 %sn", i-1, $i) } ' $ 执行 $ make_report week。
rpt 屏幕产生结果如下：
一。 报告人 ： 张长弓 1。 GNUPLOT 入门 二。 报告人 ： 吴国强 1。 Latex 简介 2。 VAST-2 使用手册 3。 mathematica 入门 三。 报告人 ： 李小华 1。 AWK Tutorial Guide 2。 Regular Expression 说明：
本程序同时也改变字段分隔字符( FS= "n"), 如此一笔数据中的每一行都是一个field。 例如 ： AWK读入的第一笔 Record 为张长弓 GNUPLOT 入门 其中 $1 指的是"张长弓", $2 指的是"GNUPLOT 入门"
上式中的C_Number[ ]是一个数组(array), 用以记录中文数字。 例如 ： C_Number[1] = "一", C_Number[2] = "二" 这过程使用AWK字符串函数 split( ) 来把中文数字放进数组 Number[ ]中。 函数 split( )用法如下 ： split( 原字符串, 数组名, 分隔字符(field separator) ) ： AWK将依所指定的分隔字符(field separator)分隔原字符串成一个个的字段(field), 并以指定的 数组 记录各个被分隔的字段
九．如何读取命令列上的参数
大部分的应用程序都容许使用者于命令之后增加一些选择性的参数。执行AWK时这些参数大部分用于指定数据文件文件名, 有时希望在程序中能从命令列上得到一些其它用途的数据。 本小节中将叙述如何在AWK程序中取用这些参数。
建立档案如下, 命名为 see_arg ：
{
awk '
BEGIN {
for( i=0； i
十一．使用AWK编写Recusive Program
AWK 中除了函数的参数列(Argument List)上的参数(Arguments)外,所有变量不管于何处出现全被视为 Global variable。 其生命持续至程序结束 --- 该变量不论在function外或 function内皆可使用, 只要变量名称相同所使用的就是同一个变量,直到程序结束。 因 Recusive 函数内部的变量, 会因它呼叫子函数(本身)而重复使用，故编写该类函数时， 应特别留心。
例如 ： 执行
awk '
BEGIN
{
x = 35
y = 45
test_variable( x )
printf("Return to main ： arg1= %d, x= %d, y= %d, z= %dn",
arg1, x, y, z)
}
function test_variable( arg1 )
{
arg1++ # arg1 为参数列上的参数, 是local variable。 离开此函数后将消失。
y ++ # 会改变主式中的变量 y
z = 55 # z 为该函数中新使用的变量, 主程序中变量 z 仍可被使用。
printf("Inside the function： arg1=%d,x=%d, y=%d, z=%dn",
arg1, x, y, z)
} '
结果屏幕印出
Inside the function： arg1= 36,x= 35, y= 46, z= 55
Return to main ： arg1= 0, x= 35, y= 46, z= 55
由上可知 ：
函数内可任意使用主程序中的任何变量。
函数内所启用的任何变量(除参数外), 于该函数之外依然可以使用。
此特性优劣参半, 最大的坏处是式中的变量不易被保护, 特别是recursive呼叫本身, 执行子函数时会破坏父函数内的变量。
权变的方法是 ：
在函数的 Argument list 上虚列一些 Arguments。函数执行中使用这些虚列的 Arguments 来记录不想被破坏的数据,如此执行子函数时就不会破坏到这些数据。 此外AWK 并不会检查,呼叫函数时所传递的参数个数是否一致。
例如 ： 定义 recursive function 如下 ：
function demo( arg1 )# 最常见的错误例子
。。。。。。。。
for(i=1； i 大于
= 大于或等于
= 23 && FNR = 23 && FNR= 23 时, AWK 就 turn on 这个 switch； 因为随着资料列的读入, AWK不停的累加 FNR。当 FNR = 28 时, Pattern2 FNR == 28 便成立, 这时 AWK会关上这个 switch。当 switch 打开的期间, AWK 会执行"print " " $0'' 。( FNR 为AWK的内建变量, 请参考附录 D )
2．Appendix B Actions
Actions 是由下列指令(statement)所组成 ：
expression ( function calls, assignments……)
print expression-list
printf( format, expression-list)
if( expression ) statement [else statement]
while( expression ) statement
do statement while( expression)
for( expression； expression； expression) statement
for( variable in array) statement
delete
break
continue
next
exit [expression]
statement
AWK 中大部分指令与 C 语言中的用法一致, 此处仅介绍较为常用或容易混淆之指令的用法。
流程控制指令：
if 指令
语法
if (expression) statement1 [else statement2 ]
范例 ：
if( $1> 25 )
print "The 1st field is larger than 25"
else print "The 1st field is not larger than 25"
(a)与 C 语言中相同, 若 expression 计算(evaluate)后之值不为 0
或空字符串, 则执行 statement1； 否则执行 statement2。
(b)进行逻辑判断的expression所传回的值有两种, 若最后的逻辑值
为true, 则传回1, 否则传回0。
(c)语法中else statement2 以[ ] 前后括住表示该部分可视需要而
予加入或省略。
while 指令
语法 ：
while( expression ) statement
范例 ：
while( match(buffer,/[0-9]+.c/ ) ){
print "Find ：" substr( buffer,RSTART, RLENGTH)
buff = substr( buffer, RSTART + RLENGTH)
}
上列范例找出 buffer 中所有能合于(match) /[0-9]+.c/(数字之后接上 ``.c''的所有子字符串)。范例中 while 以函数 match( )所传回的值做为判断条件。 若buffer中还含有合于指定条件的子字符串(match成功), 则 match()函数传回1,while 将持续进行其后之statement。
do-while 指令
语法 ：
do statement while(expression)
范例 ：
do{
print "Enter y or n ! "
getline data 0 )
{
if( $1 == 0 ) # 所读取的数据置于 $0
break # AWK立刻把 $0 上新的字段数据
else # 指定给 $1, $2, 。。。$NF
print $2 / $1
}
上例中, AWK 不断地从档案 {datafile}中读取数据, 当$1等于0时,就停止该执行循环。
continue 指令
循环中的 statement 进行到一半时, 执行 continue 指令来掠过回圈中尚未执行的statement。
范例 ：
for( index in X_array)
{
if( index !~ /[0-9]+/ ) continue
print "There is a digital index", index
}
上例中若 index 不为数字则执行 continue, 故将掠过(不执行)其后
的指令。需留心 continue 与 break 的差异 ： 执行 continue 只是掠过其后未执行的statement, 但并未跳离开该循环。
next 指令
执行 next 指令时, AWK 将掠过位于该指令(next)之后的所有指令
(包括其后的所有Pattern { Actions }), 接着读取下一笔数据列,
继续从第一个 Pattern {Actions}
执行起。
范例 ：
/^[ t]*$/ { print "This is a blank line! Do nothing here !"
next
}
$2 != 0 { print $1, $1/$2 }
上例中, 当 AWK 读入的资料列为空白行时( match /^{}[]*$/ )除打印讯息外且执行 next, 故 AWK 将掠过其后的指令, 继续读取下一笔数据, 从头(第一个 Pattern { Actions })执行起。
exit 指令
执行 exit 指令时, AWK将立刻跳离(停止执行)该AWK程序。
AWK 中的 I/O 指令
printf 指令
该指令与 C 语言中的用法相同, 可藉由该指令控制数据输出时的格式。
语法 ：
printf("format", item1, item2,。。 )
范 例 ：
id = "BE-2647"； ave = 89
printf("ID# ： %s Ave Score ： %dn", id, ave)
(a)结果印出 ：
ID# ：BE-647 Ave Score ： 89
(b)format 部分系由 一般的字符串(String Constant) 及 格式控制字符
(Formatcontrol letter, 其前会加上一个%字符)所构成。 以上式为例 "ID# ： " 及 " Ave Score ： " 为一般字符串。 %s 及 %d 为格式控制字符。
(c)印出时, 一般字符串将被原封不动地印出。 遇到格式控制字符时,
则依序把 format后方之 item 转换成所指定的格式后印出。
(d)有关的细节, 读者可从介绍 C 语言的书籍上得到较完整的介绍。
(e)print 及 printf 两个指令, 其后可使用>或 将输出到stdout的数据 Redirct到其它档案, 7。1 Redirect Output to Files 中有完整的
范例说明。
print 指令
范 例 ：
id = "BE-267"； ave = 89
print "ID# ：", id, "Ave Score ："ave
(a)结果印出 ：
ID# ： BE-267 Ave Score ：89
(b)print 之后可接上字符串常数(Constant String)或变量。 它们彼此间可用``,'' 隔开。
(c)上式中, 字符串 "ID# ：" 与变量 id 之间使用``,''隔开, 印出时两者之间会以自动 OFS(请参考 D 内建变量 OFS) 隔开。 OFS 之值一般内定为"一个空格符"
(d)上式中字符串 "Ave Score ：" 与变量ave之间并未以``,''隔开, AWK会将这两者先当成字符串concate在一起(变成``Ave Score ：89")后, 再予印出
(e)print 及 printf 两个指令, 其后可使用> 或> 将输出到stdout的数据 Redirct到其它档案, 7。1 Redirect Output to Files 中有完整的
范例说明。
getline 指令
语法 由何处读取数据 资料读入后置于
getline var> file 所指定的 file 变量 var(var省略时,表示置于$0)
| getline var pipe 变量 var(var省略时,表示置于$0)
getline var 见 注一 变量 var(var省略时,表示置于$0)
注一 ： 当 Pattern 为 BEGIN 或 END 时, getline 将由 stdin 读取数据,否则由AWK正处理的数据文件上读取数据。
getline 一次读取一行数据,
若读取成功则return 1,
若读取失败则return -1,
若遇到档案结束(EOF), 则return 0
close 指令
该指令用以关闭一个开启的档案, 或 pipe(见下例)
范 例 ：
awk '
BEGIN { print "ID # Salary" > "data.rpt" }
{ print $1 , $2 * $3 | "sort +0n > data.rpt" }
END{ close( "data.rpt" )
close( "sort +0n > data.rpt" )
print " There are", NR, "records processed。"
}
说 明 ：
(a)上例中, 一开始执行 print "ID # Salary" > "data.rpt" 指令来印出一行抬头。 它使用 I/O Redirection( > )将数据转输出到data.rpt,故此时档案 {data.rpt} 是处于 Open 状态。
(b)指令 print $1, $2 * $3 不停的将印出的资料送往 pipe(|), AWK于程序将结束时才会呼叫 shell 使用指令 "sort +0n > data.rpt" 来处理 pipe 中的数据； 并未立即执行, 这点与 Unix 中pipe的用法不尽相同。
(c)最后希望于档案 {data.rpt}之``末尾''处加上一行 "There are。。。。。"。但此时, Shell尚未执行 "sort +0n > data.rpt" 故各数据列排序后的 ID 及 Salary 等数据尚未写入data.rpt。 所以得命令 AWK提前先通知 Shell 执行命令 "sort +0n > data.rpt" 来处理 pipe中的资料。 AWK中这个动作称为 close pipe。 系由执行 close( "shell command" )来完成。 需留心 close( )指令中的 shell command 需与``|''后方的 shell command 完全相同(一字不差), 较佳的方法是先以该字符串定义一个简短的变量, 程序中再以此变量代替该 shell command
(d)为什么要执行 close("data.rpt") ? 因为 sort 完后的资料也将写到data.rpt,而该档案正为AWK所开启使用(write)中, 故AWK程序中应先关闭 data.rpt。 以免造成因二个 processes 同时开启一个档案进行输出(write)所产生的错误。
system 指令
该指令用以执行 Shell上 的 command。
范 例 ：
DataFile = "invent。rpt"
system( "rm " DataFile )
说明 ：
(a)system("字符串")指令接受一个字符串当成Shell的命令。 上例中, 使用一个字符串常数"rm " 连接(concate)一个变量 DataFile 形成要求 Shell执行的命令。Shell 实际执行的命令为 ``rm invent。rpt''。
``|'' pipe指令
``|'' 配合 AWK 输出指令, 可把 output 到 stdout 的数据继续转送给 Shell 上的令一命令%当成input的数据。
``|'' 配合 AWK getline 指令, 可呼叫 Shell 执行某一命令, 再以 AWK的 getline 指令将该命令的所产生的数据读进 AWK 程序中。
范 例 ：
{ print $1, $2 * $3 | "sort +1n > result" }
"date" | getline Date_data
读者请参考 7。2 Using System Resources 其中有完整的范例说明。
AWK 释放所占用的内存的指令
AWK 程序中常使用数组(Array)来记忆大量数据。 delete 指令便是用来释放数组中的元素所所占用的记忆空间。
范 例 ：
for( any in X_arr )
delete X_arr[any]
读者请留心, delete 指令一次只能释放数组中的一个``元素''。
AWK 中的数学操作数(Arithmetic Operators)
+(加), -(减), *(乘), /(除), %(求余数), ^(指数) 与 C 语言中用法相同
AWK 中的 Assignment Operators
=, +=, -=, *= , /=, %=, ^=
x += 5 的意思为 x = x + 5, 其余类推。
AWK 中的 Conditonal Operator
语 法 ：
判断条件 ? value1 ： value2
若 判断条件 成立(true) 则传回 value1, 否则传回 value2。
AWK 中的逻辑操作数(Logical Operators)
&&( and ), ||or, !(not)
Extended Regular Expression 中使用 ``|'' 表示 or 请勿混淆。
AWK 中的关系操作数(Relational Operators)
>, >=, , > =,0) {
print substr(data,{ RSTART, RLENGTH })
sub(/[0-9]+/,"")
}
}
' $* }
结果印出 ：
12
34
56
61
sub( )中第三个参数(原字符串)若未指定,则其默认值为$0。可用 sub( /[9-0]+/,"digital" ) 表示 sub(/[0-9]+/,"digital",$0 )gsub( 比对用的 Regular Expression}, 将替换的新字符串, 原字符串)这个函数与 sub()一样,同样是进行字符串取代的函数。 唯一不同点是gsub()会取代所有合条件的子字符串。
gsub()会传回被取代的子字符串个数。
请参考 sub()。
substr( 字符串,起始位置 [,长度] )：
传回从起始位置起,指定长度之子字符串。 若未指定长度,则传回起始位置到自串末尾之子字符串。
执行下例
awk {' BEGIN{ print substr( "User：Wei-Lin Liu", 6)}
结果印出
Wei-Lin Liu（2）数学函数
int(x) ： 传回x的整数部分(去掉小数)。
例如 ：
int(7.7) 将传回 7
int(-7.7) 将传回 -7
sqrt(x) ： 传回x的平方根。
例如 ：
sqart(9) 将传回 3
若 x 为负数,则执行 sqrt(x)时将造成 Run Time Error
exp(x) ： 将传回e的x次方。
例如 ：
exp(1) 将传回 2.71828
log(x) ： 将传回x以e为底的对数值。
例如 ：
log(e) = 1
若 x
没有评论:
发表评论