Ang paghahati ay ginagawa sa pamamagitan ng regular na pagpapahayag fs o may field separator FS, Kung fs hindi binigay. Hinahati ng walang laman na string bilang field separator ang string sa isang hanay ng mga elemento na character ayon sa karakter.

Awk "BEGIN ( print split("It-was_the-best_of-times", output_array, "[-_]"), output_array, output_array )" 6 ang pinakamaganda

sub(r, t, s) pinapalitan ng kung saan nangyayari ang linya unang paglitaw ng regular na pagpapahayag r nasa linya nagbabalik ng `posisyon sa. Kung hindi ibinigay ang s, pagkatapos ay gamitin $0

nagbabalik ng `posisyon sa ay ang string kung saan nangyayari ang pagpapalit. Sa halip na magbalik ng bagong string na may ginawang kapalit, ibabalik ang bilang ng mga ginawang pagpapalit (0 o 1).

Awk "BEGIN ( s = "It was the best of times, it was the worst of times"; \ print "Num. matches replaced:", sub("times", "gifs", s); \ print s )" Blg. pinalitan ang mga tugma: 1 Ito ang pinakamahusay sa mga gif, ito ang pinakamasama sa mga panahon

gsub ginagawa ang parehong bagay bilang sub maliban na ang lahat ng paglitaw ng regular na expression ay pinalitan; sub At gsub ibalik ang bilang ng mga kapalit.

Awk "BEGIN ( s = "It was the best of times, it was the worst of times"; \ print "Num. matches replaced:", gsub("times", "cats", s); \ print s )" Blg. pinalitan ang mga tugma: 2 Ito ang pinakamahusay sa mga pusa, ito ang pinakamasama sa mga pusa sprintf sprintf(fmt, expr, ...) ay nagbabalik ng string na nagreresulta mula sa pag-format ng expr ... ayon sa printf(3) na format fmt awk "BEGIN ( x = sprintf("[%8.3f]", 3.141592654); print x )" [ 3.142]

Mga function sa antas ng system

sistema() nagbibigay-daan sa iyo na tumawag sa potensyal na ANUMANG maipapatupad na file sa system. Ang target na programa ay maaaring nasa iyong $PATH, o maaari mong tukuyin ito gamit ang isang ganap na landas.

Halimbawa, nakakatakot

System("rm -rf $HOME");

System("/bin/kill 1")

Kung gusto mong gumawa ng mas kumplikadong mga bagay, malamang na magtatapos ka sa paggawa ng isang bagay na tulad nito

Sysstring=sprintf("somecommand %s %s", arg1, arg2);

system(sysstring) malapit () ay isang mahalagang tampok na madalas na napapansin. Ito ay marahil dahil walang halatang tawag bukas() system(sysstring), kaya hindi iniisip ng mga tao ang hamon

. At para sa karamihan ng mga layunin na ito ay hindi kinakailangan. Ngunit DAPAT mong GAWIN ITO kung ikaw ay nakikitungo sa higit sa isang output file.

Binibigyan ka ng Awk ng kakayahang magbukas ng arbitrary na file sa mabilisang paraan. Halimbawa

/^file/ ( print $3 >> $2 )

dapat kunin ang linyang "file output here-is-a-word", buksan ang file na "output" at i-print ang "here-is-a-word" dito.

Ang AWK ay "matalino" dahil sinusubaybayan nito kung anong mga file ang bubuksan mo at PINAnanatili itong bukas. Ipinapalagay na kung binuksan mo ang file nang isang beses, malamang na gagawin mo itong muli. Sa kasamaang palad, nangangahulugan ito na kung magbubukas ka ng MARAMING file, maaari kang maubusan ng mga descriptor ng file. Kaya kapag alam mong tapos ka na sa isang file, isara ito. Kaya upang mapabuti ang halimbawa sa itaas, dapat kang gumamit ng isang bagay tulad ng mga sumusunod na linya:

/^file/ (kung ($2 != oldfile) (close(oldfile) ); print $3 >> $2 ; oldfile = $2; )

Ika-anim na Bahagi: Arrays

Konsepto ng array

Tinitingnan na namin ang mga variable bilang mga pangalan na naglalaman ng isang halaga. Ang mga array ay isang extension ng mga variable. Ang mga array ay mga variable na naglalaman ng higit sa isang halaga. Maaari silang maglaman ng higit sa isang halaga dahil ang bawat halaga ay may sariling numero.

Kung kailangan mong magkaroon ng tatlong halaga, maaari mong sabihin:

Value1="one"; value2="dalawa"; value3="tatlo";

O, maaari mong gamitin

Values="one"; values="two"; values="three";

Ang unang halimbawa ay tatlong magkakaibang variable na may sariling mga pangalan (na naiiba sa isang character). Ang pangalawang halimbawa ay isang array na binubuo ng isang variable, ngunit naglalaman ng maraming value, bawat isa ay may sariling numero.

Kapag gumagamit ng variable bilang array, dapat mong palaging ilakip ang value sa mga square bracket. Maaari kang pumili ng anumang pangalan para sa isang array variable, ngunit mula ngayon ang pangalan na iyon ay maaari LAMANG gamitin para sa isang array. HINDI ka makakagawa ng makabuluhang bagay

Values="one"; values="newvalue";

Gayunpaman, MAAARI mong muling italaga ang mga halaga tulad ng gagawin mo para sa mga normal na variable. Yung. tama ang sumusunod:

Ang kawili-wiling bagay ay, hindi katulad ng ibang mga wika, hindi ka pinipilit na gumamit lamang ng mga numero. Sa mga halimbawa sa itaas, ang ,, ay talagang binibigyang kahulugan bilang [“1”], [“2”], [“3”]. Na nangangahulugan na maaari mo ring gamitin ang iba pang mga string bilang mga identifier, at ituring ang array na halos tulad ng isang database ng solong column. Ang opisyal na pangalan para dito ay "kaugnay na hanay".

Mga Numero["one"]=1; mga numero ["dalawa"]=2; i-print ang mga numero ["isa"]; value="two"; print numbers; value=$1; if(numbers = ""){ print "no such number"; } !}

Kailan at paano gamitin ang mga array

Maaaring may iba't ibang mga kaso kung saan maaari mong piliing gumamit ng mga array. Ang ilang mga tao, kapag nagtatrabaho sa awk, ginagawa nang walang array. Ngunit hindi ito isang ganap na tamang posisyon: para sa mga array mayroong mga espesyal na variable na, halimbawa, ay nagpapakita ng laki nito (ang bilang ng mga halaga sa array), may mga construct na maginhawa para sa pag-enumerate ng mga miyembro ng array, at ang ilang mga function ay nagbabalik ng isang halaga sa anyo ng isang array. Anyway, tingnan natin ang ilang halimbawa na maaaring maging kapaki-pakinabang.

Nagse-save ng impormasyon para magamit sa ibang pagkakataon

Kapag gumagamit ng awk sa isang malaking shell script, maaari mong i-save ang impormasyon sa isang pansamantalang file. Ngunit maaari mong i-save ang mga salitang kailangan mo sa memorya at pagkatapos ay i-print ang lahat ng ito sa dulo, na magiging mas mabilis kaysa sa paggamit ng isang pansamantalang file.

/especial/( savedwords=$2; lnum+=1; ) END ( count=0; while(na-save na salita != "") ( print count, savewords; count+=1; ) )

Sa halip na magpakita lamang ng mga salita, maaari mong gamitin ang seksyong END para gawin ang anumang karagdagang pagproseso na maaaring kailanganin mo bago ipakita ang mga ito.

Kung nais mong magtalaga ng isang natatanging index sa mga halaga (upang maiwasan ang mga duplicate), maaari mong karaniwang sumangguni sa kanilang mga halaga sa pamamagitan ng kanilang sariling mga hilera. O, halimbawa, mag-save ng array na may column 3, na na-index ng katumbas na value sa column 2.

( threecol[$2]=$3 ) END ( para sa (v sa threecol) ( print v, threecol[v] ) )

Mga array at split()

Ang iba pang pangunahing dahilan para gumamit ng mga array ay kung gusto mong gumawa ng mga subfield. Sabihin nating mayroon kang isang row na may ilang malalaking dibisyon at ilang maliliit na dibisyon. Sa madaling salita, ang mga top level na field ay pinaghihiwalay ng mga puwang, ngunit pagkatapos ay makakakuha ka ng mas maliliit na salita na pinaghihiwalay ng mga colon.

Ito ay isang variable:field:type line Maaaring mayroong maramihang:type:values ​​​​dito

Sa halimbawa sa itaas, ang ikaapat na field, na pinaghihiwalay ng isang espasyo, ay may mga subfield na pinaghihiwalay ng mga tutuldok. Ngayon, sabihin nating gusto mong malaman ang halaga ng pangalawang subfield sa ikaapat na malaking field. Ang isang paraan upang gawin ito ay ang tumawag sa dalawang awks na konektado ng pipe:

Awk "(print $4)" | awk -F: "(print $2)"

Ang isa pang paraan ay ang pagbabago ng halaga ng "FS" sa mabilisang, na naglalaman ng field separator (tila hindi ito gumagana sa lahat ng pagpapatupad ng awk):

Awk "( newline=$4; fs=FS; FS=":"; $0=newline; print $2 ; FS=fs; )"

Ngunit maaari mo ring gawin ito sa mga array gamit ang split() function na tulad nito:

Awk "( newline=$4; split(newline,subfields,":"); print subfields) "

Sa kasong ito, ang paggamit ng array ay ang pinakakaraniwan at marahil pinaka-eleganteng paraan para gawin ito.

Kaya, ang Awk ay nagbibigay ng limitadong bilang ng mga istruktura ng data. Bilang karagdagan sa mga variable ng scalar at string, ang wika ay may built-in na napakalaking istraktura ng data. Bagama't opisyal na tinatawag na "arrays", ang istrukturang ito ay talagang isang nauugnay na array, katulad ng dict data structure sa Python.

Hindi kailangang masimulan ang mga array. Maaari ka lamang magsimulang magtalaga ng mga halaga. Tandaan na ang mga susi ay maaaring mga numero o mga string.

Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a["DOG"] = "CAT"; \ print a, a, a["DOG"] \ )" 1.1 0 CAT

Hindi magpi-print ng variable ang Awk nang walang index:

Awk "BEGIN ( \a["DOG"] = "CAT"; \print a\ )" awk: cmd. line:3: fatal: subukang gumamit ng array `a" sa kontekstong scalar

Bagama't maaari tayong mag-loop sa pamamagitan ng key gamit para sa:

Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a["DOG"] = "CAT"; \ for(k in a) print(a[k]) \ )" CAT 0 1.1

Ikapitong Bahagi: AWK at Shells (sh/ksh/bash/csh)

Minsan maaaring hindi sapat ang functionality ng AWK. Sa kasong ito, maaari mong isama ang awk sa iyong shell script. Nasa ibaba ang ilang halimbawa kung paano ito magagawa.

Simpleng konklusyon

Minsan gusto mong gamitin ang awk bilang isang formatter, at i-dump ang output nang direkta sa user Ang sumusunod na script ay kumukuha ng username bilang argumento at gumagamit ng awk upang i-dump ang impormasyon ng user mula sa /etc/passwd.

Tandaan: Tandaan na sa script ang mga solong quote ay pinalawak (hindi nested) at sa pagitan ng dalawang pinalawak na pares ng mga solong quote ay may variable na $1 (ang pangalawa), na sa kasong ito ay ang script argument, habang ang $1 ay bahagi ng syntax $1 (ibig sabihin ang unang field sa linya).

#!/bin/sh habang [ "$1" !="" ] ; gawin awk -F: "$1 == ""$1"" ( print $1,$3) " /etc/passwd shift tapos na

Pagtatalaga ng mga variable ng awk output shell

Minsan gusto naming gumamit ng awk para lamang sa isang mabilis na paraan upang itakda ang halaga ng isang variable. Gamit ang passwd na tema, mayroon kaming paraan upang malaman ang shell para sa user at tingnan kung kasama ito sa listahan ng mga opisyal na shell.

Muli, pansinin kung paano isinara ang mga solong quote sa awk expression Pagkatapos ng closed (second) quote, ang $1 ay isang variable na ipinapasa ang halaga ng unang argumento sa script, hindi bahagi ng awk syntax.

#!/bin/sh user="$1" kung [ "$user" == "" ] ; pagkatapos ay echo ERROR: kailangan ng username ; labasan ; fi usershell=`awk -F: "$1 == ""$1"" ( print $7) " /etc/passwd` grep -l $usershell /etc/shells kung [ $? -ne 0 ] ; pagkatapos ay echo ERROR: shell $usershell para sa user $user wala sa /etc/shells fi

Iba pang mga alternatibo:

# Tingnan ang "man regex" usershell=`awk -F: "/^"$1":/ ( print $7) " /etc/passwd` echo $usershell; # Tanging modernong awk lang ang tumatanggap ng -v. Maaaring kailanganin mong gumamit ng "nawk" o "gawk" usershell2=`awk -F: -v user=$1 "$1 == user ( print $7) " /etc/passwd` echo $usershell2;

Ang pagpapaliwanag ng mga karagdagang pamamaraan sa itaas ay iniiwan bilang takdang-aralin para sa mambabasa :)

Paglilipat ng data sa awk sa pamamagitan ng pipe

Minsan gusto mong ilagay ang awk bilang filter ng data, sa isang malaking program, o bilang isang linyang command na ipinasok sa isang shell prompt. Isang halimbawa ng tulad ng isang command sa isang script (isang listahan ng mga web server log file ay ipinapasa bilang mga argumento sa script, dahil ang pag-log ay nako-customize at ang mga log ay maaaring magkaroon ng ibang istraktura; upang gumana sa mga partikular na kaso, ang mga command ay maaaring kailanganin dapat ayusin):

#!/bin/sh grep -h " /index.html" $* | awk -F\" "(print $4)" | sort -u

1. Kawili-wiling artikulo, nais kong pasalamatan ka para sa iyong mga pagsisikap.

   Natagpuan ko na ito ay hindi tumpak. Kung ipapatupad mo ang linya mula sa halimbawa

   Awk -F " " "( print $2 )" field_data.txt

   ito ay maglalabas ng parehong bagay bilang

   Awk "( print $2 )" field_data.txt

   Ang resulta ay isang halimbawa na may -F hindi maayos na inilarawan.

Isang panimula sa isang kahanga-hangang wika na may kakaibang pangalan

Serye ng Nilalaman:

Sa pagtatanggol sa awk

Sa seryeng ito ng mga artikulo, gagawin kong isang bihasang programmer ng awk ang mambabasa. Sumasang-ayon ako na ang awk ay walang pinakamaganda o pinakauso na pangalan, at ang GNU na bersyon ng awk, na tinatawag na gawk, ay mukhang kakaiba. Ang mga programmer na hindi pamilyar sa wika ay maaaring marinig ang pangalan nito at isipin ang isang paghalu-halo ng sinaunang at lumang code na maaaring magdulot ng kahit na ang pinaka-kaalaman na espesyalista sa UNIX na mabaliw (na nagiging dahilan upang siya ay sumigaw ng "kill -9!" at patuloy na tumakbo para sa kape).

Oo, walang magandang pangalan si awk. Ngunit ito ay isang kahanga-hangang wika. Ang Awk ay idinisenyo para sa pagpoproseso at pag-uulat ng teksto, ngunit mayroon itong maraming mahusay na binuo na mga tampok na nagbibigay-daan sa seryosong programming. Gayunpaman, hindi tulad ng ilang iba pang mga wika, pamilyar ang syntax ng awk at hinihiram ang pinakamahusay mula sa mga wika tulad ng C, python at bash (bagama't pormal na ginawa ang awk bago ang python at bash). Ang Awk ay isa sa mga wikang iyon na, kapag natutunan, ay nagiging mahalagang bahagi ng strategic arsenal ng isang programmer.

Unang hakbang sa awk

Magsimula tayo at subukang mag-eksperimento sa awk upang makita kung paano ito gumagana. Sa command line, ipasok ang sumusunod na command:

Dapat ipakita ng resulta ang mga nilalaman ng /etc/passwd file. Ngayon - isang paliwanag sa ginawa ni awk. Kapag tumatawag sa awk, tinukoy namin ang /etc/passwd bilang input file. Nang tumakbo kami ng awk, pinoproseso nito ang print command para sa bawat linya sa /etc/passwd sa pagkakasunud-sunod. Ang lahat ng output ay ipinadala sa stdout at nakuha namin ang parehong resulta tulad ng cat /etc/passwd. Ngayon ipaliwanag natin ang (print) block. sa awk braces ay ginagamit sa pagpapangkat ng mga bloke ng teksto, tulad ng sa C. Ang aming bloke ng teksto ay mayroon lamang isang print command. Sa awk, ang print command na walang karagdagang mga parameter ay nagpi-print ng buong nilalaman kasalukuyang linya.

Narito ang isa pang halimbawa ng isang awk program na gumagawa ng parehong bagay:

Sa awk, ang variable na $0 ay kumakatawan sa buong kasalukuyang linya, kaya ang pag-print at pag-print ng $0 ay eksaktong parehong bagay. Kung gusto mo, maaari kang lumikha ng isang programa sa awk na maglalabas ng data na ganap na hindi nauugnay sa input data. Narito ang isang halimbawa:

Kapag ipinasa mo ang string "" sa print command, palagi itong nagpi-print ng walang laman na string. Kung susubukan mo ang script na ito, makikita mo na ang awk ay naglalabas ng isang blangkong linya bawat linya sa /etc/passwd. Nangyayari ito muli dahil nagpapatupad ang awk ng script para sa bawat linya sa input file. Narito ang isa pang halimbawa:

Kung patakbuhin mo ang script na ito, pupunuin nito ang screen ng mga salitang "yay". :)

Maramihang mga patlang

Ang Awk ay angkop para sa pagproseso ng text na hinati sa maraming lohikal na field, at ginagawang madali ang pag-access sa bawat indibidwal na field mula sa loob ng isang awk script. Ang sumusunod na script ay magpi-print ng listahan ng lahat ng mga account sa system:

Sa awk call sa halimbawa sa itaas, ang –F na opsyon ay tumutukoy sa ":" bilang field separator. Kapag pinoproseso ang print $1 command, ini-print ng awk ang unang field na makikita sa bawat linya ng input file. Narito ang isa pang halimbawa:

Narito ang isang snippet mula sa screen output ng script na ito:

Gaya ng nakikita mo, inilalabas ng awk ang una at pangatlong field ng /etc/passwd file, na kung saan ay ang username at uid field, ayon sa pagkakabanggit. Gayunpaman, kahit na gumagana ang script, hindi ito perpekto - walang mga puwang sa pagitan ng dalawang field ng output! Maaaring inaasahan ng mga nakasanayan sa programming sa bash o python ang pag-print ng $1 $3 na utos na magpasok ng puwang sa pagitan ng dalawang field na ito. Gayunpaman, kapag lumitaw ang dalawang linya sa tabi ng isa't isa sa isang awk program, pinagsasama-sama ng awk ang mga ito nang hindi nagdaragdag ng puwang sa pagitan nila. Ang sumusunod na utos ay maglalagay ng puwang sa pagitan ng mga patlang:

Kapag tinawag ang print sa ganitong paraan, pinagsasama nito ang $1 , " " at $3 sa serye, na gumagawa ng output na nababasa ng tao sa screen. Siyempre, maaari rin kaming magpasok ng mga field label kung kinakailangan:

Bilang resulta, nakukuha namin ang sumusunod na konklusyon:

Mga panlabas na script

Ang pagpasa ng mga script sa awk bilang mga argumento ng command line ay maaaring maging maginhawa para sa maliliit na one-liner, ngunit pagdating sa mga kumplikadong multi-line na programa, tiyak na mas mahusay na buuin ang script bilang isang panlabas na file. Maaari mong ituro ang awk sa script file na ito gamit ang -f na opsyon:

Ang paglalagay ng mga script sa hiwalay na mga text file ay nagbibigay-daan din sa iyong samantalahin ang mga karagdagang benepisyo ng awk. Halimbawa, ang sumusunod na multi-line na script ay gumagawa ng parehong bagay tulad ng isa sa aming mga nakaraang one-liner - nagpi-print ng unang field ng bawat linya mula sa /etc/passwd:

Ang pagkakaiba sa pagitan ng dalawang pamamaraang ito ay kung paano namin tinukoy ang field separator. Sa script na ito, ang field separator ay panloob na tinukoy ng program mismo (sa pamamagitan ng pagtatakda ng FS variable), samantalang sa aming nakaraang halimbawa, ang FS ay na-configure sa pamamagitan ng pagpasa sa awk ng -F":" na opsyon sa command line. Karaniwang pinakamainam na tukuyin ang field separator sa loob mismo ng script, dahil lang hindi nito kakailanganing tandaan mo ang isa pang argumento ng command line. Titingnan natin ang variable ng FS nang mas detalyado mamaya sa artikulong ito.

BEGIN at END block

Karaniwang pinapagana ng awk ang bawat bloke sa teksto ng script nang isang beses para sa bawat linya ng pag-input. Gayunpaman, madalas na may mga sitwasyon sa programming kung saan kailangan mong magsagawa ng initialization code bago simulan ng awk ang pagproseso ng text mula sa isang input file. Para sa mga ganitong kaso, ang awk ay nagbibigay ng kakayahang tumukoy ng isang BEGIN block. Ginamit namin ang BEGIN block sa nakaraang halimbawa. Dahil ang BEGIN block ay pinoproseso bago simulan ng awk ang pagpoproseso ng input file, ito ay isang magandang lugar upang simulan ang isang FS (field separator) na variable, mag-output ng isang header, o mag-initialize ng iba pang mga global variable na gagamitin mamaya sa programa.

Nagbibigay din ang Awk ng isa pang espesyal na bloke na tinatawag na END block. Isinasagawa ng Awk ang block na ito pagkatapos maproseso ang lahat ng linya sa input file. Karaniwan, ang isang END block ay ginagamit upang magsagawa ng mga panghuling kalkulasyon o mga resulta ng output na dapat lumabas sa dulo ng stream ng output.

Mga regular na expression at block

Binibigyang-daan ka ng Awk na gumamit ng mga regular na expression upang piliing magsagawa ng mga partikular na bloke ng isang programa depende sa kung ang regular na expression ay tumutugma sa kasalukuyang linya. Narito ang isang halimbawang script na nagpi-print lamang ng mga linyang iyon na naglalaman ng sequence ng character na foo:

Siyempre, maaari kang gumamit ng mas kumplikadong mga regular na expression. Narito ang isang script na maglalabas lamang ng mga string na naglalaman ng float:

Mga Expression at Block

Mayroong maraming iba pang mga paraan upang piliing isagawa ang isang bloke ng isang programa. Maaari naming ilagay ang anumang Boolean expression bago ang isang bloke ng programa upang makontrol ang pagpapatupad ng bloke na iyon. Magpapatupad lang ng program block ang Awk kung ang dating Boolean na expression ay magiging true. Ang sumusunod na halimbawang script ay maglalabas ng ikatlong field ng lahat ng linya kung saan ang unang field ay fred . Kung ang unang field ng kasalukuyang linya ay hindi fred , ipagpapatuloy ng awk ang pagproseso ng file at hindi maglalabas ng print statement para sa kasalukuyang linya: :

Nag-aalok ang Awk ng buong hanay ng mga operator ng paghahambing, kabilang ang karaniwang "==", "<", ">", "<=", ">=" at "!=". Bilang karagdagan, ang awk ay nagbibigay ng "~" at "!~" na mga operator, na nangangahulugang "mga tugma" at "hindi tumutugma." Inilalagay nila ang variable sa kaliwa ng operator at ang regular na expression sa kanan nito Narito ang isang halimbawa kung saan ang pangatlong field lang ng isang linya ang output kung ang ikalimang field ng parehong linya ay naglalaman ng root sequence ng character:

Mga pahayag na may kondisyon

Nagbibigay din ang Awk ng napakagandang C-like if na mga pahayag. Kung nais mo, maaari mong muling isulat ang nakaraang script gamit ang kung:

Parehong gumagana ang mga script. Sa unang halimbawa, ang boolean na expression ay nasa labas ng block, habang sa pangalawang halimbawa, ang block ay isinasagawa para sa bawat input line, at pinili namin ang print command gamit ang isang if statement, at maaari mong piliin ang isa na pinakamahusay na pinagsama sa iba pang mga bahagi ng script.

Narito ang isang mas kumplikadong halimbawa ng isang if statement sa awk. Tulad ng nakikita mo, kahit na may mga kumplikadong nested na kondisyon, kung ang mga pahayag ay mukhang magkapareho sa kanilang mga katapat na C:

Gamit ang mga pahayag na if, maaari nating baguhin ang code na ito:

Ang parehong mga script ay magpi-print lamang ng mga linyang iyon Hindi naglalaman ng pagkakasunod-sunod ng character matchme . At sa kasong ito, masyadong, maaari kang pumili ng isang paraan na mas mahusay na gumagana sa isang partikular na programa. Pareho silang gumagawa ng parehong bagay.

Binibigyan ka rin ng Awk ng kakayahang gamitin ang mga Boolean operator na "||" (“lohikal O”) at “&&” (“lohikal na AT”), na nagbibigay-daan sa iyong lumikha ng mas kumplikadong mga Boolean na expression:

Ang halimbawang ito ay maglalabas lamang ng mga linya kung saan ang unang field ay foo At ang pangalawang field ay bar.

Mga variable na numero!

Sa ngayon ay naka-print na kami ng alinman sa mga variable ng string, buong mga string, o mga partikular na field. Gayunpaman, binibigyan din kami ng awk ng kakayahang magsagawa ng mga paghahambing sa parehong mga integer at mga numero ng floating point. Gamit ang mathematical expression, napakadaling magsulat ng script na binibilang ang bilang ng mga walang laman na linya sa isang file. Narito ang isang script:

Sa BEGIN block, sinisimulan namin ang aming integer variable x sa zero. Pagkatapos, sa tuwing makakatagpo ang awk ng walang laman na linya, isasagawa nito ang statement x=x+1 , dagdagan ang x ng 1. Kapag naproseso na ang lahat ng linya, isasagawa ang END block, at ipi-print ng awk ang panghuling kabuuan, na nagpapahiwatig ang bilang ng mga walang laman na linya na natagpuan.

Mga variable ng string

Ang isa sa mga magagandang bagay tungkol sa mga variable ng awk ay ang mga ito ay "plain at lowercase." Tinatawag ko ang mga variable ng awk na "string" dahil ang lahat ng mga variable ng awk ay panloob na naka-imbak bilang mga string. Kasabay nito, ang mga variable ng awk ay "simple" dahil maaari kang gumawa ng matematika sa isang variable, at kung naglalaman ito ng isang wastong string ng numero, awtomatikong aayusin ng awk ang pag-convert ng string sa isang numero. Upang makita kung ano ang ibig kong sabihin, tingnan ang halimbawang ito:

Awk ay maglalabas ng:

Nakaka-curious! Bagama't itinalaga namin ang string value na 1.01 hanggang x, nakapagdagdag pa rin kami ng isa dito. Hindi namin magawa ito sa bash o python. Una sa lahat, hindi sinusuportahan ng bash ang floating point arithmetic. At habang ang bash ay may mga variable na "string", hindi sila "simple"; Upang makagawa ng anumang matematika, hinihiling sa amin ng bash na ibalot ang aming mga kalkulasyon sa mga pangit na $() construct. Kung gumagamit kami ng python, kakailanganin naming tahasang i-convert ang aming string 1.01 sa isang floating point value bago gumawa ng anumang mga kalkulasyon dito. Bagama't hindi ito mahirap, dagdag na hakbang pa rin ito. Sa kaso ng awk, lahat ng ito ay awtomatikong ginagawa, at ginagawa nitong maganda at malinis ang aming code. Kung kailangan naming i-square ang unang field ng bawat input string at magdagdag ng isa dito, gagamit kami ng script na tulad nito:

Kung mag-eksperimento ka nang kaunti, makikita mo na kung ang isang variable ay walang wastong numero, ituturing ng awk ang variable na iyon bilang isang numeric zero kapag sinusuri ang isang mathematical expression.

Maraming operator

Ang isa pang magandang tampok ng awk ay ang kumpletong hanay ng mga mathematical operator. Bilang karagdagan sa karaniwang pagdaragdag, pagbabawas, pagpaparami, at paghahati, ang awk ay nagbibigay sa amin ng kakayahang gamitin ang dating ipinakitang exponent operator na "^", ang integer division remainder operator "%" at marami pang ibang maginhawang assignment operator na hiniram mula sa C.

Kabilang dito ang mga operator bago at pagkatapos ng incremental/decremental na pagtatalaga (i++, --foo), mga operator ng pagtatalaga na may karagdagan/pagbabawas/pagpaparami/dibisyon (a+=3, b*=2, c/=2.2, d-=6.2) . Ngunit hindi lang iyon - mayroon din kaming maginhawang mga operator ng pagtatalaga na may pagkalkula ng natitirang bahagi ng integer division at exponentiation (a^=2, b%=4).

Mga separator ng field

Ang awk ay may sariling hanay ng mga espesyal na variable. Binibigyang-daan ka ng ilan sa mga ito na i-fine-tune kung paano gumagana ang awk, habang ang iba ay naglalaman ng mahalagang impormasyon sa pag-input. Natalakay na namin ang isa sa mga espesyal na variable na ito, ang FS. Gaya ng nabanggit kanina, binibigyang-daan ka ng variable na ito na tukuyin ang pagkakasunud-sunod ng mga character na ituturing ng awk bilang field separator. Kapag ginamit namin ang /etc/passwd bilang input, ang FS ay nakatakda sa ":". Ito ay naging sapat na, ngunit ang FS ay nagbibigay sa amin ng higit na kakayahang umangkop.

Ang halaga ng FS variable ay hindi kailangang maging isang character; maaari itong italaga ng isang regular na expression na tumutukoy sa pattern ng character ng anumang haba. Kung pinoproseso mo ang mga field na pinaghihiwalay ng isa o higit pang mga character ng tab, dapat na i-configure ang FS bilang mga sumusunod:

Sa itaas ginamit namin espesyal na karakter regular na expression na "+" na nangangahulugang "isa o higit pang mga paglitaw ng nakaraang character".

Kung ang mga field ay pinaghihiwalay ng puting espasyo (isa o higit pang mga puwang o tab), maaari mong itakda ang FS sa sumusunod na regular na expression:

Habang gagana ang setup na ito, hindi ito kinakailangan. Bakit? Dahil ang default na value ng FS ay isang space character, na binibigyang-kahulugan ng awk bilang "isa o higit pang mga puwang o tab." Sa aming partikular na halimbawa, ang default na halaga ng FS ay eksakto kung ano ang kailangan namin!

Wala ring problema sa mga kumplikadong regular na expression. Kahit na ang mga tala ay pinaghihiwalay ng salitang "foo" na sinusundan ng tatlong digit, ang sumusunod na regular na expression ay mag-parse ng data nang tama:

Bilang ng mga patlang

Ang susunod na dalawang variable na titingnan natin ay karaniwang hindi sinadya upang sulatan, ngunit ginagamit upang basahin at makakuha ng kapaki-pakinabang na impormasyon tungkol sa input. Ang una sa mga ito ay ang NF variable, na tinatawag ding bilang ng mga field. Awkmatikong itinatakda ng Awk ang halaga ng variable na ito sa bilang ng mga field sa kasalukuyang tala. Maaari mong gamitin ang variable ng NF upang ipakita lamang ang ilang partikular na linya ng pag-input:

Siyempre, ang variable ng NF ay maaari ding gamitin sa mga conditional na pahayag, halimbawa:

Record number

Ang isa pang maginhawang variable ay ang record number (NR). Palagi itong naglalaman ng bilang ng kasalukuyang tala (itinuturing ng awk na ang unang tala ay numero ng talaan 1). Sa ngayon ay nakipag-ayos kami input file, na naglalaman ng isang entry sa bawat linya. Sa ganitong mga sitwasyon, iuulat din ng NR ang kasalukuyang numero ng linya. Gayunpaman, kapag sinimulan naming pangasiwaan ang mga talaan ng maraming linya sa mga susunod na artikulo sa seryeng ito, hindi na ito mangyayari, kaya kailangan mong mag-ingat! Maaaring gamitin ang NR tulad ng variable ng NF sa output lamang ilang linya input:

Isa pang halimbawa:

Nagbibigay ang Awk ng mga karagdagang variable na maaaring magamit para sa iba't ibang layunin. Titingnan natin ang mga variable na ito sa mga artikulo sa hinaharap. Dumating na kami sa dulo ng aming unang paggalugad ng awk. Sa mga susunod na artikulo sa serye, magpapakita ako ng mas advanced na functionality ng awk, at tatapusin namin ang seryeng ito gamit ang isang real-world na awk application. Pansamantala, kung gusto mong matuto nang higit pa, maaari mong tingnan ang mga mapagkukunang nakalista sa ibaba.