Der Reportgenerator awk

Intro

• awk bietet eine Reihe von Funktionen die, denen des sed-Editors, ähnlich sind. awk zerlegt die Zeilen noch automatisch in Strings bzw. Felder wie sie hier genannt werden.
• Der Aufruf von awk erfolgt folgendermassen:

awk [-Fz] [parameter] [awk_program] [file . . .] 
awk [-Fz] [parameter] -f awk_script [file . . .]

awk-Programm

• Ein awk-Programm/Skript besteht aus drei Teilen:
  • Initialisierung
  • eigentliche Verarbeitung
  • Abschluss

• Vollständiges awk-Programm hat den folgenden Aufbau:

BEGIN      { start_actions }   # optional
pattern1   { action1 }
pattern2   { action2 }
 . . .        . . .
END        { end_actions }     # optional

• Hier die Beschreibung einzelner Teile:
  • start_actions
    Die mit start_actions spezifizierten Aktionen werden ausgeführt, bevor die erste Zeile der ersten Eingabedatei eingelesen wird.
  • end_actions
    Die mit end_actions spezifizierten Aktionen werden nach der Bearbeitung aller Eingabedateien ausgeführt und ermöglichen damit Endergebnisse/Schlussarbeiten durchzuführen.
  • pattern { action }
    awk liest eine Zeile der Eingabe und prüft ob sie dem Muster pattern entspricht. In diesem Fall wird die nachfolgend angegebene action ausgeführt. Danach wird untersucht ob das Kriterium (pattern) des nächsten awk-Elementes zutrifft. Erst wenn alle Elemente des awk-Programms in diesem Sinne durchlaufen sind, wird die nächste Zeile eingelesen und dieser Vorgang wiederholt. Fehlt in einem awk-Element die Musterkomponente (pattern), so wird die action dieses Elementes auf alle Eingabezeilen angewandt; fehlt die Aktionskomponente, so wird die Zeile unverändert auf die Standardausgabe geschrieben.
  • Ein pattern kann diverse Formen annehmen:
    • ein regulärer Ausdruck in der Form: /pattern/
    • ein Auswahlbereich in der Form: /pattern1/,/pattern2/
    • ein relationaler Ausdruck
    • eine Verknüpfung der Elementen von oben

Einführende Beispiele

• Äquivalent zu egrep.

$ awk '/pattern/ { print }' filenames . . .

• Gleich wie oben.

$ awk '/pattern/' filenames

• Äquivalent zu cat.

$ awk '{ print }' filenames . . .

Sonderzeichen

• In pattern können folgende Sonderzeichen verwendet werden:
  • .
    Beliebiges Zeichen (genau 1 Zeichen, kein \n).
  • .*
    Beliebige Zeichenkette (auch leere).
  • *
    Beliebige Wiederholung (auch keine).
  • ?
    Keine oder eine Wiederholung.
  • +
    Eine oder mehrere Wiederholungen.
  • [. . .]
    Eines der Zeichen aus . . ..
  • [^. . .]
    Keines der Zeichen aus . . ..
  • ^pattern
    Am Satzanfang.
  • pattern$
    Am Satzende; z.B.: /^$/steht für einen leeren Satz
  • a | b
    a oder b.
  • \( . . .\)
    Gruppierung.
  • \
    Maskiert nachfolgendes Sonderzeichen; z.B.: \\ steht für \ selbst

Felder

• Beim Einlesen einer Zeile (dafault awk-record) wird die Eingabe in Felder zerteilt und die Elemente den awk-Variablen $1, $2, usw. zugewiesen. Die Variable $0 enthält die ganze Zeile.
• Die Unterteilung der Eingabe in Felder geschieht durch Feldtrennzeichen, die in der FS-Variable festgelegt sind. Der Standardwert von FS sind die sogenannten white spaces: <space> und <tab>. Feldtrennzeichen können entweder durch die Option -Fz beim Aufruf von awk oder innerhalb des awk-Programms durch die Zuweisung FS=z umdefiniert werden.
• Die awk-Variable NF gibt die Anzahl Felder an.

awk-Sprachelemente

Konstanten

• Numerische Konstanten sind entweder ganze Zahlen oder Gleitpunktzahlen. Folgende Formen sind erlaubt: 1.2, .3, 23e2, 3.4 e-3, 34e+4, 12E14, 12.3E-2; diesen darf ein + oder ein - vorangestellt sein.
• Textkonstanten werden durch ". . ." geklammert. Soll das Zeichen " selbst im Text vorkommen, so muss dies durch \" angegeben werden. \n steht für die <NEWLINE>,\t für <TAB> und \\ für das Zeichen \ selbst.

Variablen

• Variablen haben einen Namen der mit einem Buchstaben beginnt. Variablen müssen nicht explizit deklariert/definiert werden. Sie werden bei der ersten Verwendung im awk-Programm angelegt. Der initiale Wert einer awk-Variable ist eine leere Zeichenkette.
• Es sind auch Felder bei Variablen möglich; es wird die gleiche Syntax wie in C verwendet. Im Gegensatz zu C, darf bei awk der Index nicht nur numerischer Ausdruck sein, sondern auch aus einer (beliebigen) Zeichenkette bestehen - auf dieser Weise werden die sogenannten Associative Arrays unterstützt.
• Neben den vom Benutzer vorgegebenen Variablen und den Record- bzw. Feld-Variablen $0, $1, $2, . . ., kennt awk bereits eine Reihe von variablen mit fester Bedeutung. Diese werden im Gegensatz zu Shell ohne $ angesprochen:
  • ARGC
    Entspricht der Anzahl der Argument der Kommandozeile.
  • ARGV
    Ein Array dessen Elemente die Argumente der Kommandozeile enthalten.
  • FILENAME
    Der Name der aktuellen Eingabedatei.
  • FS
    Enthält das oder die Trennzeichen für Felder der Eingabe.
  • NF
    Die Anzahl der Felder in der aktuellen Eingabezeile.
  • NR
    Enthält die Nummer der aktuellen Zeile der Eingabe.
  • OFMT
    Definiert das Standardformat von Zahlenwerten in der Ausgabe (Default: %.6g).
  • OFS
    Gibt die Trennzeichen an, die jeweils zwischen zwei Feldern in der Ausgabe stehen sollen. Default Wert für OFS ist das Leerzeichen.
  • ORS
    Definiert das/die Zeichen mit dem/denen ein Record in der Ausgabe abgeschlossen werden soll. Default Wert für ORS ist <NEWLINE>.
  • RS
    Definiert Zeichen das/die in der Eingabe als Satztrennzeichen betrachtet werden soll/sollen. Default Wert für RS ist <NEWLINE>.

Ausdrücke

• In numerischen Ausdrücken dürfen die Operatoren +, -, *, /, % (Modulo), (. . .) zur Gruppierung sowie numerische Funktionen vorkommen.
• In Textausdrücken wird der Operator <space> als Zeichen für die Zusammensetzung (concatenation) von Strings verwendet.
• In logischen Ausdrücken kommen folgende Operatoren vor:
  • Vergleichsoperatoren (<, <=, ==, !=, >= und >)
  • Operatoren für die logischen Verknüpfungen:
    • && für AND, d.h. beide Operanden müssen true sein
    • || für OR, d.h. eines der beiden Operanden muss true sein
    • ! für die Negation
    • ~ für entspricht dem Muster
    • !~ für entspricht dem Muster nicht
• Ein Ausdruck wird abhängig von seinen Elementen als ein numerischer Ausdruck oder als ein Textausdruck betrachtet. Will man erreichen, dass ein Ausdruck als numerischer interpretiert wird, so kann dies durch "+ 0" im Ausdruck erzielt werden; soll der Ausdruck als Textausdruck interpretiert werden, so kann dies durch eine Zusammenfügung mit einer leeren Zeichenkette ("") erreicht werden.

awk-Aktionen

• Eine awk-Aktion kann aus keiner, einer oder aus mehreren Anweisungen bestehen.
• Eine Anweisung wird durch ein Semikolon ;, durch ein <NEWLINE> oder durch eine schliessende Klammer } beendet.
• Bei den Zuweisungen sind die folgenden Operatoren zugelassen:
  • =
    "Normale" Zuweisung.
  • op=
    variable op= expr entspricht dem variable = variable op expr, wobei op einer von: +, -, *, / und % sein kann.
  • ++
    Prefix und postfix, wie in C.
  • --
    Prefix und postfix, wie in C.
• In den awk-Aktionen sind neben Zuweisungen auch folgende Anweisungsarten möglich:
  • if (condition) statement1 [else statement2]
    Falls condition erfüllt ist, wird statemet1 ausgeführt; falls nicht wird sie übersprungen und, falls die else-Komponente vorhanden ist, wird statement2 ausgeführt.
  • while (condition) statement
    Die condition wird ausgewertet, und falls sie erfüllt ist, die angegebene Anweisung ausgeführt. Dieser Vorgang wird solange wiederholt, bis die condition nicht mehr erfüllt ist.
  • for (stmt1; cond; stmt2) stmt
    Der Ausdruck stmt1 wird ausgewertet. Danach wird die Bedingung cond überprüft. Ist sie erfüllt, so wird die Anweisung stmt ausgeführt, danach stmt2 ausgewertet. Dies wird solange wiederholt, bis die Bedingung nicht mehr erfüllt ist.
  • for (variable in field) stmt
    Die variable nimmt nacheinander die Werte der einzelnen Feldelemente an. Hierdurch wird die Anweisung stmt so oft durchlaufen, wie field Elemente besitzt. In stmt soll die Variable nicht verändert werden und dem field keine neuen Elemente zugewiesen werden. Die Reihenfolge, in denen die Feldelemente angeliefert werden ist nicht definiert und kann sich von Durchlauf zu Durchlauf unterscheiden.
  • break
    Diese Anweisung beendet die Abarbeitung einer for- oder while-Schleife. Die Abarbeitung wird hinter der Schleife fortgesetzt.
  • continue
    Es wird an das Ende einer for- oder while-Schleife gesprungen und erneut überprüft, ob die Schleifenbedingung noch zutrifft.
  • print [stmts] [I/O redirection]
  • printf format [,stmts] [I/O redirection]
    Ausdrücke der Liste werden ausgewertet und ausgegeben. Bei printf spezifiziert format mit der gleichen Syntax wie bei printf in C den Aufbau der Ausgabe. Die Umlenkung (redirection) kann folgende Formen haben:
    • >file
      Die Ausgabe wird in die angegebene Datei geschrieben.
    • >>file
      Die Ausgabe wird am Ende der angegebenen Datei angefügt.
    • | program
      Die Ausgabe wird über eine Pipe dem angegebenen Programm übergeben. Die Form ist dann in der Regel:

print . . . | "program args"

• {stmt . . .}
  Klammerung/Gruppierung von Anweisungen.
• variable = expr
  Der angegebene Ausdruck wird ausgewertet und das Ergebnis der variable zugewiesen.
• next
  Die noch verbliebenen Kriterien (patterns) des awk-Programms werden übersprungen und die nächste Eingabezeile wird gelesen und verarbeitet.
• exit [expr]
  Der Rest der Eingabedatei wird übersprungen, END-Teil des awk-Programms wird ausgeführt (falls vorhanden) und awk wird beendet. Der Exit-Status erhält den Wert expr.
• return [expr]
  Rücksprung aus einer Funktion mit dem Ergebniswert expr.
• # comment
  Das Zeichen # leitet ein Kommentar ein. Dieser erstreckt sich bis zum Ende der Zeile.

awk-Funktionen

Numerische Funktionen

• atan2(x)
  Liefert Arcus Tangens von x.
• cos(x)
  Liefert Cosinus von x.
• exp(x)
  Exponentialfunktion, liefert e^x.
• int(x)
  Liefert den ganzzahligen Anteil eines numerischen Wertes (x).
• log(x)
  Logarithmus Naturalis von x.
• rand()
  Liefert eine Zufallszahl 0 <= i <= 1.
• sin(x)
  Liefert Sinus von x.
• sqrt(x)
  Liefert Wurzel von x.
• srand(x)
  Initialisiert die Zufallsfolge für rand mit x. Fehlt x, so wird ein Wert aus der Uhrzeit berechnet.
• length(expr)
  length
  Liefert die Länge einer Zeichenkette in Bytes zurück. Ohne Parameter liefert die Funktion die Länge der aktuellen Zeile ($0).

Funktionen auf Zeichenketten

• gsub(re, new, text)
  Die Zeichenkette text wird nach dem Textausdruck re (regulärer Ausdruck) durchsucht und alle passenden Textstücke durch new ersetzt. Fehlt der Parameter text, so wird die Funktion auf $0 verwendet.
• index(t1, t2)
  Sucht im Text t1 nach dem Text t2 und liefert die Anfangsposition (oder 0) zurück. t1 und t2 dürfen String-Ausdrücke sein.
• split(expr, name, separator)
  split(expr, name)
  Der Textausdruck expr wird entsprechend Trennzeichen (separator), bzw. in der zweiten Form entsprechend FS, in Feldelemente zerlegt. Diese werden in dem Feld name abgelegt. split liefert als Funktionswert die Anzahl gefundenen Elemente.
• sprintf(format, expr, . . . )
  Formatiert den/die Ausdrücke expr, . . . entsprechend den in Angaben in format und liefert das Ergebnis als Zeichenkette zurück. Für format gelten die Konventionen wie in C.
• sub(re, new, text)
  sub(re, new)
  Die Zeichenkette text wird nach dem Textausdruck re (regulärer Ausdruck) durchsucht und das erste passende Textstück durch new ersetzt. Fehlt der Parameter text, so wird die Funktion auf $0 angewandt.
• substr(text, m, n)
  substr(text, m)
  Liefert einen n Zeichen langen Text aus der Zeichenkette text. Der Text wird aus text beginnend mit dem m-ten Zeichen herausgeschnitten. Die Zählung beginnt bei 1. Fehlt die Angabe von n (zweite Form), so wird die Zeichenkette aus text, beginnend bei Position m bis zum Ende der Zeichenkette zurückgegeben.

E/A- und generelle Funktionen

• close(file)
  Schliesst die angegebene Datei oder die Pipe.
• getline < file
  getline variable
  getline variable < file
  cmd | getline
  getline
  Nächste Eingabezeile wird eingelesen, zerteilt und steht in $0 bis $NF zur Verfügung. getline liefert als Funktionswert 0 zurück, falls die Eingabe ohne Fehler gelesen werden konnte, 1 falls <EOF> erreicht wurde und -1 falls ein Fehler auftrat.
• system(cmd)
  Das angegebene Unix cmd wird ausgeführt und sein Exit-Status als Funktionswert zurückgeliefert..

Übergabe von Shellparametern

• Die alte Art der Übergabe von Parametern aus der Kommandozeile an das awk-Skript geschah über eine entsprechende Shell-Klammerung. Beispiele:
  • awk 'BEGIN {length = '$1'} . . .'
    $1 wird von der Shell durch den entsprechenden Parameter substituiert und damit dem awk-Skript als Wert übergeben.
  • awk "length $1 {. . .}" . . .
    Die Shell ersetzt $1 (dieser befindet sich in der ". . ."-Klammerung) und übergibt den entsprechenden Wert dem awk-Skript.
• Bessere Art ist die Übergabe durch eine entsprechende Kommandozeile, z.B.:

$ awk 'length > maxl {print . . .}' maxl=30

• In den neueren Versionen von awk steht der ARGC/ARGV-Mechanismus zur Verfügung, ähnlich wie in C. In der Variable ARGC steht die Anzahl der Parameter die beim awk-Aufruf übergeben wurden. In der Variable ARGV stehen in der Reihenfolge des Aufrufs die einzelnen Parameter des Aufrufs. Das Beispiel von oben kann wie folgt geschrieben werden:

$ awk  . . . 'BEGIN {length = ARGV[1]} . . .'

Einfache Beispiele

• $ du -a | awk '{ print $2 }'
  Entspricht dem: $ du -a * | sed 's/.*->//'
• $ who | awk '{ print $1, $5 }'
  Entspricht dem: $ who | sed 's/ .* //'
• $ who | awk '{ print $5, $1 }' | sort
  Gleich wie oben, nur werden die Spalten 1 und 5 ausgewechselt und nach Login-Zeiten sortiert.
• Trennungs-Zeichen ändern

$ sed 3q /etc/passwd | \
 awk -F: '{ print $1 }'

• Output
  • Zeilen numerieren:

$ awk '{ print NR, $0 }'

• Verbesserte Version der Zeilennumerierung:

$ awk '{ printf "%4d %s\n", NR, $0 }'

• Indent-Programm.

$ awk '{ printf "\t%s\n", $0 }'

Beispiele zu den Mustern

• Sucht alle Benutzer ohne Passwort:

awk -F: '$2 == ""' /etc/passwd

• Das zweite Feld ist leer.

$2 == ""

• Das zweite Feld entspricht einem leeren String.

$2 ~ /^$/

• Das zweite Feld entspricht nicht einem nicht leeren String.

$2 !~ /./

• Die Länge des zweiten Feldes ist gleich 0.

length($2) == 0

• Sucht nach Zeilen mit ungeraden Anzahl Felder:

NF % 2 != 0

• Sucht nach langen Zeilen und warnt:

length($0) > 72 {
   print "Line", NR, "too long:",
      substr($0, 1, 60)
}

• Ausgabe eines Befehls weiterverarbeiten:

$ date | awk '{print substr($4, 1, 5)}'

Beispiele zu den BEGIN- und END-Mustern

• FS umdefinieren:

$ awk 'BEGIN { FS = ":" }         gleich wie -F 
 $2 == "" ' /etc/passwd
$

• Word Count (wc -l):

$ awk 'END { print NR }' . . .    == wc -l

Arithmetik und Variablen (Einführende Beispiele)

• Die Summe aller Zahlen aus der ersten Spalte wird berechnet. s muss nicht deklariert/definiert werden.

{s = s + $1}
END {print s}

• Gleich wie oben; Durchschnittswert wird auch berechnet.

{s += $1}
END {print s, s/NR}

• Die Anzahl von Zeichen (nc) und die Anzahl von Wörtern (nw) berechnen:

{
   nc += length($0) + 1
   nw += NF
}
END {print NR, nw, nc}

• Berechnet Anzahl Seiten die vom pr erzeugt werden:

$ wc filenames . . . | awk '!/ total$/ {
   n += int (($1+55)/56)
}
END { print n } '
$

Arrays

• Eine Text-Datei rückwärts ausdrucken:

awk '
{ line[NR] = $0 }
END {
   for ( i = NR; i > 0; i-- )
      print line[i]
}
' $*

• Wie bei den Variablen, müssen Arrays nicht deklariert werden.
• Eine (erste) Zeile aus der /etc/passwd-Datei weiterverarbeiten:

$ sed 1q /etc/passwd | \
 awk '{split($0, a, ":"); print a[1]}'

• Ausgabe vom date weiterverarbeiten:

$ echo 5/10/86 | \
 awk '{split($0, date, "/"); print date[3]}'

Assoziative Arrays

• Grundidee: Indizes eines Arrays sind nicht Zahlen

Susie 400
John  100
Mary  200
Mary  300
John  100
Susie 100
Mary  100

{sum[$1] += $2}
END {for (name in sum) print name, sum[name]}

John  200
Susie 500
Mary  600

Beispiele zu den Assoziativen Arrays

• Word Count (awk-Version)

awk '{ for (i = 1; i <= NF; i++) num[$i]++ }
END { for (word in num) print word, num[word] }'

• fold - lange Zeilen werden zerteilt und neu formatiert:

$ sed 's/->/    /g' | awk '
BEGIN {
   N = 80
   for (i = 1; i <= N; i++) blanks = blanks " "
}
{
   if ((n = length($0)) <= N) print
   else {
      for (i = 1; n > N; n -= N) {
         printf "%s\\\n", substr($0,i,N)
         i += N;
      }
      printf "%s%s\n",substr(blanks,1,N-n),substr($0,i)
   }
} '

Beispiele zur Interaktion mit dem Shell-Programm

• Shell Argumente:

$ name arg1 arg2 arg3 . . . arg9 arg10 . . .
  name $1   $2   $3         $9

• Zeigt $1-tes Feld aus der Eingabe.

$ awk '{print $'$1'}' . . .
$ awk "{print \$$1}" . . .

• Summiert alle Zahlen aus dem $1-ten Feld der Eingabe:

$ awk '{s += $'$1'}
 END {print s}'

• Summiert Werte von allen $1 Spalten und berechnet den "Grand Total"-Wert:

$ awk '
BEGIN {
   n = '$1'
}
{
   for (i = 1; i <= n; i++) sum[i] += $i
}
END {
   for (i = 1; i <= n; i++) {
      printf "%6g ", sum[i]
      total += sum[i]
   }
   printf "; total = %6g\n", total
}'

Kalender Beispiel

$ awk < $HOME/calendar '
BEGIN {
   x = "Jan 31 Feb 28 Mar 31 Apr 30 May 31 Jun 30 " \
   "Jul 31 Aug 31 Sep 30 Oct 31 Nov 30 Dec 31 Jan 31"
   split(x, data)
   for (i = 1; i < 24; i += 2) {
      days[data[i]] = data[i+1]
      nextmon[data[i]] = data[i + 2]
   }
   #split("'"`date`"'", date)           old & ungly!
   "date" | getline; split($0, date)    new & nice!
   mon1 = date[2]; day1 = date[3]
   mon2 = mon1; day2 = day1 + 1
   if (day1 = days[mon1]) {
      day2 = 1
      mon2 = nextmon[mon1]
   }
}
$1 == mon1 && $2 == day1 || $1 == mon2 && $2 == day2
' | mail $NAME


$ cat ~adamov/calendar
Oct 17 Mother's Birthday
Nov 21 Project Meeting
Dec 1 Parnas' Talk
$


$ cat early.morning
calendar
echo early.morning | at 5am
$

LANsys 15.03.2004