mawk - Online sa Cloud

PROGRAMA:

NAME

mawk - pattern scanning at text processing language

SINOPSIS

mawk [-W opsyon] [-F halaga] [-v var=halaga] [--] 'text ng programa' [file ...]
mawk [-W opsyon] [-F halaga] [-v var=halaga] [-f program-file] [--] [file ...]

DESCRIPTION

mawk ay isang interpreter para sa AWK Programming Language. Ang wikang AWK ay kapaki-pakinabang para sa
pagmamanipula ng mga file ng data, pagkuha at pagproseso ng teksto, at para sa prototyping at
eksperimento sa mga algorithm. mawk ay isang bago ang awkward ibig sabihin ay ipinapatupad nito ang wikang AWK
gaya ng tinukoy sa Aho, Kernighan at Weinberger, Ang AWK Programming Wika, Addison-Wesley
Publishing, 1988. (Pagkatapos ay tinukoy bilang AWK book.) mawk umaayon sa Posix
1003.2 (draft 11.3) kahulugan ng wikang AWK na naglalaman ng ilang mga tampok na hindi
inilarawan sa aklat ng AWK, at mawk nagbibigay ng maliit na bilang ng mga extension.

Ang isang AWK program ay isang sequence ng huwaran {aksyon} mga pares at mga kahulugan ng function. Maikli
Ang mga programa ay ipinasok sa command line na karaniwang nakapaloob sa ' ' upang maiwasan ang shell
interpretasyon. Maaaring basahin ang mga mas mahabang programa mula sa isang file na may opsyong -f. Data
Ang input ay binabasa mula sa listahan ng mga file sa command line o mula sa karaniwang input kapag ang
walang laman ang listahan. Ang input ay nahahati sa mga talaan ayon sa tinutukoy ng record separator
variable, RS. Sa una, RS = "\n" at ang mga tala ay kasingkahulugan ng mga linya. Ang bawat tala ay
kumpara sa bawat isa huwaran at kung tumugma ito, ang teksto ng programa para sa {aksyon} is
pinatay.

Opsyon

-F halaga nagtatakda ng field separator, FS, Upang halaga.

-f file Ang teksto ng programa ay binasa mula sa file sa halip na mula sa command line. Maramihan
-f pinapayagan ang mga pagpipilian.

-v var=halaga nagtatalaga halaga sa variable ng programa ay.

-- ay nagpapahiwatig ng hindi malabo na dulo ng mga opsyon.

Ang mga opsyon sa itaas ay magiging available sa anumang Posix compatible na pagpapatupad ng AWK, at
ang mga partikular na opsyon sa pagpapatupad ay nauna sa -W. mawk nagbibigay ng anim:

-W bersyon mawk isinusulat ang bersyon at copyright nito sa stdout at pinagsama-samang mga limitasyon sa
stderr at lumabas sa 0.

-W nagsusulat ang dump ng isang assembler tulad ng listahan ng panloob na representasyon ng
programa sa stdout at lumabas sa 0 (sa matagumpay na compilation).

-W interactive na nagtatakda ng mga unbuffered writes sa stdout at line buffered reads mula sa stdin.
Ang mga rekord mula sa stdin ay mga linya anuman ang halaga ng RS.

-W exec file Ang teksto ng programa ay binasa mula sa file at ito ang huling pagpipilian. Kapaki-pakinabang sa
mga sistemang sumusuporta sa #! "magic number" convention para sa executable
script.

-W sprintf=num inaayos ang laki ng kay mawk panloob na sprintf buffer sa num byte. Higit sa
ipinahihiwatig ng bihirang paggamit ng opsyong ito mawk dapat i-recompile.

-W mga puwersa ng posix_space mawk hindi upang isaalang-alang ang '\n' bilang espasyo.

Ang mga maikling porma -W[vdiesp] ay kinikilala at sa ilang mga sistema -We ay sapilitan na iwasan
mga limitasyon sa haba ng command line.

ANG AWK ANG WIKA

1. Programa kaayusan
Ang isang AWK program ay isang sequence ng huwaran {aksyon} mga pares at mga kahulugan ng function ng user.

Ang isang pattern ay maaaring:
BEGIN
END
pagpapahayag
pagpapahayag, pagpapahayag

Isa, ngunit hindi pareho, ng huwaran {aksyon} maaaring tanggalin. Kung {aksyon} ay tinanggal ito ay
implicitly { print }. Kung huwaran ay tinanggal, pagkatapos ito ay implicitly na tumugma. BEGIN at
END ang mga pattern ay nangangailangan ng isang aksyon.

Ang mga pahayag ay winakasan ng mga bagong linya, semi-colon o pareho. Mga pangkat ng mga pahayag tulad ng
ang mga aksyon o mga loop na katawan ay hinarangan sa pamamagitan ng { ... } tulad ng sa C. Ang huling pahayag sa isang bloke
hindi kailangan ng terminator. Walang kahulugan ang mga blangkong linya; winakasan ang walang laman na pahayag
na may semi-colon. Maaaring ipagpatuloy ang mahahabang pahayag gamit ang backslash, \. Ang isang pahayag ay maaari
masira nang walang backslash pagkatapos ng kuwit, kaliwang brace, &&, ||, do, iba, ang tama
panaklong ng isang if, habang or para pahayag, at ang tamang panaklong ng isang function
kahulugan. Ang isang komento ay nagsisimula sa # at umaabot hanggang, ngunit hindi kasama ang dulo ng linya.

Kinokontrol ng mga sumusunod na pahayag ang daloy ng programa sa loob ng mga bloke.

if ( ipahayag ) pahayag

if ( ipahayag ) pahayag iba pahayag

habang ( ipahayag ) pahayag

do pahayag habang ( ipahayag )

para ( opt_expr ; opt_expr ; opt_expr ) pahayag

para ( ay in ayos ) pahayag

magpatuloy

masira

2. data uri, Conversion at paghahambing
Mayroong dalawang pangunahing uri ng data, numeric at string. Ang mga numeric constant ay maaaring maging integer
-2, decimal tulad ng 1.08, o sa scientific notation tulad ng -1.1e4 o .28E-3. Ang lahat ng mga numero ay
kinakatawan sa loob at lahat ng pagkalkula ay ginagawa sa floating point arithmetic. Kaya para sa
halimbawa, ang expression na 0.2e2 == 20 ay totoo at totoo ay kinakatawan bilang 1.0.

Ang mga string constant ay nakapaloob sa double quotes.

"Ito ay isang string na may bagong linya sa dulo.\n"

Maaaring ipagpatuloy ang mga string sa isang linya sa pamamagitan ng pagtakas (\) sa bagong linya. Ang sumusunod na pagtakas
kinikilala ang mga pagkakasunud-sunod.

\\ \
\" "
\a alerto, ascii 7
\b backspace, ascii 8
\t tab, ascii 9
\n bagong linya, ascii 10
\v patayong tab, ascii 11
\f formfeed, ascii 12
\r pagbabalik ng karwahe, ascii 13
\ddd 1, 2 o 3 octal digit para sa ascii ddd
\xhh 1 o 2 hex na digit para sa ascii hh

Kung tatakasan mo ang anumang ibang karakter \c, makakakuha ka ng \c, ibig sabihin, mawk hindi pinapansin ang pagtakas.

Mayroon talagang tatlong pangunahing uri ng data; ang pangatlo ay numero at pisi na may parehong a
numeric value at isang string value sa parehong oras. Papasok ang mga variable na tinukoy ng user
pag-iral noong unang isinangguni at nasimulan sa walang halaga, isang numero at halaga ng string
na may numerong halaga 0 at string na halaga "". Non-trivial number at string typed data
nagmula sa input at karaniwang naka-imbak sa mga field. (Tingnan ang seksyon 4).

Ang uri ng isang expression ay tinutukoy ng konteksto nito at awtomatikong uri ng conversion
nangyayari kung kinakailangan. Halimbawa, upang suriin ang mga pahayag

y = x + 2 ; z = x "hello"

Ang halaga na nakaimbak sa variable na y ay ita-type ng numeric. Kung ang x ay hindi numeric, ang halaga ay nabasa
mula sa x ay na-convert sa numeric bago ito idagdag sa 2 at naka-imbak sa y. Ang halaga na nakaimbak
sa variable z ay ita-type ng string, at ang halaga ng x ay mako-convert sa string kung
kailangan at pinagdugtong ng "hello". (Siyempre, ang halaga at uri na nakaimbak sa x ay
hindi binago ng anumang mga conversion.) Ang isang string expression ay na-convert sa numeric gamit nito
pinakamahabang numeric prefix tulad ng sa atof(3). Ang isang numeric na expression ay na-convert sa string sa pamamagitan ng
pagpapalit ipahayag sa sprintf(CONVFMT, ipahayag), maliban kung ipahayag maaaring katawanin sa host
machine bilang isang eksaktong integer pagkatapos ito ay na-convert sa sprint("%d", ipahayag). Sprintf() ay isang
AWK built-in na duplicate ang functionality ng sprint(3), at CONVFMT ay isang built-in
variable na ginagamit para sa panloob na conversion mula sa numero patungo sa string at nasimulan sa "%.6g".
Maaaring pilitin ang mga tahasang uri ng conversion, ipahayag "" ay string at ipahayagAng +0 ay numero.

Upang suriin, ipahayag1 rel-op ipahayag2, kung ang parehong mga operand ay numeric o numero at string pagkatapos
ang paghahambing ay numero; kung ang parehong operand ay string ang paghahambing ay string; kung isa
Ang operand ay string, ang non-string operand ay na-convert at ang paghahambing ay string. Ang
Ang resulta ay numeric, 1 o 0.

Sa boolean na konteksto gaya ng, if ( ipahayag ) pahayag, ang isang string na expression ay sinusuri ang totoo kung
at kung ito ay hindi ang walang laman na string na ""; mga numerong halaga kung at kung hindi lamang ayon sa numero
zero.

3. regular mga expression
Sa wikang AWK, ang mga talaan, mga patlang at mga string ay kadalasang sinusuri para sa pagtutugma ng a regular
pagpapahayag. Ang mga regular na expression ay nakapaloob sa mga slash, at

ipahayag ~/r/

ay isang AWK expression na nagsusuri sa 1 kung ipahayag "mga tugma" r, na nangangahulugang isang substring ng
ipahayag ay nasa hanay ng mga string na tinukoy ng r. Nang walang tugma ang expression ay sinusuri sa 0;
pinapalitan ang ~ ng operator na "not match", !~ , binabaligtad ang kahulugan. Bilang pattern-action
pares,

/r/ { aksyon } at $0 ~/r/ { aksyon }

ay pareho, at para sa bawat input record na tumutugma r, aksyon ay pinaandar. Sa katunayan, /r/
ay isang AWK expression na katumbas ng ($0 ~/r/) kahit saan maliban kung nasa kanan
gilid ng isang operator ng tugma o ipinasa bilang argumento sa isang built-in na function na umaasa sa a
argumento ng regular na expression.

Gumagamit ang AWK ng mga pinahabang regular na expression tulad ng sa egrep(1). Ang regular na expression
metacharacter, ibig sabihin, ang mga may espesyal na kahulugan sa mga regular na expression ay

^ $ . [ ] | ( ) * + ?

Ang mga regular na expression ay binuo mula sa mga character tulad ng sumusunod:

c tumutugma sa anumang hindi metacharacter c.

\c tumutugma sa isang character na tinukoy ng parehong mga pagkakasunud-sunod ng pagtakas na ginamit sa
string constants o ang literal na karakter c kung \c ay hindi isang pagtakas
pagkakasunod-sunod.

. tumutugma sa anumang karakter (kabilang ang bagong linya).

^ tumutugma sa harap ng isang string.

$ tumutugma sa likod ng isang string.

Ang [c1c2c3...] ay tumutugma sa anumang karakter sa klase na c1c2c3... . Isang pagitan ng
ang mga character ay tinutukoy ng c1-c2 sa loob ng isang klase [...].

Ang [^c1c2c3...] ay tumutugma sa anumang karakter na wala sa klase na c1c2c3...

Ang mga regular na expression ay binuo mula sa iba pang mga regular na expression tulad ng sumusunod:

r1rMga 2 na tugma r1 sinundan agad ng r2 (concatenation).

r1 | rMga 2 na tugma r1 o r2 (paghahalili).

r* mga tugma r paulit-ulit na zero o higit pang beses.

r+ mga tugma r inulit ng isa o higit pang beses.

r? mga posporo r zero o isang beses.

(r) mga tugma r, pagbibigay ng pagpapangkat.

Ang pagtaas ng precedence ng mga operator ay alternation, concatenation at unary (*, + o
?).

Halimbawa,

/^[_a-zA-Z][_a-zA-Z0-9]*$/ at
/^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/

ay tinutugma ng mga AWK identifier at AWK numeric constants ayon sa pagkakabanggit. Tandaan na . kailangan
ay makatakas upang makilala bilang isang decimal point, at ang mga metacharacter ay hindi espesyal
sa loob ng mga klase ng karakter.

Ang anumang expression ay maaaring gamitin sa kanang bahagi ng ~ o !~ operator o ipasa sa a
built-in na umaasa ng isang regular na expression. Kung kinakailangan, ito ay na-convert sa string, at
pagkatapos ay binibigyang kahulugan bilang isang regular na pagpapahayag. Halimbawa,

BEGIN { identifier = "[_a-zA-Z][_a-zA-Z0-9]*" }

$0 ~ "^" identifier

nagpi-print ng lahat ng linya na nagsisimula sa isang AWK identifier.

mawk kinikilala ang walang laman na regular na expression, //, na tumutugma sa walang laman na string at samakatuwid
ay tinutugma ng anumang string sa harap, likod at sa pagitan ng bawat karakter. Halimbawa,

echo abc | mawk { gsub(//, "X") ); print }
XaXbXcX

4. Records at patlang
Ang mga tala ay binabasa nang paisa-isa, at iniimbak sa parang nagbabago $0. Ang tala ay
hatiin sa patlang na nakaimbak sa $1, $2, ..., $NF. Ang built-in na variable NF ay naka-set
sa bilang ng mga patlang, at NR at FNR ay dinaragdagan ng 1. Mga field sa itaas $NF ay nakatakda sa
"".

Takdang-aralin sa $0 nagiging sanhi ng mga patlang at NF na muling kalkulahin. Takdang-aralin sa NF o sa a
mga sanhi ng larangan $0 to be reconstructed by concatenating the $i's pinaghiwalay ng FSO.
Pagtatalaga sa isang field na may index na mas malaki kaysa NF, nadadagdagan NF at sanhi $0 upang maging
itinayong muli.

Ang input ng data na nakaimbak sa mga field ay string, maliban kung ang buong field ay may numeric form at pagkatapos
ang uri ay numero at string. Halimbawa,

echo 24 24E |
mawk '{ print($1>100, $1>"100", $2>100, $2>"100") }'
0 1 1 1

$0 at $2 ay string at $1 ay numero at string. Ang unang paghahambing ay numeric, ang
pangalawa ay string, ang pangatlo ay string (100 ay na-convert sa "100"), at ang huli ay string.

5. expression at operator
Ang expression syntax ay katulad ng C. Pangunahing mga expression ay mga numeric constants, string
mga constant, variable, field, array at function na tawag. Ang identifier para sa isang variable,
array o function ay maaaring isang sequence ng mga titik, digit at underscore, na hindi
magsimula sa isang digit. Ang mga variable ay hindi idineklara; umiiral ang mga ito noong unang isinangguni at ngayon
pinasimulan sa walang halaga.

Ang mga bagong expression ay binubuo ng mga sumusunod na operator sa pagkakasunud-sunod ng pagtaas
karapatan sa pangunguna.

trabaho = += -= *= /= %= ^=
kondisyonal ? :
lohiko or ||
lohiko at &&
ayos pagiging kasapi in
pagtutugma ~!~
pamanggit < > <= >= == !=
pagsasama-sama (walang tahasang operator)
idagdag ops + -
Mul ops * /%
hindi nag-iingat + -
lohiko hindi !
pagpaparami ^
Inc at Disyembre ++ -- (parehong post at pre)
parang $

Ang pagtatalaga, kondisyon at exponentiation ay nag-uugnay sa kanan sa kaliwa; ang iba pang mga operator
iugnay kaliwa pakanan. Anumang expression ay maaaring maging panaklong.

6. Mga Arrays
Nagbibigay ang Awk ng mga one-dimensional na array. Ang mga elemento ng array ay ipinahayag bilang ayos[ipahayag]. Expr
ay panloob na na-convert sa uri ng string, kaya, halimbawa, A[1] at A["1"] ay pareho
elemento at ang aktwal na index ay "1". Ang mga array na na-index ng mga string ay tinatawag na associative
mga array. Sa una ang isang array ay walang laman; umiiral ang mga elemento noong unang na-access. Isang ekspresyon,
ipahayag in ayos sinusuri sa 1 kung ayos[ipahayag] ay umiiral, kung hindi sa 0.

Mayroong isang anyo ng para pahayag na umiikot sa bawat index ng isang array.

para ( ay in ayos ) pahayag

set ay sa bawat index ng ayos at nagpapatupad pahayag. Ang utos na ay nakahalang
ang mga indeks ng ayos hindi nakalagay.

Ang pahayag, alisin ayos[ipahayag], sanhi ayos[ipahayag] hindi umiral. mawk sumusuporta sa isang
extension, alisin ayos, na nagtatanggal ng lahat ng elemento ng ayos.

Ang mga multidimensional na array ay na-synthesize sa concatenation gamit ang built-in na variable
SUBSEP. ayos[ipahayag1,ipahayag2] ay katumbas ng ayos[ipahayag1 SUBSEP ipahayag2]. Pagsubok para sa a
multidimensional na elemento ay gumagamit ng isang panaklong index, tulad ng

kung ( (i, j) sa A ) i-print ang A[i, j]

7. Mga built-in na variable
Ang mga sumusunod na variable ay built-in at sinimulan bago ang pagpapatupad ng programa.

ARGC bilang ng mga argumento ng command line.

ARGV hanay ng mga argumento ng command line, 0..ARGC-1.

CONVFMT format para sa panloob na conversion ng mga numero sa string, sa simula = "%.6g".

KAPALIGIRAN array na na-index ng mga variable ng kapaligiran. Isang string ng kapaligiran, var=halaga
ay nakaimbak bilang KAPALIGIRAN[ay] = halaga.

FILENAME pangalan ng kasalukuyang input file.

FNR kasalukuyang record number sa FILENAME.

FS hinahati ang mga tala sa mga field bilang isang regular na expression.

NF bilang ng mga patlang sa kasalukuyang talaan.

NR kasalukuyang record number sa kabuuang input stream.

OFMT format para sa pag-print ng mga numero; una = "%.6g".

FSO ipinasok sa pagitan ng mga patlang sa output, sa simula = " ".

ORS tinatapos ang bawat tala sa output, sa simula = "\n".

RLENGTH haba na itinakda ng huling tawag sa built-in na function, tugma().

RS input record separator, sa simula = "\n".

Magsimula index na itinakda ng huling tawag sa tugma().

SUBSEP ginamit upang bumuo ng maraming mga subscript ng array, sa simula = "\034".

8. Built-in function
Mga function ng string

gsub(r,s,t) gsub(r,s)
Global substitution, bawat tugma ng regular na expression r sa variable t is
pinalitan ng string s. Ang bilang ng mga kapalit ay ibinalik. Kung t is
tinanggal, $0 Ginagamit. Isang & sa kapalit na string s ay pinalitan ng
katugmang substring ng t. \& at \\ ilagay ang literal na & at \, ayon sa pagkakabanggit, sa
ang kapalit na string.

index (s,t)
If t ay isang substring ng s, pagkatapos ay ang posisyon kung saan t ang simula ay ibinalik, kung hindi
0 ay ibinalik. Ang unang karakter ng s ay nasa posisyon 1.

haba(s)
Ibinabalik ang haba ng string s.

tugma(s,r)
Ibinabalik ang index ng unang pinakamahabang tugma ng regular na expression r in
pisi s. Nagbabalik ng 0 kung walang tugma. Bilang side effect, Magsimula ay nakatakda sa
ibalik ang halaga. RLENGTH ay nakatakda sa haba ng tugma o -1 kung walang tugma.
Kung ang walang laman na string ay tumugma, RLENGTH ay nakatakda sa 0, at 1 ay ibinalik kung
ang laban ay nasa harap, at ang haba(s) +1 ay ibinalik kung ang laban ay sa
ang likod.

hati(s,A,r) hati(s,A)
Pisi s ay nahahati sa mga field sa pamamagitan ng regular na expression r at ang mga patlang ay
na-load sa array A. Ang bilang ng mga patlang ay ibinalik. Tingnan ang seksyon 11
sa ibaba para sa karagdagang detalye. Kung r ay tinanggal, FS Ginagamit.

sprintf (format, expr-list)
Nagbabalik ng string na binuo mula sa expr-list ayon sa format. Tingnan ang
paglalarawan ng printf() sa ibaba.

sub(r,s,t) sub(r,s)
Isang pagpapalit, katulad ng gsub() maliban sa karamihan ng isang pagpapalit.

substr(s,i,n) substr(s,i)
Ibinabalik ang substring ng string s, simula sa index i, ng haba n. Kung n
ay inalis, ang panlapi ng s, Nagsisimula sa i ay ibinalik.

babaan(s)
Nagbabalik ng kopya ng s na ang lahat ng upper case na character ay na-convert sa lower case.

topper(s)
Nagbabalik ng kopya ng s na ang lahat ng maliliit na character ay na-convert sa malalaking titik.

Mga function ng aritmetika

atan2(y,x) Arctan ng y/x sa pagitan ng -pi at pi.

cos (x) Cosine function, x sa radians.

exp(x) Exponential function.

int(x) Nagbabalik x pinutol patungo sa zero.

log(x) Natural na logarithm.

rand() Nagbabalik ng random na numero sa pagitan ng zero at isa.

kasalanan (x) Pag-andar ng sine, x sa radians.

sqrt(x) Nagbabalik ng square root ng x.

srand(ipahayag) srand()
Binhi ang random number generator, gamit ang orasan kung ipahayag ay tinanggal, at
ibinabalik ang halaga ng nakaraang binhi. mawk buto ang random na numero
generator mula sa orasan sa startup kaya hindi na kailangang tumawag
srand(). Srand(ipahayag) ay kapaki-pakinabang para sa pag-uulit ng pseudo random sequence.

9. input at output
Mayroong dalawang output statement, i-print at printf.

nagsusulat ng print $0 ORS sa karaniwang output.

i-print ipahayag1, ipahayag2, ..., ipahayagn
nagsusulat ipahayag1 FSO ipahayag2 FSO ... ipahayagn ORS sa karaniwang output. Numeric
ang mga expression ay na-convert sa string na may OFMT.

printf format, expr-list
kino-duplicate ang pagsusulat ng printf C library function sa karaniwang output. Ang
ang kumpletong mga detalye ng format ng ANSI C ay kinikilala sa mga conversion %c,
%d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X at %%, at conversion
mga kwalipikasyon h at l.

Ang listahan ng argumento na ipi-print o printf ay maaaring opsyonal na ilakip sa mga panaklong. Print
nag-format ng mga numero gamit ang OFMT o "%d" para sa mga eksaktong integer. "%c" na may isang numeric na argumento
nagpi-print ng kaukulang 8 bit na character, na may string argument na nagpi-print ng una
katangian ng string. Ang output ng print at printf ay maaaring i-redirect sa isang file o
utos sa pamamagitan ng pagdaragdag > file, >> file o | utos hanggang sa dulo ng print statement.
Magbubukas ang pag-redirect file or utos isang beses lang, ang mga kasunod na pag-redirect ay idinagdag sa na
bukas na stream. Sa pamamagitan ng kumbensyon, mawk iniuugnay ang filename "/dev/stderr" kay stderr which
nagbibigay-daan sa pag-print at printf na mai-redirect sa stderr. mawk iniuugnay din ang "-" at
"/dev/stdout" na may stdin at stdout na nagpapahintulot sa mga stream na ito na maipasa sa mga function.

Ang input function getline ay may mga sumusunod na pagkakaiba-iba.

getline
nagbabasa sa $0, ina-update ang mga field, NF, NR at FNR.

getline file
nagbabasa sa $0 mula file, ina-update ang mga field at NF.

getline ay
binabasa ang susunod na tala sa ay, mga update NR at FNR.

getline ay < file
binabasa ang susunod na talaan ng file sa ay.

utos | getline
pipe ng isang talaan mula sa utos sa $0 at ina-update ang mga patlang at NF.

utos | getline ay
pipe ng isang talaan mula sa utos sa ay.

Nagbabalik ang Getline ng 0 sa end-of-file, -1 sa error, kung hindi man 1.

Ang mga utos sa dulo ng mga tubo ay isinasagawa ng /bin/sh.

Ang function na malapit(ipahayag) isinasara ang file o pipe na nauugnay sa ipahayag. Isara ay nagbabalik ng 0 kung
ipahayag ay isang bukas na file, ang exit status kung ipahayag ay isang piped command, at -1 kung hindi man. Isara
ay ginagamit upang muling basahin ang isang file o command, siguraduhin na ang kabilang dulo ng isang output pipe ay tapos na
o makatipid ng mga mapagkukunan ng file.

Ang function na flush(ipahayag) pinapa-flush ang output file o pipe na nauugnay sa ipahayag. Pag-flush
nagbabalik ng 0 kung ipahayag ay isang bukas na stream ng output na iba pa -1. Nag-flush nang walang argumento
stdout. Ang Fflush na may walang laman na argumento ("") ay nag-flush sa lahat ng bukas na output.

Ang function na sistema(ipahayag) gamit / Bin / SH upang maipatupad ipahayag at ibinabalik ang exit status ng
utos ipahayag. Mga pagbabagong ginawa sa KAPALIGIRAN array ay hindi ipinasa sa mga utos na pinaandar gamit ang
sistema o mga tubo.

10. gumagamit tinukoy function
Ang syntax para sa function na tinukoy ng gumagamit ay

tungkulin pangalan( mga pagtatalo ) { pahayag }

Ang function body ay maaaring maglaman ng return statement

pagbabalik opt_expr

Hindi kailangan ng return statement. Maaaring nested o recursive ang mga function call. Mga pag-andar
ay ipinasa ang mga expression sa pamamagitan ng halaga at arrays sa pamamagitan ng reference. Ang mga karagdagang argumento ay nagsisilbing lokal
mga variable at sinisimulan sa walang halaga. Halimbawa, csplit(s,A) inilalagay ang bawat karakter ng s
sa array A at ibinabalik ang haba ng s.

function na csplit(s, A, n, i)
{
n = (mga) haba
para sa( i = 1 ; i <= n ; i++ ) A[i] = substr(s, i, 1)
ibalik n
}

Ang paglalagay ng dagdag na espasyo sa pagitan ng mga naipasa na argumento at mga lokal na variable ay karaniwan.
Maaaring i-reference ang mga function bago ang mga ito ay tukuyin, ngunit ang pangalan ng function at ang '(' ng
ang mga argumento ay dapat hawakan upang maiwasan ang pagkalito sa pagkakaugnay.

11. Paghahati mga string, mga tala at file
Ginagamit ng mga Awk program ang parehong algorithm upang hatiin ang mga string sa mga array na may split(), at mga tala
sa mga patlang sa FS. mawk gumagamit talaga ng parehong algorithm upang hatiin ang mga file sa mga talaan
on RS.

hati(expr,A,sep) ay gumagana tulad ng sumusunod:

(1) Kung Septiyembre ay tinanggal, ito ay pinalitan ng FS. Septiyembre maaaring isang ekspresyon o
regular na pagpapahayag. Kung ito ay isang expression ng non-string na uri, ito ay
na-convert sa string.

(2) Kung Septiyembre = " " (isang puwang), pagkatapos ay pinutol mula sa harap at
likod ng ipahayag, at Septiyembre nagiging . mawk tumutukoy bilang regular
expression /[ \t\n]+/. Kung hindi man Septiyembre ay itinuturing bilang isang regular na expression,
maliban na ang mga meta-character ay binabalewala para sa isang string ng haba 1, hal,
split(x, A, "*") at split(x, A, /\*/) ay pareho.

(3) Kung ipahayag ay hindi string, ito ay na-convert sa string. Kung ipahayag ay pagkatapos ay ang walang laman
string "", split() ay nagbabalik ng 0 at A ay nakatakdang walang laman. Kung hindi, lahat ng hindi-
overlapping, non-null at pinakamahabang tugma ng Septiyembre in ipahayag, magkahiwalay ipahayag sa
mga field na na-load sa A. Ang mga patlang ay inilalagay sa A[1], A[2], ...,
Ang A[n] at split() ay nagbabalik ng n, ang bilang ng mga field na bilang ng
tugma plus one. Nakalagay ang data A na mukhang numeric ay nai-type na numero at
string.

Gumagana ang paghahati ng mga tala sa mga field maliban kung ang mga piraso ay na-load sa $1, $2,...,
$NF. Kung $0 ay walang laman, NF ay nakatakda sa 0 at lahat $i sa "".

mawk hinahati ang mga file sa mga tala sa pamamagitan ng parehong algorithm, ngunit may kaunting pagkakaiba iyon
RS ay talagang isang terminator sa halip na isang separator. (ORS ay talagang isang terminator din).

Hal, kung FS = ":+" at $0 = "a::b:" , pagkatapos NF = 3 at $1 = "a", $2 = "b" at $3 =
"", ngunit kung ang "a::b:" ay ang mga nilalaman ng isang input file at RS = ":+", pagkatapos ay mayroon
dalawang talaan "a" at "b".

RS = " " ay hindi espesyal.

If FS = "", pagkatapos mawk hinahati ang rekord sa mga indibidwal na character, at, gayundin,
hati(s,A,Inilalagay ng "") ang mga indibidwal na character ng s sa A.

12. Multi-line mga tala
Dahil sa mawk nagpapakahulugan RS bilang isang regular na expression, ang mga multi-line na tala ay madali. Setting RS
= "\n\n+", ginagawang hiwalay ang isa o higit pang mga blangkong linya sa mga talaan. Kung FS = " " (ang default),
pagkatapos ay mga solong bagong linya, ayon sa mga patakaran para sa sa itaas, maging espasyo at ang mga solong bagong linya ay
mga separator ng field.

Halimbawa, kung ang isang file ay "ab\nc\n\n", RS = "\n\n+" at FS = " ", tapos meron
isang record na "ab\nc" na may tatlong field na "a", "b" at "c". Nagbabago FS = "\n", nagbibigay
dalawang patlang na "ab" at "c"; nagbabago FS = "", ay nagbibigay ng isang field na kapareho ng
record.

Kung gusto mong ituring na blangko ang mga linyang may mga puwang o tab, itakda RS = "\n([ \t]*\n)+".
Para sa compatibility sa ibang awks, setting RS = "" ay may parehong epekto na parang mga blangkong linya
ay tinanggal mula sa harap at likod ng mga file at pagkatapos ay tinutukoy ang mga talaan na parang RS =
"\n\n+". Kinakailangan ng Posix na ang "\n" ay palaging naghihiwalay ng mga talaan kapag RS = "" anuman ang
halaga ng FS. mawk ay hindi sumusuporta sa convention na ito, dahil ang pagtukoy sa "\n" bilang
ginagawa itong hindi kailangan.

Kadalasan kapag nagbago ka RS para sa mga talaan ng maraming linya, gugustuhin mo ring baguhin
ORS sa "\n\n" kaya ang record spacing ay napanatili sa output.

13. Programa pagpapatupad
Inilalarawan ng seksyong ito ang pagkakasunud-sunod ng pagpapatupad ng programa. Una ARGC ay nakatakda sa kabuuan
bilang ng mga argumento ng command line na ipinasa sa yugto ng pagpapatupad ng programa. ARGV[0] is
itakda ang pangalan ng AWK interpreter at ARGV[1] ... ARGV[ARGC-1] hawak ang natitira
mga argumento ng command line na hindi kasama sa mga opsyon at source ng program. Halimbawa sa

mawk -f prog v=1 A t=hello B

ARGC = 5 na may ARGV[0] = "mawk", ARGV[1] = "v=1", ARGV[2] = "A", ARGV[3] = "t=hello" at
ARGV[4] = "B".

Susunod, bawat isa BEGIN Ang block ay naisakatuparan sa pagkakasunud-sunod. Kung ang programa ay ganap na binubuo ng BEGIN
mga bloke, pagkatapos ay matatapos ang pagpapatupad, kung hindi, ang isang input stream ay mabubuksan at magpapatuloy ang pagpapatupad.
If ARGC katumbas ng 1, ang input stream ay nakatakda sa stdin, kung hindi ang mga argumento ng command line
ARGV[1] ... ARGV[ARGC-1] ay sinusuri para sa isang file argument.

Ang mga argumento ng command line ay nahahati sa tatlong set: mga argumento ng file, mga argumento ng pagtatalaga
at walang laman na mga string "". May form ang isang assignment ay=pisi. Kapag ang isang ARGV[i] ay sinusuri
bilang isang posibleng argumento ng file, kung ito ay walang laman ito ay nilaktawan; kung ito ay isang takdang-aralin
argumento, ang pagtatalaga sa ay nagaganap at i lumaktaw sa susunod na argumento; iba pa ARGV[i]
ay binuksan para sa input. Kung nabigo itong buksan, matatapos ang pagpapatupad sa exit code 2. Kung hindi
Ang argumento ng command line ay isang argumento ng file, pagkatapos ay ang input ay nagmumula sa stdin. Getline sa a BEGIN
magbubukas ng input ang aksyon. Ang "-" bilang isang argumento ng file ay nagsasaad ng stdin.

Kapag ang isang input stream ay bukas, ang bawat input record ay sinusubok laban sa bawat isa huwaran, at kung ito
mga tugma, ang nauugnay aksyon ay pinaandar. Ang isang pattern ng expression ay tumutugma kung ito ay
boolean true (tingnan ang dulo ng seksyon 2). A BEGIN tumutugma ang pattern bago magkaroon ng anumang input
nabasa, at isang END tumutugma sa pattern pagkatapos basahin ang lahat ng input. Isang pattern ng hanay,
ipahayag1,ipahayag2 , tumutugma sa bawat record sa pagitan ng tugma ng ipahayag1 at ang laban ipahayag2
inclusively.

Kapag naganap ang pagtatapos ng file sa input stream, ang natitirang mga argumento ng command line ay
napagmasdan para sa isang file argument, at kung mayroong isa ito ay binuksan, kung hindi ang END huwaran is
itinuturing na tugma at lahat END pagkilos ay pinaandar.

Sa halimbawa, ang pagtatalaga v=1 ay nagaganap pagkatapos ng BEGIN pagkilos ay pinaandar, at
ang data na inilagay sa v ay nai-type na numero at string. Binabasa ang input mula sa file A. Sa dulo
ng file A, t ay nakatakda sa string na "hello", at B ay binuksan para sa input. Sa dulo ng file B,
ang END pagkilos ay pinaandar.

Daloy ng programa sa huwaran {aksyon} antas ay maaaring baguhin sa

susunod
lumabas opt_expr

mga pahayag. A susunod Ang pahayag ay nagiging sanhi ng susunod na tala ng input na basahin at pagsubok ng pattern
upang simulan muli sa una huwaran {aksyon} pares sa programa. An lumabas mga sanhi ng pahayag
agarang pagpapatupad ng END mga aksyon o pagwawakas ng programa kung wala o kung ang
lumabas nangyayari sa isang END aksyon. Ang opt_expr nagtatakda ng exit value ng program maliban kung
na-override ng isang mamaya lumabas o kasunod na pagkakamali.

HALIMBAWA

1. tularan ang pusa.

{ print }

2. tularan ang wc.

{ chars += length($0) + 1 # magdagdag ng isa para sa \n
mga salita += NF
}

END{ print NR, words, chars }

3. bilangin ang bilang ng mga natatanging "totoong salita".

MAGSIMULA { FS = "[^A-Za-z]+" }

{ para sa(i = 1 ; i <= NF ; i++) salita[$i] = "" }

WAKAS { tanggalin ang salita[""]
para sa (i sa salita) cnt++
i-print ang cnt
}

4. buuin ang pangalawang field ng bawat record batay sa unang field.

$1 ~ /credit|gain/ { sum += $2 }
$1 ~ /debit|pagkawala/ { sum -= $2 }

WAKAS { print sum }

5. pag-uri-uriin ang isang file, paghahambing bilang string

{ line[NR] = $0 "" } # tiyakin ang uri ng paghahambing
# kung sakaling magmukhang numeric ang ilang linya

WAKAS { isort(line, NR)
para sa(i = 1 ; i <= NR ; i++) print line[i]
}

#insertion uri ng A[1..n]
function isort (A, n, i, j, hold)
{
para sa( i = 2 ; i <= n ; i++)
{
hawakan = A[j = i]
habang ( A[j-1] > hold )
{ j-- ; A[j+1] = A[j] }
A[j] = hawakan
}
# sentinel A[0] = "" ay gagawin kung kinakailangan
}

Kakayahan na MGA ISYU

Ang Posix 1003.2(draft 11.3) na kahulugan ng AWK na wika ay AWK gaya ng inilarawan sa AWK
aklat na may ilang extension na lumabas sa SystemVR4 nawk. Ang mga extension ay:

Mga bagong function: toupper() at tolower().

Mga bagong variable: ENVIRON[] at CONVFMT.

Mga detalye ng conversion ng ANSI C para sa printf() at sprintf().

Mga bagong opsyon sa command: -v var=value, maramihang -f na opsyon at mga opsyon sa pagpapatupad
bilang mga argumento sa -W.

Posix AWK ay nakatuon upang gumana sa mga file sa isang linya sa isang pagkakataon. RS maaaring baguhin mula sa "\n"
sa isa pang solong karakter, ngunit mahirap makahanap ng anumang gamit para dito — wala
mga halimbawa sa AWK book. Sa pamamagitan ng kumbensyon, RS = "", ginagawang hiwalay ang isa o higit pang mga blangkong linya
mga talaan, na nagpapahintulot sa mga talaan ng maraming linya. Kailan RS = "", "\n" ay palaging isang field separator
anuman ang halaga sa FS.

mawk, sa kabilang banda, ay nagpapahintulot RS upang maging isang regular na expression. Kapag lumabas ang "\n" sa
mga talaan, ito ay itinuturing bilang espasyo, at FS palaging tinutukoy ang mga patlang.

Ang pag-alis ng linya nang paisa-isang paradigm ay maaaring gawing mas simple ang ilang mga programa at kadalasang maaaring mapabuti
pagganap. Halimbawa, muling ginagawa ang halimbawa 3 mula sa itaas,

MAGSIMULA { RS = "[^A-Za-z]+" }

{ salita[ $0 ] = "" }

WAKAS { tanggalin ang salita[ "" ]
para sa (i sa salita) cnt++
i-print ang cnt
}

binibilang ang bilang ng mga natatanging salita sa pamamagitan ng paggawa ng bawat salita bilang isang talaan. Sa katamtamang laki ng mga file,
mawk nagsasagawa ng dalawang beses nang mas mabilis, dahil sa pinasimple na panloob na loop.

Pinapalitan ng sumusunod na programa ang bawat komento ng isang puwang sa isang C program file,

MAGSIMULA {
RS = "/\*([^*]|\*+[^/*])*\*+/"
Ang # komento ay record separator
ORS = " "
getline hold
}

{ print hold ; hold = $0 }

END { printf "%s" , hold }

Ang pag-buffer ng isang tala ay kinakailangan upang maiwasang wakasan ang huling tala na may puwang.

may mawk, ang mga sumusunod ay lahat ng katumbas,

x ~ /a\+b/ x ~ "a\+b" x ~ "a\\+b"

Ang mga string ay na-scan nang dalawang beses, isang beses bilang string at isang beses bilang regular na expression. Sa
string scan, mawk binabalewala ang pagtakas sa mga hindi nakakatakas na character habang ang AWK book ay nagtataguyod
\c makikilala bilang c na nangangailangan ng dobleng pagtakas ng mga meta-character sa
mga string. Tahasang tinatanggihan ng Posix na tukuyin ang gawi na pasibo na pinipilit ang mga programa
na dapat tumakbo sa ilalim ng iba't ibang mga awks upang magamit ang mas portable ngunit hindi gaanong nababasa, doble
pagtakas.

Hindi kinikilala ng Posix AWK ang "/dev/std{out,err}" o \x hex escape sequence sa mga string.
Hindi tulad ng ANSI C, mawk nililimitahan ang bilang ng mga digit na sumusunod sa \x sa dalawa bilang ang kasalukuyang
Ang pagpapatupad ay sumusuporta lamang sa 8 bit na mga character. Ang built-in flush unang lumitaw sa a
kamakailang (1993) AT&T awk na inilabas sa netlib, at hindi bahagi ng pamantayan ng posix.
Pinagsama-samang pagtanggal sa alisin ayos ay hindi bahagi ng pamantayan ng posix.

Ang Posix ay tahasang iniiwan ang pag-uugali ng FS = "" undefined, at binabanggit ang paghahati ng
itala sa mga character bilang isang posibleng interpretasyon, ngunit sa kasalukuyan ang paggamit na ito ay hindi
portable sa mga pagpapatupad.

Sa wakas, narito kung paano mawk humahawak ng mga pambihirang kaso na hindi tinalakay sa AWK book o sa
Posix draft. Hindi ligtas na ipagpalagay ang pare-pareho sa mga awks at ligtas na lumaktaw sa susunod
seksyon.

ibinabalik ng substr(s, i, n) ang mga character ng s sa intersection ng closed
pagitan [1, haba(s)] at kalahating bukas na pagitan [i, i+n). Kapag ganito
intersection ay walang laman, ang walang laman na string ay ibinalik; so substr("ABC", 1, 0) = ""
at substr("ABC", -4, 6) = "A".

Ang bawat string, kabilang ang walang laman na string, ay tumutugma sa walang laman na string sa harap kaya,
Ang s ~ // at s ~ "", ay palaging 1 gaya ng (mga, //) at tugma (mga, ""). Ang huling dalawa
itakda RLENGTH sa 0.

index(s, t) ay palaging pareho ng tugma (s, t1) kung saan ang t1 ay kapareho ng t sa
nakatakas ang mga metacharacter. Samakatuwid, ang pagkakapare-pareho sa tugma ay nangangailangan ng (mga) index, "")
palaging nagbabalik ng 1. Gayundin ang kundisyon, index(s,t) != 0 kung at t lamang ay isang substring
ng s, nangangailangan ng index("","") = 1.

Kung nakatagpo ng getline ang dulo ng file, ang getline var, ay iniiwan ang var na hindi nagbabago. Katulad nito,
sa pagpasok sa END aksyon, $0, ang mga patlang at NF hindi nababago ang kanilang halaga
ang huling rekord.

Gumamit ng mawk online gamit ang mga serbisyo ng onworks.net