Kezdô lépések awk-ban

Az awk alapvetô feladata, hogy olyan sorokat (vagy más szövegegységeket) keressen file-okban, amelyek tartalmaznak egy bizonyos mintát. Amikor egy sor illeszkedik egy mintára, az awk segédprogram egy megadott feladatot vagy tevékenységet végez el a soron. Ezt addig ismétli minden soron, amíg a file-ok végére nem ér.

Az awk-ban írt programok különböznek a más programozási nyelven írt programoktól, mert az awk programok adatvezéreltek; ez azt jelenti, hogy elôször azt az adatot adod meg amivel dolgozni szeretnél, és csak utána adod meg, hogy mit szeretnél az adattal csinálni, ha megtaláltad. A legtöbb programozási nyelv procedurális; apró részletekre lebontva meg kell adnod a programnak, hogy mit csináljon. Amikor procedurális programozási nyelvvel dolgozol, általában nehéz pontosan megadni, hogy a programod milyen adatot fog feldolgozni. Mivel ez az awk-ban nem így van, ezért fogod könnyűnek találni az awk programok írását és olvasását.

Az awk segédprogram futásához meg kell adnod egy awk programot, ami definiálja az awk számára hogy mit kell csinálnia. A program szabályokat tartalmaz. (Tartalmazhat függvény definíciót is, ami már bonyolultabb, és így most nem mélyedünk el benne, see section Felhasználó által definiált függvények.) Minden szabály tartalmaz egy mintát, amit keresünk, és egy tevékenységet amit végre kell hajtani, ha a mintát megtalálta a program.

Szintaktikailag egy szabály egy mintából, majd egy azt követô tevékenységbôl áll. A tevékenységet kapcsos zárójelek közé kell tenni, hogy elválasszuk a mintától. A szabályok általában egy új sorral vannak elválasztva. Egy awk program így néz ki:

minta { tevékenység }
minta { tevékenység }
...

Egy rózsa tövisekkel

Az awk programozási nyelv hosszú évek során fejlôdött. Errôl további részletek találhatók egy késôbbi fejezetben, section The Evolution of the awk Language. Az ebben a könyvben bemutatott nyelvet gyakran hívják az "új awk"-nak.

Ennek következtében sok rendszer többféle awk verziót tartalmaz. Néhány rendszer rendelkezik egy awk segédprogrammal, ami az eredeti awk implementációja, és egy nawk programmal, ami az új verzió. Más rendszereken oawk-nak hívják a "régebbi awk" implementációt, és az awk nevet használják az új verzióra. Elôfordul, hogy csak egy verzió található meg a rendszeren, általában az újabb. (2)

Ebben a helyzetben bonyolult lehet azt eldönteni, hogy melyik awk verziót használd amikor a programot írod. A legjobb tanács, amit adhatunk, hogy olvasd el a rendszereden levô dokumentációt. Ellenôrizd, hogy awk, oawk, nawk vagy gawk program létezik-e a rendszereden. Jó esélyed van arra, hogy az új verzió valamilyen implementációját megtalálod a gépeden, és azt tanácsoljuk, hogy ezt használd. (Természetesen, ha ezt a könyvet olvasod, nagyon valószínű, hogy a gawk implementációt megtalálod a rendszereden!)

Amikor olyan részletre hivatkozunk aminek bármely POSIX kompatíbilis implementációban szerepelnie kell, az awk nevet fogjuk használni, csak a GNU implementációra jellemzô részeknél használjuk a gawk nevet.

Hogyan futtassunk awk programokat

Sokféle lehetôség van egy awk program futtatására. Ha a program rövid, a legegyszerűbb a parancssorban elhelyezni, például:

awk 'program' input-file1 input-file2 ...

ahol a program mintákat és tevékenységeket tartalmaz, ahogy korábban elmagyaráztuk. (Miért használunk idézôjeleket? A magyarázatot megtalálod alább, section Egyszer használatos, eldobható awk programok.)

Amikor egy program hosszabb, kényelmesebb egy file-ban elhelyezni és így futtatni:

awk -f program-file input-file1 input-file2 ...

Egyszer használatos, eldobható awk programok

Ha már jobban megismerted az awk programozási nyelvet, gyakran fog elôfordulni, hogy az egyszerűbb programokat azonnal megírod a terminál elôtt ülve, amint használni szeretnéd. Ebben az esetben az awk parancs a:

awk 'program' input-file1 input-file2 ...

ahol a program mintákat és tevékenységeket tartalmaz.

Ez a parancsformátum arra utasítja a shell-t, vagy a parancs értelmezôt, hogy indítsa el az awk segédprogramot, ami majd használni fogja a programot a bemeneti file-ok tartalmának feldolgozására. Az idézôjelek azért vannak a program körül, hogy a shell ne értelmezze ezt a részt. Ráadásul, az idézôjelek arra is utasítják a shell-t hogy az egészet egyetlen argumentumként adja át az awk-nak, így lehetôvé téve több sorból álló program megadását is.

Ez a forma lényegében megfelel közepes méretű awk programok shell script-bôl való futtatására is, mivel így elkerülhetô a külön file használata az awk programhoz. Az egy file-ból álló programok megbízhatóbbak, mivel nincs másik file, amire szükség volna, és esetleg rossz helyen lenne.

A section Hasznos egysoros programok, bemutat néhány rövid, egyszerű programot.

Mint érdekesség, megjegyezzük, hogy az

awk '/foo/' files ...

parancs lényegében ugyanaz mint a

egrep foo files ...

Az awk futtatása bemeneti file-ok nélkül

Az awk segédprogram bemeneti file-ok nélkül is futtatható. Ha begépeled:

awk 'program'

akkor az awk programot a szabványos bemenetre fogja alkalmazni, ami általában az a szöveg, amit a terminálon begépelsz. Ez egészen addig tart amíg be nem gépeled hogy Control-d, vagyis jelzed hogy a "file"-nak vége. (Más operációs rendszereken a file vége jel más lehet, pl. OS/2 és MS-DOS alatt a Control-z.)

Például az alábbi program kinyomtat egy barátságos tanácsot, (ollózva Douglas Adams művébôl, Galaxis útikönyv stopposoknak), aminek segítségével elkerülheted a számítógép által okozott fejfájást. (`BEGIN'-t még eddig nem magyaráztuk el)

$ awk "BEGIN { print \"Don't Panic!\" }"
-| Don't Panic!

Ez a program nem olvas be semmit. A `\' jel minden belsô macskaköröm elôtt szükséges a shell miatt, különösen mivel idézôjelet és macskakörmöt kevertünk a szövegben.

A következô egyszerű awk program a cat segédprogramot emulálja; amit begépelsz, kinyomtatja. (Hogy ez miért működik, azt hamarosan eláruljuk.)

$ awk '{ print }'
Now is the time for all good men
-| Now is the time for all good men
to come to the aid of their country.
-| to come to the aid of their country.
Four score and seven years ago, ...
-| Four score and seven years ago, ...
What, me worry?
-| What, me worry?
Control-d

Hosszú programok futtatása

Elôfordul, hogy az awk programod hosszú lesz. Ebben az esetben kényelmesebb lehet a programot egy külön file-ba tenni. Az awk parancs ennek a file-nek a futtatására:

awk -f source-file input-file1 input-file2 ...

A `-f' argumentum adja meg az awk-nak, hogy a végrehajtandó program a source-file-ban van. A source-file-nak bármilyen neve lehet. Például az alábbi programot

BEGIN { print "Don't Panic!" }

beteheted az `advice' file-ba. A parancs:

awk -f advice

ugyanazt fogja csinálni, mint a :

awk "BEGIN { print \"Don't Panic!\" }"

amit már korábban elmagyaráztunk. (See section Az awk futtatása bemeneti file-ok nélkül.) Érdemes megjegyezni, hogy a file-név köré, amit a `-f' argumentummal definiálsz, nem kellenek idézôjelek, mivel a file-nevek általában nem tartalmaznak speciális shell karaktereket. Természetesen az idézôjelek az `advice' file-on belül sem kellenek az awk program köré. Az idézôjelek csak a parancssorban megadott awk programok esetén kellenek.

Ha azonosítani szeretnéd awk programjaidat, akkor használhatod a `.awk' kiterjesztést a file név után. Ez nem befolyásolja az awk program működését, de egyszerűbbé teheti file-jaid nyilvántartását.

Futtatható awk programok

Miután megtanultad az awk nyelvet, önmagában futtatható programokat is írhatsz a `#!' mechanizmus segítségével. A legtöbb Unix rendszeren (3) ez működni fog (és valamikor a GNU rendszeren is.)

Például kiegészítheted az `advice' file-t az alábbiak szerint:

#! /bin/awk -f

BEGIN { print "Don't Panic!" }

Miután a file-t futtathatóvá tetted (a chmod segédprogrammal), ha egyszerűen begépeled a shell-nek, hogy `advice', a rendszer úgy állít be mindent, mintha az awk(4) segédprogramot a `awk -f advice' paranccsal futtatnád.

$ advice
-| Don't Panic!

Az önmagában futtatható awk programok akkor is jó szolgálatot tehetnek, ha olyan programot szeretnél írni, amit más felhasználók is futtathatnak anélkül, hogy ismernék az awk-ot.

Figyelem: Ne tegyél egynél több argumentumot a `#!' jellel kezdôdô sorba az awk után. Ez nem működik. Az operációs rendszer az interpreter utáni részt úgy kezeli, mint egyetlen argumentum, és így adja át az awk-nak. Következésképpen furcsa dolgok történhetnek: a legvalószínűbb, hogy a program használatáról kapsz valamilyen ismertetést.

Néhány régebbi rendszer nem támogatja a `#!' mechanizmust. Ugyanazt a hatást érheted el egy shell script-el, aminek valahogy így kell kinéznie:

: Ezt biztosítja, hogy az alap shell fogja végrehajtani.
awk 'program' "$@"

Ebben az esetben alapvetô fontosságú, hogy a programot idézôjelek közé tedd, így a shell nem fogja értelmezni. Ha mégis lehagynád, csak egy shell varazsló a megmondhatója, hogy mi fog történni.

A "$@" jel hatására a shell minden, a parancssorban megadott argumentumot átad az awk segédprogramnak, anélkül hogy azokat értelmezné. Az elsô sorban elhelyezett kettôspont segítségével a program még C shell-t használó embereknek is működni fog. (Nem minden régebbi rendszer ismeri ezt a módszert, de a legtöbb igen.)

Megjegyzések az awk programokban

Egy megjegyzés lényegében egy szöveg, ami az emberek számára került be a programba, és nem igazán része a programnak. A megjegyzések például elmagyarázhatják, hogy a program mit csinál, és hogyan működik. Szinte minden programozási nyelvben lehet megjegyzéseket elhelyezni, mivel a programokat általában nehezebb megérteni a megjegyzések által adott extra segítség nélkül.

Az awk programozási nyelvben a megjegyzések egy `#' karakterrel kezdôdnek és a sor végéig tartanak. A `#' karakternek nem kell a sor elsô karakterének lennie. Az awk nyelv a karakter utáni teljes sort eldobja. Például az alábbiakkal egészíthetjük ki az `advice' programot:

# Ez a program egy barátságos üzenetet nyomtat ki. Így
# segít abban, hogy ne félj az új dolgoktól.
BEGIN { print "Don't Panic!" }

Ha akarsz, tehetsz megjegyzéseket az egyszer használatos programokba is, de ez nem túl hasznos; a megjegyzések fô célja, hogy segítsen téged vagy más felhasználókat a program megértésében egy késôbbi idôpontban.

Figyelem: Ahogy azt már korábban megemlítettük, section Egyszer használatos, eldobható awk programok, a kicsi és közepes programokat idézôjelek közé teheted, hogy önmagukban is futtatható shell script-ek legyenek. Ha ezt a módszert választod ne használj idézôjelet a megjegyzésekben (sehol a programodban). A shell ezt úgy értelmezné mint a lezárását a kezdô idézôjelnek. Az eredmény? A shell jelezni fogja hogy nincs azonos számú kezdô és záró idézôjel, és ha ezután az awk mégis elindulna, akkor valószínűleg hibaüzeneteket fog kiírni. Például:

awk 'BEGIN { print "hello" } # let's be cute'

Egy nagyon egyszerű példa

Az alábbi parancs egy egyszerű awk programot futtat le, ami a `foo' szó minden elôfordulását megkeresi a `BBS-list' file-ban.

awk '/foo/ { print $0 }' BBS-list

Amikor az awk olyan sort talál, ami tartalmazza a `foo' szót, kinyomtatja az adott sort, mivel a `print $0' ezt jelenti: nyomtasd ki az aktuális sort. (Ugyanez érhetô el az egyszerű `print' paranccsal, így az is használható.)

A példában `/' jelek veszik körül a `foo' szót az awk programban. Ezek a jelek határozzák meg, hogy a `foo' mintát szeretnénk megtalálni. Az ilyen mintákat reguláris kifejezésnek nevezzük és késôbb tárgyaljuk részletesen (see section Reguláris kifejezések). Lehet, hogy a minta a szónak csak egy részére illeszkedik. Az awk program körüli idézôjelek hatására a shell semelyik speciális shell karaktert (ami esetleg elôfordulhat a mintában) nem fogja értelmezni.

A program eredménye:

$ awk '/foo/ { print $0 }' BBS-list
-| fooey        555-1234     2400/1200/300     B
-| foot         555-6699     1200/300          B
-| macfoo       555-6480     1200/300          A
-| sabafoo      555-2127     1200/300          C

Egy awk szabályban vagy a minta vagy a tevékenység elhagyható, de egyszerre mindkettô nem. Ha a minta nincs megadva, akkor az adott tevékenység minden sorra végrehajtódik. Ha a tevékenység lett elhagyva, akkor az alaptevékenység hajtódik végre, kinyomtat minden olyan sort, amire a minta illeszkedik.

Ezért van az, hogy a fenti példában elhagyhatjuk a tevékenységet (a print és a kapcsos zárójeleket) és az eredmény ugyanaz lesz: minden olyan sort kinyomtat, ami illeszkedik a `foo' mintára. Összehasonlításképpen, ha a print tevékenységet elhagyjuk, de a kapcsos zárójeleket megtartjuk, ami egy üres tevékenységet jelent, akkor egyetlen sort sem fog a program kinyomtatni.

Egy példa két szabállyal

Az awk segédprogram a bemeneti file-okat olvassa soronként és megpróbálja illeszteni a mintákat minden egyes sorra. Ha több minta is illeszkedik, akkor több tevékenység hajtodik végre, abban a sorrendben, ahogy az awk programban definiálva lettek. Ha egyetlen minta sem illeszkedik, akkor nem történik semmi.

Miután az aktuális sorra illeszkedô szabályokat feldolgozta (lehet hogy egyet sem), az awk beolvassa a következô sort (de érdemes figyelembe venni a section A next kifejezés, és a section A nextfile kifejezés által leírtakat). Ezt a folyamatot a file végéig ismétli.

Például az alábbi awk program:

/12/  { print $0 }
/21/  { print $0 }

két szabályt tartalmaz. Az elsô szabályban a minta az `12' szó, és a `print $0' a tevékenység. A második szabály mintája a `21' szó, és a tevékenység szintén a `print $0'. Mindegyik szabály körül kapcsos zárójelek vannak, külön-külön.

Ez az awk program kinyomtat minden olyan sort, amelyik vagy az `12' vagy a `21' szót tartalmazza. Ha egy sor mindkét szót tartalmazza, akkor kétszer lesz kinyomtatva, mindegyik szabály által egyszer.

Ha a fenti programot a két mintafile-lal (`BBS-list' és `inventory-shipped') futtatjuk, akkor az alábbi eredményt kapjuk:

$ awk '/12/ { print $0 }
>      /21/ { print $0 }' BBS-list inventory-shipped
-| aardvark     555-5553     1200/300          B
-| alpo-net     555-3412     2400/1200/300     A
-| barfly       555-7685     1200/300          A
-| bites        555-1675     2400/1200/300     A
-| core         555-2912     1200/300          C
-| fooey        555-1234     2400/1200/300     B
-| foot         555-6699     1200/300          B
-| macfoo       555-6480     1200/300          A
-| sdace        555-3430     2400/1200/300     A
-| sabafoo      555-2127     1200/300          C
-| sabafoo      555-2127     1200/300          C
-| Jan  21  36  64 620
-| Apr  21  70  74 514

Érdemes megfigyelni, hogy a `sabafoo' kezdetű sor a `BBS-list' file-ból kétszer lett kinyomtatva, mindegyik szabály kinyomtatta egyszer.

Egy bonyolultabb példa

A következô példa talán jobban bemutatja, hogy az awk mire is képes, úgy mint összegzésre, kiválasztásra és egy másik segédprogram kimenetének újrarendezésére. A példa tartalmaz olyan programozási megoldásokat, amiket eddig nem tárgyaltunk, így ne aggódj, ha nem érted minden részletét.

ls -lg | awk '$6 == "Nov" { sum += $5 }
             END { print sum }'

A parancs kinyomtatja az adott könyvtárban levô és legutoljára novemberben (bármely év) módosított file-ok összegzett méretét byte-ban. (Ha C shell-t használsz, akkor az elsô sor végén `;\' -t kell begépelni; a POSIX szabvánnyal kompatíbilis shell-ek esetén, mint a Bourne shell vagy a GNU Bourne-Again shell, a példát begépelheted, ahogy fent látod.)

Az `ls -lg' része a példának egy rendszerparancs, ami kilistázza a file-okat a könyvtárban, a file méretét és az utolsó módosítás dátumát. Az eredmény így néz ki:

-rw-r--r--  1 arnold   user   1933 Nov  7 13:05 Makefile
-rw-r--r--  1 arnold   user  10809 Nov  7 13:03 gawk.h
-rw-r--r--  1 arnold   user    983 Apr 13 12:14 gawk.tab.h
-rw-r--r--  1 arnold   user  31869 Jun 15 12:20 gawk.y
-rw-r--r--  1 arnold   user  22414 Nov  7 13:03 gawk1.c
-rw-r--r--  1 arnold   user  37455 Nov  7 13:03 gawk2.c
-rw-r--r--  1 arnold   user  27511 Dec  9 13:07 gawk3.c
-rw-r--r--  1 arnold   user   7989 Nov  7 13:03 gawk4.c

Az elsô mezô tartalmazza az olvasási-írási jogokat, a második a link-ek számát a file-ra. A harmadik mezô adja meg a file tulajdonosának azonosítóját. A negyedik mezô azonosítja a csoportot, míg az ötödik mezô tartalmazza a file méretét byte-okban. A hatodik, hetedik és nyolcadik mezô az utolsó módosítás hónapját, napját és óráját adja meg. Végül a kilencedik mezô a file neve.

A `$6 == "Nov"' kifejezés az awk programban egy ellenôrzés, hogy az `ls -lg' kimenetében a hatodik mezô megegyezik-e a `Nov' szóval. Minden olyan sorra, aminél a hatodik mezô megegyezik a `Nov' szóval, a `sum += $5' tevékenység hajtódik végre. Ez hozzáadja az ötödik mezô tartalmát a sum változóhoz. Miután az awk befejezte a bemenet olvasását, a sum változó fogja tartalmazni azon file-ok méretének összegét, amelyeknél illeszkedést talált. (Ez azért fog működni, mert minden awk változó automatikusan zérus értéket kap kezdetben.)

Az ls-bôl származó utolsó sor beolvasása után az END szabály hajtódik végre és az awk kinyomtatja a sum változó értékét. Ebben a példában a sum változó értéke 80600 lesz.

További bonyolult awk programozási technikákat mutatunk be a késôbbi fejezetekben (see section Tevékenységek áttekintése), de mielôtt továbblépnél, fontos megérteni, hogy az awk hogyan dolgozza fel a bemenetet, és jeleníti meg az eredményt. A mezôk manipulálásával és a print paranccsal több hasznos és meggyôzô jelentést, összefoglalót készíthetsz.

awk kifejezések és sorok

Általában egy sor egy kifejezést vagy szabályt tartalmaz az awk programokban, például:

awk '/12/  { print $0 }
     /21/  { print $0 }' BBS-list inventory-shipped

Ugyanakkor a gawk nem veszi figyelembe az új sort az alábbi jelek után:

,    {    ?    :    ||    &&    do    else

Az új sor bármely más esetben egy kifejezés végét jelenti. (Egy új sor kezdésének lehetôsége a kérdôjel és a kettôspont után anélkül, hogy új kifejezés kezdôdne, egy gawk kiegeszítés. A kérdôjel és a kettôspont, mint egy feltételes kifejezés jelennek itt meg, amit a section Feltételes kifejezések fejezetben magyarázunk el.)

Ha egy kifejezést két sorban szeretnél leírni, és egy olyan pontnál új sort kezdeni, ahol alapesetben a kifejezés végét jelentené az új sor, akkor az elsô sor végére egy `\' jelet kell írni. A `\' jel legyen az utolsó a sorban. Ez a módszer bárhol megengedett, akár egy kifejezésben, egy szöveg közepén vagy egy reguláris kifejezésben. Például:

awk '/Ez a reguláris kifejezés túl hosszú, ezért\
 ebben sorban folytatjuk./ { print $1 }'

A könyvben bemutatott példákban általában nem használjuk ezt a lehetôséget, mivel a gawk-ban a sor hossza nem limitált; egyszerűen a programokat teheti olvashatóbbá. Ugyanezen oknál fogva, és az érthetôség kedvéért a példaprogramokban csak rövid kifejezéseket használtunk. A `\' jel használata talán a leghasznosabb, ha az awk programodat egy külön file-ban tárolod, és nem parancsként gépeled be. Fontos megjegyezni, hogy sok awk implementáció érzékeny arra, hogy hol használjuk a `\' jelet. Például nem engedélyezett a szövegek két sorba vágása a `\' jellel bizonyos awk implementációkban. Ha különbözô awk implementációkkal is szeretnéd a programodat futtatni, a legegyszerűbb ha a szövegeket és reguláris kifejezéseket nem vágod szét a `\' jellel.

Figyelem: a `\' jel fent leírt használata nem fog működni C shell-el. A módszer csak külön file-be írt programok és a POSIX szabvánnyal kompatíbilis shell-ek, a Bourne shell vagy a Bash, esetén működik. De a C shell (csh) másképp viselkedik. A C shell esetén két `\' jelet kell használni a sor szétvágásárá, ráadásul a C shell-ben minden sort egy `\' jellel kell lezárni, hogy a következô sorban folytatható legyen. Tehát:

% awk 'BEGIN { \
?   print \\
?       "hello, world" \
? }'
-| hello, world

Itt a `%' és a `?' jelek a C shell elsôdleges és másodlagos "prompt"-jai, mint a `$' és a `>' jelek a szabványos shell-ek esetén.

Az awk egy sor orientált programozási nyelv. Minden szabály tevékenység részének ugyanabban a sorban kell kezdôdnie, mint a keresési minta. Ahhoz, hogy a tevékenység és a minta külön sorba kerülhessen a `\' jelet kell használni a fent leírt módon -- ez az egyetlen megoldási lehetôség erre.

Fontos megjegyezni, hogy a `\' jel használata és a megjegyzések nem keverhetôk. Amint egy `#' jelet beolvas az awk minden további karaktert eldob a sorban. Például:

$ gawk 'BEGIN { print "dont panic" # a friendly \
>                                    BEGIN rule
> }'
error--> gawk: cmd. line:2:                BEGIN rule
error--> gawk: cmd. line:2:                ^ parse error

Itt úgy tűnik, mintha a `\' jel megengedné a megjegyzés folytatását a következô sorban, de a `\' jelet az awk soha nem veszi észre, mert az a megjegyzésben "el van rejtve". Így a `BEGIN' kifejezés egy hibát generál.

Ha egy kifejezés egy szabályon belül nagyon rövid, lehetôség van további kifejezéseknek ugyanabba a sorba helyezésére. Ezeket a kifejezéseket a `;' jellel kell elválasztani egymástól.

Ez természetesen igaz a szabályokra is, így a fenti program az alábbi formában is helyes:

/12/ { print $0 } ; /21/ { print $0 }

Megjegyzés: az egy sorba kerülô szabályok `;' jellel való elválasztása nem része az eredeti awk nyelvnek; a kifejezések egységes kezelése érdekében került bevezetésre.

Egyéb awk sajátosságok

Az awk programozási nyelv számos olyan elôre definiált vagy beépített változó elérését biztosítja, amelyek valamilyen extra információt nyújtanak a programnak. Más változók segítségével a program befolyásolhatja az awk működését.

Ráadásul, az egyszerű számítások és szöveges műveletek elvégzésére számos beépített függvény áll rendelkezésre az awk-ban.

A könyv során fokozatosan mutatjuk be a beépített változókat és függvényeket. A szisztematikus definíciójukat két fejezetben találhatod meg: section Beépített változók, section Beépített függvények.

Mikor használjunk awk-ot

Talán elgondolgoztál már azon, hogy hogyan is lehet az awk hasznos számodra. Az egyik válasz, hogy okosan megtervezett mintákkal, mezôelválasztó jelekkel, matematikai kifejezésekkel és más kiválasztási kritériumokkal bonyolult összefoglalásokat, jelentéseket tudsz készíteni. Az awk nyelv nagyon hasznos lehet nagy mennyiségű nyers adat feldolgozására, például más segédprogramok kimenetének összegzésére (see section Egy bonyolultabb példa).

Az awk-ban írt programok általában kisebbek, mint más programozási nyelven írt programok. Ezért egyszerű az awk programok írása és használata. Gyakran a leggyorsabb módszer, egyszerűen csak leülni a terminálhoz és megírni az awk programot, majd a használat után egyszerűen eldobni. Mivel az awk programok interpretáltak (egy értelmezô dolgozza fel és hajtja végre), elkerülhetô a fordítási rész a tipikus szerkesztés-fordítás-tesztelés-hibakeresés software fejlesztési ciklusból.

Több bonyolult programot írtak már awk-ban, mint például egy teljes assemblert 8 bites mikroprocesszorokra (további részletek a see section Glossary) és egy microcode assemblert speciális Prolog számítógépek számára. Ugyanakkor ezek az alkalmazások már megmutatják az awk korlátait is.

Ha, mondjuk, néhány száz sorból álló programokat írsz awk-ban, akkor érdemes megfontolni egy másik programozási nyelv használatát. Az Emacs Lisp egy jó választás ha bonyolult szöveg és minta illesztéseket kell csinálni. A shell is alkalmas erre, ráadásul más rendszer segédprogramok is elérhetôk. A C, C++ és Lisp programozási nyelvek szintén jó környezetet biztosítanak rendszer programozáshoz és nagyobb munkák kivitelezéséhez. Az ezen a nyelveken írt programok általában hosszabbak, mint az awk változataik, de egyszerűbb ôket karbantartani, és általában gyorsabbak.

Go to the first, previous, next, last section, table of contents.