AWK：解釋型的編程語言 ，文本處理 輸出格式化的文本報表 執行算數運算 執行字符串操作

$ 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: (standard)
-f progfile --file=progfile
-F fs --field-separator=fs
-v var=val --assign=var=val
Short options : GNU long options: (extensions)
-b --characters-as-bytes
-c --traditional
-C --copyright
-d[file] --dump-variables[=file]
-e ‘program-text‘ --source=‘program-text‘
-E file --exec=file
-g --gen-pot
-h --help
-L [fatal] --lint[=fatal]
-n --non-decimal-data
-N --use-lc-numeric
-O --optimize
-p[file] --profile[=file]
-P --posix
-r --re-interval
-S --sandbox
-t --lint-old
-V --version


AWK工作流： 讀取，執行和重復
即 從BEGIN開始執行，從輸入流讀取一行，執行，讀取，執行。。一直到結束END


BEGIN語句塊的語法 BEGIN {awk-commands}
BODY語句塊的語法 /pattern/ {awk-commands}
END語句塊的語法 END {awk-commands}


使用單引號在命令行中指定AWK命令 awk ‘{print}‘ xx.txt 顯示xx內容

只打印輸入字段中的3.4列。 awk ‘{print $3 "\t" $4}‘‘ xx.txt

打印出所有匹配模式的行(包含a的行) awk ‘/a/ {print $0}‘ xx.txt 等價 awk ‘/a/‘ xx.txt

統計匹配模式的行數 awk ‘/a/{++cnt} END {print "Count = ", cnt}‘ xx.txt


打印超過18個字符的行 $ awk ‘length($0) > 18‘ xx.txt

使用腳本文件提供AWK命令 awk -f command.awk xx.txt 命令的內容在command.awk 如{print}



AWK標準選項 -v 變量賦值選項 如 awk -v name=shy ‘BEGIN{printf "Name = %s\n", name}‘


輸出排好序的全局變量列表和它們最終的值到文件中，默認的文件是 awkvars.out
$ awk --dump-variables ‘‘
$ cat awkvars.out


允許檢查程序的不兼容性或者模棱兩可的代碼，當提供參數 fatal的時候，它會對待Warning消息作為Error。
$ awk --lint ‘‘ /bin/ls


--posix 選項 該選項開啟嚴格的POSIX兼容




輸出一份格式化之後的程序到文件中，默認文件是 awkprof.out。
$ awk --profile ‘BEGIN{printf"---|Header|--\n"} {print}
END{printf"---|Footer|---\n"}‘ marks.txt > /dev/null
$ cat awkprof.out


--traditional 選項 禁止所有的gawk規範的擴展。

------------------------------------------------------------
內建變量:
AWK提供了很多內置的變量，它們在開發AWK腳本的過程中起著非常重要的角色。

標準AWK變量
ARGC 命令行參數個數


命令行中提供的參數個數
$ 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"] }‘
mylxsw

FILENAME 當前文件名
$ awk ‘END {print FILENAME}‘ marks.txt
marks.txt


FS 輸入字段的分隔符
代表了輸入字段的分隔符，默認值為空格，可以通過-F選項在命令行選項中修改它。
$ awk ‘BEGIN {print "FS = " FS}‘ | cat -vte
FS = $
$ awk -F , ‘BEGIN {print "FS = " FS}‘ | cat -vte
FS = ,$


NF 字段數目
代表了當前行中的字段數目，例如下面例子打印出了包含大於兩個字段的行
$ echo -e "One Two\nOne Two Three\nOne Two Three Four" | awk ‘NF > 2‘
One Two Three
One Two Three Four


NR 行號

$ echo -e "One Two\nOne Two Three\nOne Two Three Four" | awk ‘NR < 3‘
One Two
One Two Three

FNR 行號（相對當前文件）

與NR相似，不過在處理多文件時更有用，獲取的行號相對於當前文件。
OFMT 輸出格式數字

默認值為%.6g

$ awk ‘BEGIN {print "OFMT = " OFMT}‘
OFMT = %.6g

OFS 輸出字段分隔符

輸出字段分隔符，默認為空格

$ awk ‘BEGIN {print "OFS = " OFS}‘ | cat -vte
OFS = $

ORS 輸出行分隔符

默認值為換行符

$ awk ‘BEGIN {print "ORS = " ORS}‘ | cat -vte
ORS = $
$

RLENGTH

代表了 match 函數匹配的字符串長度。

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

RS 輸入記錄分隔符

$ awk ‘BEGIN {print "RS = " RS}‘ | cat -vte
RS = $
$

RSTART

match函數匹配的第一次出現位置

$ awk ‘BEGIN { if (match("One Two Three", "Thre")) { print RSTART } }
9

SUBSEP 數組子腳本的分隔符

數組子腳本的分隔符，默認為\034

$ awk ‘BEGIN { print "SUBSEP = " SUBSEP }‘ | cat -vte
SUBSEP = ^\$

$ 0 代表了當前行

代表了當前行


$ awk ‘{print $0}‘ marks.txt
1) Amit Physics 80
2) Rahul Maths 90
3) Shyam Biology 87
4) Kedar English 85
5) Hari History 89

$n

當前行中的第n個字段
$ awk ‘{print $3 "\t" $4}‘ marks.txt
Physics 80
Maths 90
Biology 87
English 85
History 89

GNU AWK的變量
ARGIND

當前被處理的ARGV的索引
$ awk ‘{
print "ARGIND = ", ARGIND; print "Filename = ", ARGV[ARGIND]
}‘ junk1 junk2 junk3
ARGIND = 1
Filename = junk1
ARGIND = 2
Filename = junk2
ARGIND = 3
Filename = junk3

在非POSIX系統上指定對所有的文件I/O采用二進制模式。
ERRORNO

一個代表了getline跳轉失敗或者是close調用失敗的錯誤的字符串。

$ awk ‘BEGIN { ret = getline < "junk.txt"; if (ret == -1) print "Error:", ERRNO }‘
Error: No such file or directory

FIELDWIDTHS

設置了空格分隔的字段寬度變量列表的話，GAWK會將輸入解析為固定寬度的字段，而不是使用FS進行分隔。
IGNORECASE

設置了這個變量的話，AWK會忽略大小寫。

$ awk ‘BEGIN{IGNORECASE = 1} /amit/‘ marks.txt
1) Amit Physics 80

LINT

提供了對–lint選項的動態控制。

$ awk ‘BEGIN {LINT = 1; a}‘
awk: cmd. line:1: warning: reference to uninitialized variable `a‘
awk: cmd. line:1: warning: statement has no effect

PROCINFO

包含進程信息的關聯數組，例如UID，進程ID等


$ awk ‘BEGIN { print PROCINFO["pid"] }‘
4316

TEXTDOMAIN

代表了AWK的文本域，用於查找字符串的本地化翻譯。

$ awk ‘BEGIN { print TEXTDOMAIN }‘
messages

操作符

與其它編程語言一樣，AWK也提供了大量的操作符。
算數操作符

算數操作符不多說，直接看例子，無非就是+-*/%
$ awk ‘BEGIN { a = 50; b = 20; print "(a + b) = ", (a + b) }‘
(a + b) = 70

$ awk ‘BEGIN { a = 50; b = 20; print "(a - b) = ", (a - b) }‘
(a - b) = 30

$ awk ‘BEGIN { a = 50; b = 20; print "(a * b) = ", (a * b) }‘
(a * b) = 1000

$ awk ‘BEGIN { a = 50; b = 20; print "(a / b) = ", (a / b) }‘
(a / b) = 2.5

$ awk ‘BEGIN { a = 50; b = 20; print "(a % b) = ", (a % b) }‘
(a % b) = 10

增減運算符

自增自減與C語言一致。
$ awk ‘BEGIN { a = 10; b = ++a; printf "a = %d, b = %d\n", a, b }‘
a = 11, b = 11
$ awk ‘BEGIN { a = 10; b = --a; printf "a = %d, b = %d\n", a, b }‘
a = 9, b = 9
$ awk ‘BEGIN { a = 10; b = a++; printf "a = %d, b = %d\n", a, b }‘
a = 11, b = 10
$ awk ‘BEGIN { a = 10; b = a--; printf "a = %d, b = %d\n", a, b }‘
a = 9, b = 10

賦值操作符

$ awk ‘BEGIN { name = "Jerry"; print "My name is", name }‘
My name is Jerry
$ awk ‘BEGIN { cnt = 10; cnt += 10; print "Counter =", cnt }‘
Counter = 20
$ awk ‘BEGIN { cnt = 100; cnt -= 10; print "Counter =", cnt }‘
Counter = 90
$ awk ‘BEGIN { cnt = 10; cnt *= 10; print "Counter =", cnt }‘
Counter = 100
$ awk ‘BEGIN { cnt = 100; cnt /= 5; print "Counter =", cnt }‘
Counter = 20
$ awk ‘BEGIN { cnt = 100; cnt %= 8; print "Counter =", cnt }‘
Counter = 4
$ awk ‘BEGIN { cnt = 2; cnt ^= 4; print "Counter =", cnt }‘
Counter = 16
$ awk ‘BEGIN { cnt = 2; cnt **= 4; print "Counter =", cnt }‘
Counter = 16

關系操作符

$ awk ‘BEGIN { a = 10; b = 10; if (a == b) print "a == b" }‘
a == b
$ awk ‘BEGIN { a = 10; b = 20; if (a != b) print "a != b" }‘
a != b
$ awk ‘BEGIN { a = 10; b = 20; if (a a ) print "b > a" }‘
b > a

邏輯操作符


$ awk ‘BEGIN {
num = 5; if (num >= 0 && num <= 7) printf "%d is in octal format\n", num
}‘
5 is in octal format
$ awk ‘BEGIN {
ch = "\n"; if (ch == " " || ch == "\t" || ch == "\n")
print "Current character is whitespace."
}‘
Current character is whitespace.
$ awk ‘BEGIN { name = ""; if (! length(name)) print "name is empty string." }‘
name is empty string.

三元操作符

$ awk ‘BEGIN { a = 10; b = 20; (a > b) ? max = a : max = b; print "Max =", max}‘
Max = 20

一元操作符


$ awk ‘BEGIN { a = -10; a = +a; print "a =", a }‘
a = -10
$ awk ‘BEGIN { a = -10; a = -a; print "a =", a }‘
a = 10

指數操作符

$ awk ‘BEGIN { a = 10; a = a ^ 2; print "a =", a }‘
a = 100

$ awk ‘BEGIN { a = 10; a ^= 2; print "a =", a }‘
a = 100

字符串連接操作符

$ awk ‘BEGIN { str1 = "Hello, "; str2 = "World"; str3 = str1 str2; print str3 }‘
Hello, World

數組成員操作符

$ awk ‘BEGIN {
arr[0] = 1; arr[1] = 2; arr[2] = 3; for (i in arr) printf "arr[%d] = %d\n", i, arr[i]
}‘
arr[2] = 3
arr[0] = 1
arr[1] = 2

正則表達式操作符

正則表達式操作符使用 ~ 和 !~ 分別代表匹配和不匹配。


$ awk ‘$0 ~ 9‘ marks.txt
2) Rahul Maths 90
5) Hari History 89
$ awk ‘$0 !~ 9‘ marks.txt
1) Amit Physics 80
3) Shyam Biology 87
4) Kedar English 85
# 匹配正則表達式需要在表達式前後添加反斜線，與js類似吧
$ tail -n 40 /var/log/nginx/access.log | awk ‘$0 ~ /ip

\[127\.0\.0\.1\]
/‘

更多關於正則表達式請看後面的正則表達式部分

正則表達式

AWK在處理正則表達式方面是非常強大的，使用簡單的正則表達式可以處理非常復雜的問題。

$ echo -e "cat\nbat\nfun\nfin\nfan" | awk ‘/f.n/‘
fun
fin
fan
$ echo -e "This\nThat\nThere\nTheir\nthese" | awk ‘/^The/‘
There
Their
$ echo -e "knife\nknow\nfun\nfin\nfan\nnine" | awk ‘/n$/‘
fun
fin
fan
$ echo -e "Call\nTall\nBall" | awk ‘/[CT]all/‘
Call
Tall
$ echo -e "Call\nTall\nBall" | awk ‘/[^CT]all/‘
Ball
$ echo -e "Call\nTall\nBall\nSmall\nShall" | awk ‘/Call|Ball/‘
Call
Ball
$ echo -e "Colour\nColor" | awk ‘/Colou?r/‘
Colour
Color
$ echo -e "ca\ncat\ncatt" | awk ‘/cat*/‘
ca
cat
catt
$ echo -e "111\n22\n123\n234\n456\n222" | awk ‘/2+/‘
22
123
234
222
$ echo -e "Apple Juice\nApple Pie\nApple Tart\nApple Cake" | awk ‘/Apple (Juice|Cake)/‘
Apple Juice
Apple Cake

數組

AWK支持關聯數組，也就是說，不僅可以使用數字索引的數組，還可以使用字符串作為索引，而且數字索引也不要求是連續的。數組不需要聲明可以直接使用，語法如下：
array_name[index] = value
1

array_name[index] = value

創建數組的方式非常簡單，直接為變量賦值即可


$ 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"];
print fruits["orange"]
}‘

在AWK中，只支持一維數組，但是可以通過一維數組模擬多維，例如我們有一個3×3的三維數組


100 200 300
400 500 600
700 800 900

可以這樣操作


$ 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"];
}‘
array[0,0] = 100
array[0,1] = 200
array[0,2] = 300
array[1,0] = 400
array[1,1] = 500
array[1,2] = 600

流程控制

流程控制語句與大多數語言一樣，基本格式如下

if (condition)
action

if (condition) {
action-1
action-1
.
.
action-n
}

if (condition)
action-1
else if (condition2)
action-2
else
action-3

例如：


$ awk ‘BEGIN {
num = 11; if (num % 2 == 0) printf "%d is even number.\n", num;
else printf "%d is odd number.\n", num
}‘
$ awk ‘BEGIN {
a = 30;
if (a==10)
print "a = 10";
else if (a == 20)
print "a = 20";
else if (a == 30)
print "a = 30";
}‘

循環

循環操作與其他C系語言一樣，主要包括 for，while，do...while，break，continue 語句，當然，還有一個 exit語句用於退出腳本執行。
for (initialisation; condition; increment/decrement)
action

while (condition)
action

do
action
while (condition)
例子：
$ awk ‘BEGIN { for (i = 1; i 50) break; else print "Sum =", sum
}
}‘

$ awk ‘BEGIN {
for (i = 1; i 50) exit(10); else print "Sum =", sum
}
}‘

exit用於退出腳本，參數為退出的狀態碼，可以通過shell中的$?獲取

函數
內建函數

AWK提供了很多方便的內建函數供編程人員使用。由於函數比較多，個人覺得單純看每個函數的使用也沒有什麽實際意義，比較容易遺忘，因此，這裏只簡單的列出常用的一些函數，只需要對其有個印象即可，使用的時候再去 查手冊 效果會更好一些吧。
數學函數

atan2(y, x)
cos(expr)
exp(expr)
int(expr)
log(expr)
rand
sin(expr)
sqrt(expr)
srand([expr])

字符串函數

asort(arr [, d [, how] ])
asorti(arr [, d [, how] ])
gsub(regex, sub, string)
index(str, sub)
length(str)
match(str, regex)
split(str, arr, regex)
sprintf(format, expr-list)
strtonum(str)
sub(regex, sub, string)
substr(str, start, l)
tolower(str)
toupper(str)

時間函數

systime
mktime(datespec)
strftime([format [, timestamp[, utc-flag]]])

字節操作函數

and
compl
lshift
rshift
or
xor

其它

close(expr) 關閉管道文件請看下面這段代碼

$ 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]"是我們在AWK中要用來建立雙向連接的命令。
第二個語句print提供了tr命令的輸入，使用 &| 表名建立雙向連接。
第三個語句close(cmd, "to")用於執行完成後關閉to進程
第四個語句cmd |& getline out使用getline函數存儲輸出到out變量
接下來打印變量out的內容，然後關閉cmd
delete 用於刪除數組元素
exit 退出腳本執行，並返回狀態碼參數
fflush
getline 該命令讓awk讀取下一行內容該命令讓awk讀取下一行內容，比如

$ awk ‘{getline; print $0}‘ marks.txt
2) Rahul Maths 90
4) Kedar English 85
5) Hari History 89

使用getline var 可以從file中讀取輸入，存儲到變量var中


{
if (NF == 2 && $1 == "@include") {
while ((getline line 0)
print line
# 這裏的close確保如果文件中兩個@include，可以讓其讀取兩次
close($2)
} else
print
}

命令的輸出也可以通過管道輸入到getline，使用command | getline這種方式。在這種情況下，字符串命令會作為shell命令執行，其標準輸出會通過管道傳遞個awk作為其輸入，這種形式的getline會從管道中一次讀取一條記錄。例如下面的命令會從輸入中逐行讀取，如果遇到@execute，則將該行作為命令執行，將命令的輸出作為最終的輸出內容

{
if ($1 == "@execute") {
tmp = substr($0, 10) # Remove "@execute"
while ((tmp | getline) > 0)
# 這裏實際上設置了$0為這一行的內容
print
close(tmp)
} else
print
}

如果文件包含以下內容
foo
bar
baz
@execute who
bletch

則會輸出

foo
bar
baz
arnold ttyv0 Jul 13 14:22
miriam ttyp0 Jul 13 14:23 (murphy:0)
bill ttyp1 Jul 13 14:23 (murphy:0)
bletch

使用command | getline var可以實現將命令的輸出寫入到變量var。

BEGIN {
"date" | getline current_time
close("date")
print "Report printed on " current_time
}

getline使用管道讀取輸入是一種單向的操作，在某些場景下，你可能希望發送數據到另一個進程，然後從這個進程中讀取處理後的結果， 這就用到了協同進程，我們可以使用|&打開一個雙向管道。
print "some query" |& "db_server"
"db_server" |& getline

同樣，我們也可以使用command |& getline var將協同進程的輸出寫入到變量var。
next
nextfile
return用於用戶自定義函數的返回值。
首先，創建一個functions.awk文件，包含下面的awk命令

function addition(num1, num2) {
result = num1 + num2
return result
}
BEGIN {
res = addition(10, 20)
print "10 + 20 = " res
}

執行上述代碼，輸出
10 + 20 = 30
1

10 + 20 = 30
system該函數用於執行指定的命令並且返回它的退出狀態，返回狀態碼0表示命令成功執行。
$ awk ‘BEGIN { ret = system("date"); print "Return value = " ret }‘
2016年 10月 27日 星期四 22:08:36 CST
Return value = 0

用戶自定義函數

函數是程序基本的組成部分，AWK允許我們自己創建自定義的函數。一個大型的程序可以被劃分為多個函數，每個函數之間可以獨立的開發和測試，提供可重用的代碼。

下面是用戶自定義函數的基本語法
function function_name(argument1, argument2, ...) {
function body
}


例如，我們創建一個名為functions.awk的文件，包含下面的代碼

# Returns minimum number
function find_min(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)
}

執行上述代碼，會得到下面的輸出
Minimum = 10
Maximum = 20

輸出重定向
重定向操作符

到目前為止，我們所有的程序都是直接顯示數據到了標準輸出流，其實，我們也可以將輸出重定向到文件。重定向操作符跟在print和printf函數的後面，與shell中的用法基本一致。

print DATA > output-file
print DATA >> output-file

例如，下面兩條命令輸出是一致的

$ echo "Hello, World !!!" > /tmp/message.txt
$ awk ‘BEGIN { print "Hello, World !!!" > "/tmp/message.txt" }‘

與shell中一樣，>用於將輸出寫入到指定的文件中，如果文件中有內容則覆蓋，而>>則為追加模式寫入。

$ awk ‘BEGIN { print "Hello, World !!!" >> "/tmp/message.txt" }‘
$ cat /tmp/message.txt

管道

除了將輸出重定向到文件之外，我們還可以將輸出重定向到其它程序，與shell中一樣，我們可以使用管道操作符|。
$ awk ‘BEGIN { print "hello, world !!!" | "tr [a-z] [A-Z]" }‘
HELLO, WORLD !!!

AWK中可以使用|&進行雙向連接，那麽什麽是雙向連接呢？一種常見的場景是我們發送數據到另一個程序處理，然後讀取處理結果，這種場景下就需要打開一個到另外一個進程的雙向管道了。第二個進程會與gawk程序並行執行，這裏稱其為 協作進程。與單向連接使用|操作符不同的是，雙向連接使用|&操作符。

do {
print data |& "subprogram"
"subprogram" |& getline results
} while (data left to process)
close("subprogram")

第一次I/O操作使用了|&操作符，gawk會創建一個到運行其它程序的子進程的雙向管道，print的輸出被寫入到了subprogram的標準輸入，而這個subprogram的標準輸出在gawk中使用getline函數進行讀取。

註意：目前協同進程的標準錯誤輸出將會和gawk的標準錯誤輸出混雜在一起，無法單獨獲取標準錯誤輸出。另外，I/O緩沖可能存在問題，gawk程序會自動的刷新所有輸出到下遊的協同進程的管道。但是，如果協同進程沒有刷新其標準輸出的話，gawk將可能會在使用getline函數從協同進程讀取輸出的時候掛起，這就可能引起死鎖。

我們可以使用close函數關閉雙向管道的to或者from一端，這兩個字符串值告訴gawk發送數據到協同進程完成時或者從協同進程讀取完畢時關閉管道。在使用系統命令sort的時候是這樣做是非常必要的，因為它必須等所有輸出都讀取完畢時才能進行排序。

BEGIN {
command = "LC_ALL=C sort"
n = split("abcdefghijklmnopqrstuvwxyz", a, "")

for (i = n; i > 0; i--)
print a[i] |& command
close(command, "to")

while ((command |& getline line) > 0)
print "got", line
close(command)
}

例如，下面的例子中使用tr命令轉換小寫為大寫。我們的command.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]” 是在AWK中要建立雙向連接的命令
第二行的print命令用於為tr命令提供輸入，而 |& 用於指出要建立雙向連接
第三行用於在上面的語句close(cmd, “to”),在執行完成後關閉其to進程
第四行 cmd |& getline out使用getline函數存儲輸出到變量out中
最後一行使用close函數關閉命令

美化輸出

到目前為止，我們已經使用過print和printf函數顯示數據到標準輸出，但是printf函數實際上要比我們之前使用的情況更加強大得多。該函數是從C語言中借鑒來的，在處理格式化的輸出時非常有用。

$ awk ‘BEGIN { printf "Hello\nWorld\n" }‘
Hello
World
$ awk ‘BEGIN { printf "ASCII value 65 = character %c\n", 65 }‘
ASCII value 65 = character A

格式化輸出標識有 %c， %d，%s 等，基本與C語言一致，這裏就不多贅述了。

執行shell命令

在AWK中執行shell命令有兩種方式

使用system函數
使用管道

使用system函數

system函數用於執行操作系統命令並且返回命令的退出碼到awk。

END {
system("date | mail -s ‘awk run done‘ root")
}

使用管道

如果要執行的命令很多，可以將輸出的命令直接用管道傳遞給“/bin/sh”執行

while (more stuff to do)
print command | "/bin/sh"
close("/bin/sh")

AWK 快速入門