Awk: Grundlagen: Aktionen

Zurück zu Reguläre Ausdrücke | Hoch zu Grundlagen-Inhaltsverzeichnis | Vor zu awk-Einstellungen

Variablen

Benutzerdefinierte Variablen

Variablen müssen nicht deklariert werden und können ihren Typ dynamisch ändern. awk kennt Variablen vom Typ String oder numerischer Typ. Wird eine Variable nicht initialisiert, so erhält sie standardmäßig den Wert 0 bzw. "", den leeren String der Länge 0. Variablenbezeichner müssen mit einem Buchstaben oder dem Unterstrich beginnen und dürfen nur aus diesen, sowie den Ziffern 0 bis 9 bestehen, als regulärer Ausdruck: ^[A-Za-z_][A-Za-z0-9_]*.

Beispiel:

#!/usr/bin/awk -f
BEGIN { 
  x = 51               # numerischer Wert
  print x
  x = "x-Wert ist " x  # String
  print x
  x = x + 0            # numerischer Wert
  print x
}

Ausgabe:

51
x-Wert ist 51
0

Feldvariablen

Als Feldvariablen werden die bereits bekannten Variablen für den Zugriff auf einen Datensatz $0 oder einzelne Felder $1, $2, ... bezeichnet. Feldvariablen können wie gewöhnliche Variablen verwendet werden.

Arrays

awk kennt auch ein- und mehrdimensionale Arrays, wobei awk mehrdimensionale Arrays durch eindimensionale Arrays emuliert - dazu gleich mehr. Arrays brauchen ebenfalls nicht deklariert oder explizit initialisiert zu werden. Manche Funktionen (wie z.B. split) erzeugen als Ergebnis automatisch ein Array.

Prinzipielle Schreibweisen:

arraybezeichner[i]            # eindimensionales Array
arraybezeichner[i,j]          # zweidimensionales Array
arraybezeichner[i,j,k]        # dreidimensionales Array
...
arraybezeichner["schluessel"] # assoziatives Array

Beispiel:

awk-Skript:

#!/usr/bin/awk -f
BEGIN {
  einkommen["Hans"] = 3343
  einkommen["Rudi"] = 5412
  einkommen["Susanne"] = 4221

  print "Gesamteinkommen: " einkommen["Hans"] + einkommen["Susanne"] + einkommen["Rudi"]
}

Ausgabe:

Gesamteinkommen: 12976

Bei mehrdimensionalen Arrays werden die jeweiligen Indizes durch Kommata getrennt.

Beispiel:

awk-Skript:

#!/usr/bin/awk -f
BEGIN {
  matrix[0,0] = 1
  matrix[0,1] = 0
  matrix[1,0] = 0
  matrix[1,1] = 1

  print matrix[0,0] " " matrix[0,1]
  print matrix[1,0] " " matrix[1,1]
} 

Allerdings kennt awk intern gar keine mehrdimensionalen Arrays, sondern bildet diese durch eindimensionale Arrays nach. Die mehrdimensionale Schreibweise ist nur "syntaktischer Zucker". awk wandelt mehrdimensionale Indizes durch Zusammenfügen der Index-Zeichenketten in einen einzigen Index um. Dies geschieht unter Verwendung des Inhalts der Variable SUBSEP. SUBSEP ist in awk vordefiniert und enthält eine Zeichenkette. Die Voreinstellung ist ein einzelnes Zeichen, das nicht druckbare ASCII Zeichen mit dem Wert 28 (0x1c hexadezimal, 034 oktal, ASCII Name FS "field separator"). SUBSEP kann vom Programmierer ein anderer Wert zugewiesen werden, wenn dies vorteilhaft ist.

SUBSEP wird intern in awk als Trennzeichen zwischen den Einzelindizes verwendet. Ein mehrdimensionaler Index, beispielsweise [2,4], wird als eindimensionaler Index [2 SUBSEP 4] behandelt. Das folgende Beispiel zeigt dies anhand des Überschreibens einer Variable:

#!/usr/bin/awk -f
BEGIN {
   if(SUBSEP == "\034") {
      print "SUBSEP enthält voreingestellten Wert"
   }

   #
   # a[1,2,3,4] in normaler Schreibweise zuweisen
   #
   a[1,2,3,4] = "Normale Indexschreibweise"
   print a[1,2,3,4]

   #
   # a[1,2,3,4] nochmals zuweisen, allerdings ist der Index
   # von Hand mittels SUBSEP nachgebildet und doch wird a[1,2,3,4]
   # überschrieben.
   #
   a[1 SUBSEP 2 SUBSEP 3 SUBSEP 4] = "Index von Hand nachgebildet"
   print a[1,2,3,4]

   #
   # a[1,2,3,4] ein weiteres Mal zuweisen. Diesmal wird der
   # Index zuerst von Hand in einer Variable nachgebildet
   #
   ndx = 1 SUBSEP 2 SUBSEP 3 SUBSEP 4
   a[ndx] = "Index von Hand nachgebildet II"
   print a[1,2,3,4]
}

Ausgabe:

SUBSEP enthält voreingestellten Wert
Normale Indexschreibweise
Index von Hand nachgebildet
Index von Hand nachgebildet II

Wozu ist das Wissen um dieses spezielle Implementierungsdetail von awk nützlich? Nun, es erlaubt zum Beispiel, einen mehrdimensionalen Index (der ja gar keiner ist - wie jeder nachvollziehen kann, der jemals Assembler programmiert hat) in einer normalen Variable zu speichern (wie ndx in obigem Beispiel). Weiterhin bedeutet es, dass zum Beispiel die Elemente a[5] und a[1,2,3] Elemente des selben Arrays sind, man beim Auslesen des gesamten Arrays also beide Werte erhält. Wichtig ist ebenfalls, dass man vorsichtig mit Zeichenketten als Index sein sollte, die aus irgendeinem Grund SUBSEP enthalten können. In einem solchen Fall kann man SUBSEP einen anderen Wert zuweisen.

Ein weiteres Implementationsdetail von awk-Arrays ist, dass diese (eigentlich) auch keine numerischen Indizes kennen. Man kann zwar "Zahlen" in Form numerischer Werte als Index angeben; intern wird aber nur die "Ziffer(nfolge)" als Zeichen(kette) benutzt. awk Arrays sind intern ausschließlich eindimensionale assoziative Arrays. Beispiel:

#!/usr/bin/awk -f
BEGIN {
    a[0] = 0
    a["0"] = 1
    print a[0]
}

Ausgabe:

1

Dies sollte man beachten, wenn man gemischte (numerische und Zeichenketten) Indizes für ein Array verwenden möchte. Am besten vermeidet man dieses.

awk-Variablen (Builtin-Variablen, Systemvariablen)

Variablenbezeichner	Bedeutung	Beispiel	Ausgabe
ARGC	Anzahl der übergebenen Kommandozeilenargumente	awk 'BEGIN{print ARGC}'	1
ARGV	Array mit den übergebenen Kommandozeilenargumenten	awk 'BEGIN{print ARGV[0]}'	awk
CONVFMT	Internes Umwandlungsformat für Zahlen	awk 'BEGIN{print CONVFMT}'	%.6g
ENVIRON	Array, welches die Werte der Environment-Variblen enthält	awk 'BEGIN{print ENVIRON["LANG"]}'	de_DE@euro
FILENAME	Name der aktuellen Eingabedatei
FNR	Anzahl der bisher gelesenen Datensätze in der aktuellen Eingabedatei (file number of record)
FS	Feldtrennzeichen (field separator, Default: Leer- oder Tabulatorzeichen)
NF	Anzahl der Felder im aktuellen Datensatz (number of fields)
NR	Datensatznummer (number of record)
OFMT	Output Format	awk 'BEGIN{print OFMT}'	%.6g
OFS	Output field separator (Default: Leerzeichen)
ORS	Output record separator (Default: "\n")
RLENGTH	(relevant für die match-Funktion)
RS	Record Separator (Default: "\n")
RSTART	(relevant für die match-Funktion)
SUBSEP	Subscript separator (relevant für mehrdimensionalen Arrays, Default: "\034")

Operatoren

Operatoren	Kommentar
+,-,*,/	Grundrechnungsarten
%	Modulo
^, **	Potenzierung
=, +=, -=, /=, *=, %=	Zuweisungen
~, !~	enthält, enthält nicht (relevant für reguläre Ausdrücke)
++, --	Inkrement, Dekrement (als Post- oder Präfixoperatoren)
+,-	Vorzeichen
in	Array-Mitgliedsoperator
&&, ||, !	Logische Operatoren (AND, OR, NOT)
==, <, <=, >, >=, !=	Vergleichsoperatoren
()	Gruppierung
$	Feldoperator
?:	Bedingungsoperator

Beispiel: Gegeben sei eine Tabelle tab.txt

4  15 7
2  9  8 
11 0  17
1  1  3

Gesucht ist die Summe der Feldwert für jeden Datensatz und insgesamt.

awk-Skript:

#!/usr/bin/awk -f
{
  sumDS = $1 + $2 + $3
  print "Summe Datensatz " NR " = " sumDS
  sumGes += sumDS
}
END {print "Summe gesamt = " sumGes}

Ausgabe:

Summe Datensatz 1 = 26 
Summe Datensatz 2 = 19 
Summe Datensatz 3 = 28 
Summe Datensatz 4 = 5 
Summe gesamt = 78

Priorität und Assoziativität von Operatoren

Prioriät	Operatoren	Anmerkung	Assoziativität
1	()	Gruppierung	→
2	$	Feldoperator	→
3	++, --	Inkrement, Dekrement	→
4	^, **	Exponentiation	←
5	+, -, !	Unäres Plus, Unäres Minus, logisches NOT	→
6	*, /, %	Multiplikation, Division, Modulo	→
7	+, -	Addition, Subtraktion	→
8		Stringverknüpfung	→
9	<, <=, ==, !=, >, >=, >>, |, |&	Vergleichsoperatoren und Umleitungen	→
10	~, !~	enthält, enthält nicht	→
11	in	Array-Mitgliedsoperator	→
12	&&	Logisches AND	→
13	||	Logisches OR	→
14	?:	Bedingungsoperator (Konditionaloperator)	←
15	=, +=, -=, *=, /=, %=, ^=	Zuweisungen	←
Legende: Priorität: Niedrigere Zahl bedeutet höhere Priorität Assoziativität: → ... links-assoziativ, ← ... rechts-assoziativ

Beispiele:

• a/b*c ⇔ (a/b)*c
• erg=x^y+2^z/3 ⇔ erg = ((x^y) + (2^z) / 3)
• $++n ⇔ $(++n)

Konstanten

Stringkonstanten werden in sog. doppelte Hochkommata, vulgo Gänsefüßchen, eingefasst. Begrenzungszeichen werden durch das Fluchtsymbol \ außer Kraft gesetzt; dieses dient auch für nichtdruckbare Zeichen wie z.B. \t (Tab) oder \n (linefeed).

Beispiele:

"Hallo, Welt!"
"A\tB"
"das sogenannte \"einfache Hochkomma\"  ' unterscheidet sich vom \"Gänsefüßchen\" '\"'."
"" # der kürzeste String der Welt

Numerische Konstanten können ganze Zahlen oder Gleitkommazahlen sein.

Beispiele:

5555
3.1415
.5
-3.56e5
2.01E11

Benutzerdefinierte Funktionen

Grundlagen

Eine benutzerdefinierte Funktion kann in der Form

function funktionsname(parameterliste) {
  ...
}

definiert werden. Funktionsdefinitionen sollen aus Gründen der Übersichtlichkeit an das Ende eines awk-Programmes gestellt werden.

Beispiel:

awk-Skript:

#!/usr/bin/awk -f
BEGIN {
  schreibe("Hallo, Welt!")
  schreibe("Heidis Hunde heißen Hans und Franz.") # Hans ist jünger
}

function schreibe(wert) {
  print wert
}

Ausgabe:

Hallo, Welt! 
Heidis Hunde heißen Hans und Franz.

Eine return-Anweisung bewirkt das sofortige Verlassen der Funktion. Wird bei der return-Anweisung auch noch ein Ausdruck angegeben, so wird der resultierende Wert dieses Ausdrucks an die aufrufende Anweisung zurückgegeben.

Beispiel:

#!/usr/bin/awk -f
BEGIN {
  n = berechne(2)
  n = berechne(n)
  berechne(n) 
}

function berechne(wert) {
  erg = wert^2
  print erg
  return erg
  erg +=5      # Diese Anweisung ist sinnlos, sie wird nie ausgeführt
}

Ausgabe:

4 
16 
256

Gültigkeit und Sichtbarkeit von Variablen

Grundsätzlich sind Variablen global sichtbar und gültig.

Beispiel:

#!/usr/bin/awk -f

BEGIN {
  n = 5
  berechne() 
  berechne2()
  print "erg                 --> ", erg
}

function berechne() {
  erg = n^2
  print "berechne() : erg    --> ", erg
}

function berechne2() {
  print "berechne2() : n*3   --> ", n*3
  print "berechne2() : erg*5 --> ", erg*5
}

Ausgabe:

berechne() : erg    -->  25
berechne2() : n*3   -->  15
berechne2() : erg*5 -->  125
erg                 -->  25

Parameter

Wie nicht anders zu erwarten, gilt auch hier die Regel "Keine Regel ohne Ausnahmen". Ausnahmen sind die einer Funktion übergebenen Parameter. Parameter sind nur lokal in der jeweiligen Funktion gültig.

Beispiel:

#!/usr/bin/awk -f

BEGIN {
  n = 333
  print "n                 --> ", n
  berechne(5) 
  print "n                 --> ", n
  berechne2()
  print "n                 --> ", n  
}

function berechne(n) {
  n ^= 2
  print "berechne() : n    --> ", n
}  
  
function berechne2() {
  n -= 111
  print "berechne2() : n   --> ", n 
}

Ausgabe:

n                 -->  333
berechne() : n    -->  25
n                 -->  333
berechne2() : n   -->  222
n                 -->  222

Dieses Beispiel zeigt auch eine zu beachtende Eigenheit auf. Die globale Variable n ist zwar im gesamten Skript gültig. Trotzdem kann in der Funktion berechne(n) nicht auf sie zugegriffen werden. Sie wird vom Parameter n überdeckt. In dieser Funktion ist also nur der Parameter n sichtbar, jedoch nicht die globale Variable n.

Arrays als Parameter

Parameter werden, mit Ausnahme von Arrays, "call by value" übergeben, also in Form einer Kopie. Arrays werden per "call by reference" übergeben. Das bedeutet, dass unabhängig vom formalen Parameternamen Feldmanipulationen auf das Array selbst rückwirken.

Beispiel:

#!/usr/bin/awk -f

BEGIN {
  arr[1] = 2
  arr[2] = 5
  arr[3] = 27
  
  add(arr)
  
  for(i in arr)
    print "arr[" i "] --> ", arr[i]

  print "n[4] --> ", n[4]
  
}

function add(n) {
  n[4] = 110
}

Ausgabe:

arr[4] -->  110
arr[1] -->  2
arr[2] -->  5
arr[3] -->  27
n[4] -->

Lokale Variablen

Bei Bedarf können lokale Variablen über den Umweg der Funktionenparameterliste erzeugt werden. Im Unterschied zu typisierten Programmiersprachen wie C/C++ muss bei awk die Anzahl der übergebenen Parameter beim Funktionsaufruf nicht mit der formalen Funktionsdefinition übereinstimmen.

Beispiel:

#!/usr/bin/awk -f

BEGIN {
  a = 3;    

  a = berechne(a)
    
  print "a =", a
  print "n =", n
  print "m =", m
}

function berechne(n, m) {
  m = 10
  return n/m
}

Ausgabe:

a = 0,3
n =
m =

Rekursion

Auch awk beherrscht Rekursion. Rekursion bedeutet, dass sich die Funktion selbst aufruft. Damit keine "Endlosschleife" entsteht ist auf die Vorgabe geeigneter Abbruchbedingungen zu achten.

Beispiel:

#!/usr/bin/awk -f

BEGIN {
  schreibe(10)
}

function schreibe(nr) {
  print nr 
  
  if(nr>1)
    schreibe(nr-1)
}

Ausgabe:

10
9
8
7
6
5
4
3
2
1

Builtin-Funktionen

In awk ist bereits eine große Anzahl von Funktionen fix eingebaut, die sogenannten Builtin-Funktionen. Die folgende Auflistung umfasst nur die Standard-Builtin-Funktionen.

Arithmetische Funktionen

Funktion	Bedeutung/Rückgabewert
atan2(x,y)	Arcustangens von ${\frac {x}{y}}$
cos(x), sin(x)	Cosinus und Sinus von x (x in [Rad])
exp(x)	$e^{x}\$
int(x)	Ganzzahliger Anteil von x
log(x)	$\ln x\$
rand()	Eine Zufallszahl $z:0\leq z<1$
sqrt(x)	${\sqrt {x}}$
srand(x)	Startwert für die Zufallszahlengenerierung neu setzen.
srand()	-"- (Aktueller Zeitwert wird als Startwert verwendet)

Beispiel:

awk-Skript:

#!/usr/bin/awk -f
BEGIN {
  PI = 3.1415927
  print cos(PI/4)
}

Ausgabe:

0,707107

String-Funktionen

Generell werden Strings beginnend mit 1 indiziert.

sub(regexp, replacement [, target])

Ersetze (substituiere) im target das erste Vorkommen von regexp durch replacement. Ist kein target gegeben, so wird in $0 ersetzt. regexp kann als Stringkonstante oder als regulärer Ausdruck gegeben sein.

Rückgabewert: Anzahl der Ersetzungen

Beispiel:

str = "Hallo, Welt! Welt, quo vadis?"
n = sub("Welt", "Heidi", str) 
print str
print n

ergibt

Hallo, Heidi! Welt, quo vadis?
1

gsub(regexp, replacement [, target])

Wie sub, allerdings wird global ersetzt.

Beispiel:

str = "Hallo, Welt! Welt, quo vadis?"
n = gsub("Welt", "Heidi", str) 
print str
print n

ergibt

Hallo, Heidi! Heidi, quo vadis?
2

index(string, find)

Suche das erste Vorkommen des Strings find in string.

Rückgabewert:

• 0: find wurde nicht gefunden,
• Ansonsten die Anfangsposition von find in string.

Beispiel:

str = "Hallo, Welt! Welt, quo vadis?"
n = index(str, "Welt") 
print n

ergibt

8

length([string])

Länge von string. length() entspricht length($0)

Rückgabewert: Länge von string.

Beispiel:

str = "Hallo, Welt! Welt, quo vadis?"
print length(str)

ergibt

29

match(string, regexp [, array])

match bietet ähnliche Funktionalität wie index, allerdings kann hier mittels regulärem Ausdruck gesucht werden.

split(string, array [, fieldsep])

Zerteile einen String string und speichere die einzelnen Felder im Array array. Feldtrennzeichen sind standardmäßig Leerzeichen oder Tabulatoren. Diese Vorgabe kann aber mittels fieldsep geändert werden.

sprintf(format, expr1 [, expr2, ...])

Liefert einen formatierten String. Der Parameter format entspricht dem der Funktion printf (siehe weiter unten).

substr(string, start [, length])

Liefert einen Teilstring aus string ab der Position start (mit der maximalen Länge length).

tolower(string)

Wandelt den String string in lauter Kleinbuchstaben um und gibt diesen String zurück.

toupper(string)

Wandelt den String string in lauter Großbuchstaben um und gibt diesen String zurück.

I/O-Funktionen

print

Verwendungsformen:

• print: Gibt $0 aus
• print "": Gibt eine Leerzeile aus
• print item1, item2, ...: Gibt item1, item2, ... aus (Trennzeichen entspricht dem Inhalt von OFS).
• print item1, item2, ... > filename: Schreibt aber in eine Datei filename (überschreibend).
• print item1, item2, ... >> filename: Schreibt aber in eine Datei filename (anhängend).
• print item1, item2, ... | kommando: Schreibt in die Standardeingabe von kommando

printf format, item1 [, item2, ...]

Formatierte Ausgabe. Auch die printf-Anweisung kann analog zur print-Anweisung in eine Datei umgeleitet oder mit einem externen Kommando verknüpft werden.

Der Formatstring format wird in der Form

%[modifizierer]formatangabe

spezifiziert.

modifizierer	Beschreibung
Leerzeichen	Positive Zahl: Leerzeichen, Negative Zahl: -
+	Positive Zahl: +, Negative Zahl: -
-	Links ausrichten
0	Nullen anstelle von Leerzeichen als führende Zeichen
#	Verwende in einigen Fällen ein alternatives Format
width	Mindestanzahl der auszugebenden Zeichen
.precision	Anzahl der Nachkommastellen oder maximale Zahl der auszugebenenden Zeichen

formatangabe	Beschreibung
d, i	Ganzzahlige Dezimalzahl
o	Ganzzahlige Oktalzahl
x, X	Ganzzahlige Hexadezimalzahl
c	ASCII-Zeichen (character)
e, E	Gleitkommazahl einfacher Genauigkeit in wissenschaftlicher Notation (z.B. -3.56e-5 oder 5.888E+13)
f, F	Gleitkommazahl einfacher Genauigkeit (z.B. 3.1415)
g, G	Gleitkommazahl in normaler oder wissenschaftlicher Darstellung
s	Zeichenkette (string)
%%	Das Zeichen %

Beispiele:

Anweisung	Ausgabe (Underscores _ symbolisieren Leerzeichen)
printf "%s", "Hallo"	Hallo
printf "%12s", "Hallo"	_______Hallo
printf "%.2s", "Hallo"	Ha
printf "%-12s", "Hallo"	Hallo_______
printf "%s\n%s" , "Hallo", "Welt"	Hallo Welt
printf "%c", 90	Z
printf "%5d", 12	___12
printf "%-5d", 12	12___
printf "%05d", 12	00012
printf "%o", 12	14
printf "%x", 12	c
printf "%X", 12	C
printf "%#x", 12	0xc
printf "%d", 3.1415	3
printf "%f", 3.1415	3,1415
printf "%8.3f", 3.1415	3,142
printf "%8.3g", 31415000.4	3,14e+07
printf "%+8.3g", 31415000.4	+3,14e+07

getline

Während die print- und printf-Anweisungen der Ausgabe dienen, ist die getline-Anweisung für Eingabeoperationen von Bedeutung.

Verwendungsformen:

• getline: Liest den nächsten Datensatz der aktuellen Eingabedatei in die Variable $0.
• getline var: Liest den nächsten Datensatz der aktuellen Eingabedatei in die Variable var.
• getline < filename: Liest den nächsten Datensatz aus der Datei filename in die Variable $0.
• getline var < filename: Liest den nächsten Datensatz aus der Datei filename in die Variable var.
• kommando | getline: Liest aus der Standardausgabe von kommando in die Variable $0.
• kommando | getline var: Liest aus der Standardausgabe von kommando in die Variable var.

Rückgabewert:

• 0: Dateiende
• 1: Erfolg, Datensatz konnte gelesen werden
• -1: Fehler

close(filename [,how])

Schließt die Datei oder das Kommando filename für I/O-Operationen. Der how-Parameter kann "to" oder "from" sein, je nachdem welche Seite der Pipe geschlossen werden soll.

Weitere Funktionen

system(kommando)

Führt das Kommando kommando aus.

Rückgabewert: Statuswert des ausgeführten Kommandos

Beispiel: Folgendes awk-Skript startet das Unix-Kommando ls

#!/usr/bin/awk -f
BEGIN {system("ls")}

Kontrollstrukturen

Block

Ein zusammengehörender Block von Anweisungen ist durch geschweifte Klammern {} einzufassen. Die Trennung der einzelnen Anweisungen erfolgt durch Separierung der Anweisungen in einzelne Zeilen oder mittels Semikolon ;.

{
  anweisung1
  anweisung2
  ...
  anweisungN
}

Verzweigung

Beschreibung:

WENN (bedingung IST WAHR) DANN
  ...
SONST
  ...

In awk:

if(bedingung)
  block oder anweisung

oder

if(bedingung)
  block1 oder anweisung1
else
  block2 oder anweisung2

oder

var = (bedingung)?wertTrue:wertFalse

Beispiel:

#!/usr/bin/awk -f 
BEGIN {  
  x=5

  if(x<=3)
    print "kleiner"
  else
    print "größer"
} 

Ausgabe:

größer

Beispiel:

#!/usr/bin/awk -f 
BEGIN {  
  x=5  
  y = (x<=3) ? "kleiner" : "größer"  
  print y 
} 

Ausgabe:

größer

Schleifen

awk erlaubt kopfgesteuerte und fußgesteuerte Schleifen.

Kopfgesteuert:

while(bedingung)
  block oder anweisung

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  while(i<5)
  {
    i++
    print i
  }
}

Ausgabe:

1 
2 
3 
4 
5

Fußgesteuert:

do
  block oder anweisung
while(bedingung)

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  i=10
 
  do
  {    
    print ++i
  } while(i<5)
}

Ausgabe:

11

Die Schleife wird mindestens einmal durchlaufen, auch wenn die Bedingung falsch ist.

Zählschleifen

for-Schleife

A ... expr1
B ... bedingung
C ... expr2
D ... block oder anweisung

for(expr1;bedingung;expr2)
  block oder anweisung

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  for(i=1; i<=5; i++)
  {
    print i
  }
}

Ausgabe:

1
2
3
4
5

Eine Endlosschleife kann folgendermaßen realisiert werden

for(;;)

for-in-Schleife

Auch Arrays können mittels Zählschleife durchlaufen werden.

for(var in array)
  block oder anweisung

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  a[0] = 10
  a[1] = 11
  a[2] = 12

  for(i in a)
  {
    print a[i]
  }
}

Ausgabe:

10 
11 
12

Kontrollierte Sprünge

Break

Eine Schleife kann auch mittels Setzen der break-Anweisung verlassen werden.

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  for(;;)
  {
    print i++

    if(i>10)
      break
  }
}

Continue

Beim Erreichen einer continue-Anweisung wird nur der aktuelle Schleifendurchlauf abgebrochen und mit dem nächsten Schleifendurchlauf fortgesetzt.

Beispiel:

#!/usr/bin/awk -f 
BEGIN {
  for(i=0;i<=3;i++)
  {
    if(i==2)
      continue 

    print i++
  }
}

Ausgabe:

0
1 
3

Next

Beim Erreichen einer next-Anweisung stoppt awk die Bearbeitung des aktuellen Datensatzes und geht direkt zum nächsten Datensatz über.

Exit

Ein Erreichen einer exit-Anweisung bewirkt die sofortige Beendigung der Skriptausführung und der Einleseoperationen. Eine allfällige Aktion für eine END-Bedingung wird allerdings noch ausgeführt. Einer exit-Anweisung kann auch ein Rückgabewert mitgegeben werden, z.B. exit 0.

Zum Übungsteil

Zurück zu Reguläre Ausdrücke | Hoch zu Grundlagen-Inhaltsverzeichnis | Vor zu awk-Einstellungen