Opis języka AWK

Dla AWK dane wejściowe składają się z rekordów, które rozdzielone są separatorami RS. Standardowo rekordem jest cały wiersz, czyli separatorem jest znak końca wiersza.

Rekordy podzielone są na pola, które rozdzielone są separatorami pól FS. Domyślnie separatorami pól są odstępy, tj. znaki spacji i/lub tabulacji. Poniżej zamieszczono zawartość pliku wina.txt, którego każdy wiersz zawiera: nazwę wina, symbol kraju-producenta, kolor, smak, cenę w złotych oraz liczbę butelek sprzedanych, na przykład w ostatnim miesiącu:

Ponieważ nazwa wina składa się z wielu wyrazów, liczba pól w poszczególnych rekordach jest zmienna, np. pierwszy wiersz zawiera 7 pól, drugi 9 pól, trzeci 8 pól, itd. RS i FS są zmiennymi, a więc można im nadać wartość. Przykładowo, jeśli zmiennej FS nadamy wartość `;', to separatorami pól będą znaki `;' a nie spacje i tabulatory. Wartością zmiennej FS może być dowolne wyrażenie regularne.

W akcjach i wzorcach do wartości pól można się odwoływać za pomocą zmiennych postaci $nr-pola. Tak więc $1 to pierwsze pole rekordu, $2 drugie itd. $0 oznacza cały rekord. Wbudowana zmienna NF przechowywuje liczbę pól bieżącego rekordu, stąd $NF to zmienna zawierająca zawartość ostatniego pola (w każdym rekordzie).

Przykładowo w pliku wina.txt zmienna $NF zawiera wielkość sprzedaży każdego gatunku wina. Dla pierwszego z win $1 zawiera napis "Chardonnay" a $2 napis "Lyngrove". Dla drugiego wiersza wartością $1 będzie "Cabernet" itd. Ponieważ liczba wyrazów w nazwie wina jest nieustalona, wydawać by się mogło, że dotarcie do odpowiednich informacji w każdym wierszu może być skomplikowane, ale tak nie jest, bo pola można także liczyć od końca. Zapis $(NF-1) oznacza pole przedostatnie, $(NF-2) drugie od końca itd. Nawiasy okrągłe są tutaj obowiązkowe, a ich brak zmienia znaczenie takiej konstrukcji, więcej szczegółów jest w punkcie „Zmienne przechowujące zawartości pól”.

Plik wina.txt był jednorodny w tym sensie, że każdy rekord (wiersz) zawierał informację o jednym gatunku wina. Często można mieć do czynienia z plikami, które zawierają różne rekordy, np. poniżej przedstawiono plik tdf2000.txt zawierający zestawienie wszystkich podjazdów o nachyleniu większym od 5% na alpejskich etapach wyścigu Tour de France '2000:

W tym przypadku w pliku znajdują się następujące grupy rekordów: nagłówek (wiersze 1--3), określające etap, zawierające dane o każdej górze (nazwa, dystans od startu w kilometrach, wysokość w metrach n.p.m. podnóża i szczytu, różnica poziomów oraz długość podjazdu w kilometrach) i puste wiersze separujące.

Do plików wina.txt oraz tdf2000.txt będziemy często wracać w przykładach zamieszczonych w dalszej części tekstu.

Za pomocą mechanizmu znaków #! umieszczonych jako dwa pierwsze znaki w pliku możliwe jest uruchamianie programów AWK-owych, tak jakby były programami wykonywalnymi (w systemach uniksowych, nie w DOS/MS Windows!). Jeżeli przykładowo umieścimy w pliku pr10 następujący kod:

#!/usr/bin/awk -f
NR <= 10

to, po nadaniu plikowi prawa do wykonywania (za pomocą chmod), możemy uruchamiać program pisząc po prostu: pr10 plik. (Program drukuje pierwsze 10 wierszy pliku.)

Wzorzec BEGIN nie pasuje do żadnego wiersza z pliku wejściowego, a odpowiadająca mu akcja jest wykonywana przed przeczytaniem przez AWK pierwszego znaku z tego pliku. Podobnie instrukcje wzorca END wykonywane są po przeczytaniu wszystkich znaków pliku wejściowego. Możliwe jest umieszczenie wielu wzorców BEGIN i END w programie AWK-owym; są one wtedy wykonywane po kolei. Zwyczajowo wzorce BEGIN są umieszczane na początku a END na końcu pliku.

Jednym z najczęstszych sposobów użycia BEGIN jest zmiana domyślnego sposobu w jaki AWK dzieli wiersze z czytanego pliku na pola. Wbudowana zmienna FS definiuje napis-separator pól w rekordzie. Domyślnie pola oddzielone są znakami spacji lub/i tabulacji (FS=" "). Przy uruchomieniu programu zawierającego tylko wzorce BEGIN AWK nie oczekuje w linii poleceń nazwy żadnego pliku wejściowego, por. przykład 17 (Wyświetlanie dużych plików).

Wzorcami mogą być wyrażenia arytmetyczne lub napisowe. Odpowiednia akcja jest wykonywana za każdym razem gdy takie wyrażenie ma wartość różną od zera lub od napisu pustego. Przykładowo:

$(NF-4) == "Fra" { print $0 } # Wydrukuj wina francuskie

w powyższym wierszu, który jest kompletnym programem AWK-owym, wyrażeniem we wzorcu jest porównanie czwartego pola od końca wiersza z napisem "Fra". Jeżeli napisy są identyczne to wartością wyrażenia jest prawda i AWK wykonuje akcję -- drukuje cały wiersz. Zgodnie z tym co już powiedziano, tego typu akcja jest wykonywana domyśnie -- jeżeli nie podano innej, zatem program można zapisać jeszcze krócej:

$(NF-4) == "Fra" # Wydrukuj wina francuskie

Przykładem wzorca zawierającego wyrażenie arytmetyczne może być wydrukowanie tych gatunków win, na których obrót był większy od 10 tys. zł:

$NF * $(NF-1) > 10000 # Wydrukuj najczęściej kupowane

Wzorzec regularny to wyrażenie regularne ujęte w parę znaków /. Podstawowe sposoby użycia wzorca regularnego to:

Wyrażenia regularne mogą być pomocne w rozwiązaniu problemu wydrukowania win wytrawnych i półwytrawnych:

$(NF-2) ~ /wytrawne/ # wydrukuj coś wytrawnego

AWK wydrukuje każdy wiersz, którego trzecie od końca pole zawiera napis wytrawne. W tym przykładzie zysk jest niewielki, zamiast $(NF-2) ~/wytrawne/ można zapisać:

$(NF-2) == "wytrawne" # wydrukuj wytrawne
$(NF-2) == "półwytrawne" # ... i półwytrawne

ale w ogólnym przypadku wyrażenia regularne potrafią znakomicie ułatwić pracę.

Wzorzec złożony to wyrażenie złożone z wzorców i operatorów logicznych ||, &&, !. Wzorzec złożony pasuje do bieżącego wiersza z pliku wejściowego jeżeli wartością wyrażenia jest prawda (czyli jest niezerowa lub niepusta). Poniższy przykład:

$(NF-2) == "wytrawne" || $(NF-2) == "półwytrawne" # coś wytrawnego

pokazuje wzorzec złożony i jednocześnie potwierdza, że najlepiej do rozwiązania problemu drukowania win wytrawnych korzystać z wyrażeń regularnych.

Inny przykład wzorca złożonego pozwoli nam rozwiązać problem wydrukowania win francuskich, na których obrót był większy od 10 tys. zł:

$(NF-4) == "Fra" && $(NF-1) * $NF > 10000

Pasuje do wszystkich wierszy, od wiersza pasującego do wzorca1 do wiersza pasującego do wzorca2 (łącznie z tymi wierszami). Jeżeli w pliku po raz kolejny pojawi się wzorzec1, to znowu pasują wszystkie wiersze aż do napotkania wzorca2. Jeżeli AWK nie znajdzie wzorca2, to pasują wszystkie wiersze aż do końca pliku. Jeżeli w pliku nie ma wzorca1, to nie pasuje żaden wiersz z tego pliku. Przykładowo wykonanie poniższego programu spowoduje wydrukowanie wierszy o numerach od 4 do 14 z pliku tdf2000.txt:

$3 ~ /Briancon/, $3 ~ /Morzine/

Jeżeli wykonamy następujący program:

$3 ~ /Draguignan/, $3 ~ /Briancon/

to powstaje pytanie czy na wydruku otrzymamy tylko jeden wiersz (zawiera "Draguignan" i jednocześnie zawiera "Briancon") czy też sześć wierszy (od 4 do 9; dziewiąty też zawiera słowo "Briancon") z pliku tdf2000.txt? Otóż AWK po sprawdzeniu, że wiersz pasuje do wzorca1 sprawdza ten sam wiersz, czy aby nie pasuje on do wzorca2, co powoduje, że w takim wypadku drukowany jest tylko ten wiersz. Gdyby AWK działał tak jak program sed, tj. po dopasowaniu wiersza do wzorca1, dopasowywał wzorzec2 do następnego i kolejnych wierszy wtedy na wydruku pojawiłoby się 6 wierszy.

Zwykle wyrażenia regularne zapisywane są jako ciągi znaków umieszczone pomiędzy znakami ciachów. Możliwe jest też używanie napisów jako wyrażeń regularnych. Wszędzie tam gdzie AWK oczekuje pojawienia się wyrażenia regularnego (jak, np. po prawej stronie operatorów ~ i !~) umieszczone tam wyrażenie zostanie przekształcone a następnie zamienione na napis, który będzie interpretowany jako wyrażenie regularne. Przykładowo, poniższy program:

BEGIN {cyfry="^[0-9]+$" }; $0 ~cyfry 

wydrukuje wszystkie wiersze, które zawierają wyłącznie liczbę całkowitą (bez znaku).

Ponieważ wyrażenia napisowe mogą być łączone (por. punkt „Operatory napisowe”), wyrażenie regularne może być konstruowane dynamicznie z części składowych. Przykładowo poniższy program:

BEGIN {znak ="[-+]?"; cyfra="[0-9]+"; liczba = "^" znak cyfra "$"}
$0 ~ liczba

może służyć do wydrukowane wszystkich wierszy z pliku, które zawierają wyłącznie liczbę całkowitą ze znakiem:

$0 ~ /^\\*[0-9]+\\*$/

W AWK istnieją tylko dwa typy danych: liczbowy i napisowy. Stałe liczbowe zapisujemy jak w C, tj. 3.1415 lub 1.333e-5, stałe napisowe otacza się znakami ". Stałe napisowe mogą zawierać znaki sterujące takie jak \n czy \f.

W składni AWK wyróżniamy zmienne: wbudowane, zdefiniowane przez użytkownika i przechowujące zawartości pól. Nazwy zmiennych definiowanych przez użytkownika mogą składać się z liter, cyfr i znaku podkreślenia. Pierwszym znakiem nazwy nie może być cyfra. Nazwy zmiennych wbudowanych składają się wyłącznie z dużych liter alfabetu. Nazwy zmiennych przechowujących zawartości pól zaczynają się od znaku $, po którym występuje liczba (ogólnie: wyrażenie).

Zmienne liczbowe przechowują wartości zmiennopozycyjne, przy czym ich dokładność zależna jest od implementacji. Zmienne napisowe przechowują ciągi znaków (napisy). Zmiennych nie deklaruje się. Typ zmiennej określony jest przez kontekst; w razie potrzeby zawsze dokonywana jest odpowiednia konwersja. Zmienna nie zainicjowana ma wartość zero lub "" (napis pusty).

Interpretacja wyrażeń numerycznych i tekstowych w operacjach logicznych jest następująca: fałsz odpowiada liczbie 0 i napisowi pustemu "", zaś prawda odpowiada wszystkim innym liczbom i napisom.

Zmienne wbudowane są dokładnie opisane przy okazji omawiania tych aspektów AWK, których dotyczą:

ENVIRON jest tablicą zawierającą wartości zmiennych środowiskowych przy czym indeksami są nazwy zmiennych. Przykładowo:

gawk 'BEGIN {print ENVIRON["HOME"] }'

zawiera np. /home/tomek.

ERRNO zawiera napis z systemowym komunikatem o błędzie, jeżeli przy wykonaniu funkcji getline lub close wystąpi błąd.

IGNORECASE określa czy AWK rozróżnia duże i małe litery przy porównywaniu napisów i wyrażeń regularnych. Jeżeli IGNORECASE jest niezerowe lub niepuste, wtedy operatory ~, !~ i funkcje gensub, gsub, index, match, split oraz sub nie rozróżniają dużych i małych liter. Dotyczy to także wartości zmiennych RS i FS. Począwszy od wersji 3.0, gawk obsługuje normę ISO-8859-1 (Latin-1). Standard ten nie zawiera jednak większości polskich znaków diakrytycznych.

ARGIND przechowuje indeks, pod którym w tablicy ARGV znajduje się nazwa przeglądanego pliku. Zawsze jest prawdziwa równość FILENAME == ARGV[ARGIND].

Zmienna FILENAME zawiera nazwę bieżącego pliku wejściowego. Oznacza to, że w obrębie wzorców BEGIN i END wartość FILENAME jest nieokreślona.

Zmienne przechowujące zawartości pól mogą być wykorzystane wewnątrz wyrażeń, można także im nadawać wartości. Jeżeli wartość zmiennej $0 została zmodyfikowana przez podstawienie lub zamianę (np. funkcją sub) to wartości zmiennych $1, $2, ... oraz zmiennej NF są powtórnie wyznaczane. Podobnie jeżeli zmodyfikowano którąkolwiek ze zmiennych $1, $2, ..., wtedy wartość zmiennej $0 jest odtwarzana (przy wykorzystaniu wartości zmiennej OFS jako separatora pól).

Numery pól mogą być wyznaczane jako wartości wyrażeń. Przykładowo $(NF-1) oznacza przedostatnie pole w bieżącym rekordzie (nawiasy są istotne, ponieważ $NF-1 oznacza wartość pola $NF pomniejszoną o 1). Możliwe jest także przypisanie wartości zmiennym odpowiadającym polom nie istniejącym w czytanym pliku. W takim wypadku pole zostanie utworzone i przypisana zostanie odpowiednia wartość. Odwołanie się do pola o numerze ujemnym jest błędem kończącym działanie programu.

Poniższa tabela zawiera zestawienie wszystkich operatorów arytmetycznych.

Operator modulo to reszta z dzielenia całkowitego, tj. 5.1 % 3 == 2.1 ma wartość prawda.

Napisy i zmienne napisowe można łączyć (konkatenować) przy pomocy ,,niewidocznego'' operatora -- po prostu należy umieścić napisy obok siebie. Przykładowo po wykonaniu:

y = "Ali"; z = "gator"; x1 = y "ba" "ba"; x2=  y z;

zmienna x1 ma wartość ,,Alibaba''; zmienna x2 ma wartość ,,Aligator''. Oprócz operacji konkatenacji AWK nie ma żadnych innych operatorów napisowych.

Zapis i działanie operatorów w AWK w wypadku zmiennych typu liczbowego jest identyczny jak w języku C. Nowością AWK jest to, że mogą być także stosowane do napisów.

Napisy są porównywane według kodów ASCII w taki sposób, że najpierw porównywane są pierwsze znaki, potem drugie itd. Przykładowo: "10" jest mniejsze od "9". Jeżeli jeden napis jest przedrostkiem drugiego to krótszy napis jest mniejszy od dłuższego, np. "Ali" jest mniejsze od "Alibaba".

function leapyear(year) {
   return year %4 == 0 && year % 100 \
   != 0 || year%400 ==0; }

BEGIN {print leapyear(1996), leapyear(1806),
   leapyear(1066)}

W składni AWK są dwa takie operatory ~ oraz !~. Umożliwają one dopasowanie zmiennej do wyrażenia regularnego. Przykładowo $1 ~/Chardonnay/ jest prawdziwe, gdy pierwsze pole zawiera napis Chardonnay. Samotnie pojawiające się wyrażenie /Chardonnay/ jest równoważne $0 ~ /Chardonnay/. Operator !~ pasuje do dopełnienia wyrażenia regularnego, tj. $1 !~/Chardonnay/ jest prawdziwe gdy $1 nie zawiera napisu Chardonnay.

Przypisanie oznaczane jest w AWK pojedynczym znakiem równości =. Podobnie jak w języku C operator ten nadaje zmiennej wartość i zwraca przypisaną wartość, stąd dozwolone są wyrażenia postaci x = y = 1 lub (x = y) <= 1.

Z operatorem przypisania związane są operatory modyfikacji: +=, -=, *=, /=, %=, /= i ^=. Przykładowo wyrażenie x += y jest tożsame z x = x + y, wyrażenie x -= y jest tożsame z x = x - y itd.

#!/usr/bin/awk -f
{obrot = $NF * $(NF-1); oo += obrot }
$(NF - 3) ~ /białe/ {biale += obrot } 
$(NF - 3) ~ /czerwone/ {czerwone += obrot } 
END { print "Obrót razem:", oo ", w tym: czerwone:", 
      czerwone ", białe:", biale "."; } 

Operator warunkowy ?: posiada następującą składnię:

wyrażenie1 ? wyrażenie2 : wyrażenie3

Najpierw obliczane jest wyrażenie1. Jeśli jest ono prawdziwe obliczane jest wyrażenie2, w przeciwnym wypadku wyrażenie3.

Poniższy program oblicza i drukuje odwrotność pierwszych pól wszystkich rekordów, sprawdzając czy $1 nie jest równe zeru:

{print $1!=0 ? 1/$1 : "Zero w wierszu", NR;}

Jeśli w wierszu programu AWK-owego umieścimy samotny znak `;', to otrzymamy instrukcję pustą. Spójrzmy na poniższy program wykorzystujący taką instrukcję w pętli for; program drukuje wszystkie wiersze, które zawierają puste pole.

BEGIN { FS = "\t" } # Pola oddziela znak tabulacji!
{ for (i=1; i <= NF && $i!=""; i++)
   ;
  if (i <= NF) { print }
}

Element tablicy możemy usunąć za pomocą instrukcji delete:

delete tablica[indeks]

przykładowo delete ls["Alibaba"] usuwa z tablicy ls element odpowiadający indeksowi "Alibaba".

{ obrot[$(NF-2)] += $NF * $(NF-1) }
END { for (wino in obrot) { print wino, obrot[wino] }}

Tablice wielowymiarowe są symulowane przez AWK za pomocą tablic jednowymiarowych. Z punktu widzenia użytkownika nie ma to wielkiego znaczenia. Przykładowo w wyniku działania poniższego fragmentu programu:

for (i=1; i <= 10; i++)
   for (j=1; j <= 10; j++)
      r[i,j] = rand();

zostanie utworzona tablica 100 elementów, do których możemy się odwoływać za pomocą par zmiennych indeksowanych postaci i,j. Wewnętrznie jednakże poszczególne elementy tablic są indeksowane za pomocą napisów postacji i SUBSEP j. Zmienna wbudowana SUBSEP przechowuje znak używany do oddzielenia indeksów składowych; standardową wartością tej zmiennej nie jest przecinek ale znak "\034". Sposób testowania czy element i,j należy do tablicy nie zmienia się:

for ((i,j) in r) {...}

zaś w wypadku pętli for piszemy:

for (k in r) {print r[k]}

i, jeżeli jest to potrzebne, wykorzystujemy konstrukcję split(k,x,SUBSEP) do dostępu do wartości zmiennych indeksowych.

{  o = $NF * $(NF-1); # obliczamy obrót 
   smaki[$(NF-2)] += o; # obrót wg. smaków
   kolory[$(NF-3)] += o; # obrót wg. kolorów
   obrot[$(NF-2), $(NF-3)] += o # obrót wg. smaków i kolorów
}
END { for (smak in smaki) {
         print smak, "...", smaki[smak]; 
         razem +=smaki[smak]; 
         for (kolor in kolory) {
              if ((smak, kolor) in obrot)
                print "--", kolor, "...", obrot[smak, kolor];
       } }
    print "Razem ...", razem;
}

Standardową wartością wbudowanej zmiennej FS jest " " (spacja -- odstęp). W takiej sytuacji poszczególne pola są rozdzielone odstępami lub znakami tabulacji. Sposób rozdzielania pól można zmienić przypisując zmiennej FS odpowiedni napis. Jeżeli napis ten jest dłuższy niż jeden znak, to AWK traktuje go jako wyrażenie regularne. Najdłuższe (leftmost longest) ciągi znaków, nie zachodzące na siebie (non overlapping), pasujące do tego wyrażenia regularnego będą oddzielać poszczególne pola w bieżącym wierszu. Przykładowo deklaracja:

BEGIN {FS ="[,;:]"}

powoduje, że pola będą rozdzielane przecinkiem, średnikiem lub dwukropkiem. Kiedy wartością FS jest pojedynczy znak (inny od odstępu), to ten znak jest używany do rozdzielania pól.

awk -F'[,;:]' -f program plik

Wartość zmiennej RS przechowuje napis używany przez AWK do oddzielania poszczególnych rekordów. Standardowo rekordy są oddzielane znakami końca wiersza (co odpowiada przypisaniu RS="\n"). W ograniczonym zakresie możemy zmienić sposób w jaki AWK wyróżnia poszczególne rekordy nadając odpowiednią wartość zmiennej RS. W opisie [AhoetAll] separatorem rekordu może być tylko napis jednoznakowy lub napis pusty. Jeżeli RS="" (napis pusty), wtedy separatorami rekordów są puste wiersze (jeden lub więcej).

BEGIN {RS=""; ORS="\n\n" }; /Aleja Zwycięstwa/

W niektórych implementacjach AWK separator rekordu może być wyrażeniem regularnym. W takiej sytuacji, każdy napis pasujący do tego wyrażenia wyznacza koniec kolejnego rekordu (z tym, że napis ten nie jest częścią tego rekordu, podobnie jak w wypadku gdy separatorem jest pojedynczy znak).

Jeżeli RS jest wyrażeniem regularnym wtedy zmienna RT przechowuje dla bieżącego rekordu, napis będący jego separatorem od rekordu następnego.

function usage() {
   print "awksed co naco pliki..." > "/dev/stderr"
   exit 1 }

BEGIN {   # sprawdź argumenty wywołania
   if (ARGC < 3) { usage() }
   RS = ARGV[1]; ORS = ARGV[2]

   # nie używaj argumentów jako nazw plików
   ARGV[1] = ARGV[2] = ""
}
{  if (RT == ""){ printf "%s", $0 }
   else { print } }

#!/bin/bash
cat $3 | awk -vCO=$1 -vCOCO=$2 '
BEGIN {FS="\t" } # Pierwsze pole od reszty oddziela tabulator
NF > 0 {dane[$1] = $2 }
NF < 1 && dane[CO] ~ COCO { drukuj(); usun() }
END { if (dane[CO]~ COCO) {drukuj() }} # ostatni rekord!
function usun(i){ for (i in dane) {delete dane[i] } }
function drukuj(){ print dane["kto"]; print dane["tel"] }'

Polecenie getline umożliwia czytanie danych z bieżącego lub/i z innego pliku tekstowego albo z potoku generowanego przez inny program. Poniżej zestawiono różne formy użycia getline (plik i program to zmienna lub stała napisowa zawierająca odpowiednio nazwę pliku lub programu, z którego AWK ma czytać strumień danych).

Dwie pierwsze formy dotyczą czytania danych z bieżącego pliku, dwie następne z pliku. Dwie ostatnie to wczytywanie danych ze strumienia generowanego przez inny program. Polecenie getline zwraca wartość 1 jeżeli wczytany został następny wiersz tekstu (rekord), 0 jeżeli napotkano koniec pliku (strumienia) danych oraz -1 w wypadku napotkania błędu (np. otwarcia pliku). Jeżeli po słowie getline występuje zmienna z to wczytany wiersz jest dostępny jako wartość tej zmiennej, w innym wypadku jest dostępny jako wartość zmiennej $0. Przykładowo pętla:

while (getline < plik > 0) {...}

Jest ,,tradycyjną'' techniką umożliwiającą przejrzenie całego pliku. Poszczególne wiersze dostępne są w każdej iteracji pętli jako wartości zmiennej $0.

Podobnie wygląda czytanie danych z potoku. Przykładowo chcąc przekazać do AWK zawartość bieżącego katalogu możemy się posłużyć następującą pętlą:

while ("ls -l" | getline > 0) {...}

Pliki i potoki otwarte przez AWK są automatycznie zamykane z chwilą zakończenia działania programu. Jeżeli jednak musimy przeglądać wielokrotnie zawartość jakiegoś pliku w obrębie jednego programu AWK-owego to za każdym razem należy zamknąć czytany plik używając funkcji close, np.:

close (plik); close("ls -lrt")

BEGIN { niema = 1; DUZY = 1000000
   while ("ls -l" | getline)
      if (NF == 9  && $5 > DUZY) {print $0; niema =0 }
   if (niema) {print "Nie ma plików większych od", DUZY; }
}

function getdate(x, date) {
   "date" | getline x;  split(x, date, " ");
   DAT["year"]= date[6]; DAT["mon"]= date[2]; DAT["day"]= date[3];
   return;
}
# Przykład wykorzystania funkcji getdate:
BEGIN {getdate(); print DAT["mon"], DAT["day"] }

Rekord może być także dzielony na pola o ustalonej długości. W tym celu zmiennej wbudowanej FIELDWIDTHS przypisujemy napis zawierający ciąg oddzielonych odstępami liczb. Każda liczba oznacza długość odpowiedniego pola w znakach. Jeżeli wartością zmiennej FIELDWIDTHS nie jest napis pusty, pola wyznaczane są w oparciu o specyfikację podaną w tej zmiennej, a nie w oparciu wartość separatora pól (czyli zmienną FS). Przypisanie wartości zmiennej FS (np. FS=FS) przywraca standardowy sposób wyznaczania pól.

# Drukuj nazwę góry i jej długość
BEGIN  { FIELDWIDTHS = "1 25 5 5 4 3 4 4 4 4 4" }
NR==1, /^-+[ \t]*$/ { next }
/^Etap[ \t]+[0-9]+:/ { next }
NF > 0 { print $2, $11 }

Składnia instrukcji printf jest niemalże identyczna z odpowiednią funkcją języka C. Ogólna postać tej instrukcji jest następująca:

printf (format, arg1,arg2,...)

Nawiasy ( oraz ) są opcjonalne. Napis lub zmienna napisowa format określa sposób przekształcania i formatowania argumentów. Zawiera on dwa rodzaje obiektów: zwykłe znaki, kopiowane po prostu przy drukowaniu oraz specyfikacje przekształceń, z których każda określa sposób przekształcenia i wypisania kolejnego argumentu funkcji printf. Specyfikacja ta rozpoczyna się od znaku % a kończy znakiem określającym typ konwersji. Pomiędzy nimi możemy użyć ponadto następujących znaków modyfikujących:

Oto lista znaków przekształceń i ich znaczenie (zapis [-] oznacza, że znak - jest opcjonalny):

Jeżeli znak występujący po % nie jest znakiem przekształcenia to jest on po prostu wypisany; zatem %% spowoduje wypisanie znaku %.

Poniższe zestawienie ilustruje działanie różnych specyfikacji. Aby można ocenić długości pól otoczono je znakami |, zaś spacje oznaczono znakiem _.

Instrukcja print jest uproszczoną formą printf a jej działanie jest następujące: drukowane argumenty są oddzielane wartością zmiennej wbudowanej OFS (standardowo OFS=" " -- argumenty oddzielone są znakiem odstępu) a na końcu listy jest drukowana wartość zmiennej wbudowanej ORS (standardowo ORS="\n" -- każde kolejne print drukuje od nowego wiersza). Wszystkie argumenty numeryczne są drukowane w oparciu o tę samą specyfikację, określoną poprzez wartość zmiennej OFMT (standardowo OFMT="%.6g"). Stąd, uruchamiając poniższy przykład:

awk 'BEGIN {OFS=":";ORS="->"; print log(2), log(3); print log(5); }'

otrzymamy:

0.693147:1.09861->1.60944->

Zamiast na ekran (standardowe wyjście) instrukcje printf/print mogą przesłać dane do pliku. Służą do tego operatory > oraz >>, zaś instrukcje mają wówczas postać:

printf format, arg1,... > plik
print arg1,... > plik

lub

printf format, arg1,... >> plik
print arg1,... >> plik

plik jest napisem lub zmienną typu napisowego zawierającą legalną (z punktu widzenia systemu operacyjnego) nazwę pliku. Przykładowo program:

{ printf "%s\n", $0 > $1 }

będzie działał doputy, dopóki wartością $0 w pliku wejściowym będzie napis mogący być legalną nazwą pliku (oraz dopóki liczba otwartych jednocześnie plików nie przekroczy dopuszczalnego maksimum, porównaj uwagi z przykładu 22 (Pisanie do wielu plików)).

Operator > otwiera plik tylko raz (niszcząc poprzednią zawartość); kolejne instrukcje printf dodają tekst do tego pliku. Operator >> różni się od > tym, że przy otwarciu pliku poprzednia zawartość nie jest niszczona.

#!/bin/bash
if test $# -eq 0; then
  echo "`basename $0`: plik..." >&2; exit 0; fi

cat $* | awk ' {  o = $NF * $(NF-1);
   smaki[$(NF-2)] += o; kolory[$(NF-3)] += o;
   obrot[$(NF-2), $(NF-3)] += o
}
END { for (smak in smaki) 
         for (kolor in kolory) 
              if ((smak, kolor) in obrot)
                print smak, kolor, obrot[smak, kolor];
}' | sort | awk ' BEGIN { kreska = "+-----------------------+"
     KRESKA = "+=======================+"; print KRESKA; }
{ if (kolor != $1) {
    if (NR !=1) {
      printf "| Razem:   | %10.2f |\n", razem; 
      print KRESKA; razem = 0}
      printf "| Wina %-16.16s |\n", $1; 
      print kreska;
    }
  razem += $3; rrazem += $3;  kolor = $1; 
  printf "| %-8.8s | %10.2f |\n", $2, $3
} 
END { printf "| Razem:   | %10.2f |\n", razem; 
      print KRESKA;
      printf "| OGÓŁEM:  | %10.2f |\n", rrazem; 
      print KRESKA; } '

Możliwe jest także drukowanie w potoku za pomocą instrukcji printf (print) o postaci:

printf format, arg1,... | program
print arg1,... | program

program jest napisem lub zmienną napisową zawierającą nazwę programu-odbiorcy strumienia danych drukowanych przez printf (print).

{ obrot[$(NF-2)] += $NF * $(NF-1) }
END {for (wino in obrot) {print wino, obrot[wino] | "sort -nr +1" }}

Funkcja close zamyka plik otwarty za pomocą operatorów >, >> i |. Jej składnia jest następująca:

close(napis)

gdzie napis jest identyczny z napisem plik lub program, za pomocą których uprzednio otwarto plik/potok. Funkcja ta jest niezbędna w sytuacji gdy np. najpierw piszemy do pliku a następnie chcemy (w obrębie tego samego programu) czytać z niego dane.

Napis zamykający plik lub potok musi być identyczny z dokładnością do znaków odstępu, z tym, za pomocą którego plik/potok został otworzony. Z tego względu zalecamy używanie do otwierania i zamykania plików i potoków uprzednio zadeklarowanych zmiennych a nie posługiwanie się stałymi napisowymi.

#!/usr/bin/awk -f
NR==1, /^-+[ \t]*$/ { next }  # Pomiń nagłówek,
/^Etap[ \t]+[0-9]+:/ { close(File);
    sub(/:/,"",$2); File="etap" $2;
    next } 
NF > 0 { print $0 > File}

#!/bin/bash
if [ ! -f "$1" ]; then 
echo "Wykorzystanie: `basename $0`: plik" >&2; exit 0; fi
awk 'FNR==1 { pass++ }
pass == 1 {oo += $NF * $(NF-1) } 
pass == 2 {print $0, 100 * $NF * $(NF-1)/oo }' $1 $1

Funkcja fflush o postaci:

fflush(napis)

opróżnia bufor związany z plikiem lub potokiem poprzez napis, identyczny z napisem plik lub program, za pomocą których uprzednio otwarto plik/potok. Dopuszczalne są także dwie następujące postacie funkcji: fflush() oraz fflush(""). Pierwsza opróżnia bufor związany ze standardowym wyjściem, druga bufory związane z wszystkimi otwartymi w danej chwili plikami/potokami.

Funkcja system ma postać:

system(instrukcja)

wykonuje instrukcję systemową przekazaną jako wartość napisowego argumentu instrukcja. Najczęściej funkcje printf/printf i operatory >, >> i | wystarczają do zrealizowania typowych zadań bez potrzeby uciekania się do funkcji system.