Schleifen

Schleifen und mehr

Schleifen sind ein grundlegendes Element jeder Programmiersprache. Perl hat alles was eine Programmiersprache braucht - also auch Schleifen. Mit Schleifen kann man einen Block von Befehlen wiederholen.

Die for-Schleife

Die for-Schleife teilt sich auf in Kopf und Anweisungsblock:

for (init.; test; inkr.) # Kopf
{           # Beginn des Anweisungsblock
  befehl1;
  befehl2;
  ...
}           # Ende des Anweisungsblocks

Was passiert da? Also als erstes wird der Teil init. im Kopf ausgeführt. In der Regel steht dort eine Variableninintialisierung - und zwar der sog. Schleifenvariablen - (z. B. $i=0), jedoch kann man dort auch irgendetwas anderes einbauen - ob das nun sinnvoll ist, ist wieder eine andere Frage. Der zweite Teil des Kopfes ist ein Test auf Durchführung der Schleife (falls der Test true liefert) oder Abbruch der Schleife (falls der Test false liefert). Der Test wird nach der Initialisierung ausgeführt und kann z. B. so Aussehen: $i<=10. Anschließend werden die Befehle im Anweisungsblock - das ist alles, was zwischen den beiden Klammern {} steht - abgearbeitet. Ist das geschehen, wird der letzte Teil des Kopfes behandelt. Dort wird in der Regel die Schleifenvariable hochgezählt (z. B. $i++). Danach wird ab dem zweiten Teil des Kopfes alles wiederholt.

Ein Beispiel:

# Ausgabe der Zahlen 0..9
for ($i=0; $i<10; $i++) {
print "$i\n";
}

Im einzelnen geschieht hier folgendes:

Schritt	Beschreibung	Wert von $i	Wert des Tests
1	Standardvariable $i auf 0 setzen	0
2	Teste, ob Schleife ausgeführt werden soll		true
3	Drucke Wert von $i auf dem Bildschirm aus (das ist 0) gefolgt von einem Zeilenumbruch
4	Erhöhe $i um 1	1
5	Teste, ob Schleife ausgeführt werden soll		true
...	...
28	erhöhe $i	9
29	Teste, ob Schleife ausgeführt werden soll		true
31	Ausgabe von 9
32	erhöhe $i	10
33	Teste, ob Schleife ausgeführt werden soll		false
34	Schleife ist beendet, da der Test false ergibt

Die while-Schleife

Die while-Schleife ist etwas einfacher aufgebaut als die for-Schleife:

while(test) # Kopf
{           # Beginn des Anweisungsblocks
  befehl1;
  befehl2;
  ...
}           # Ende des Anweisungsblocks

Die while-Schleife besitzt ebenfalls einen Kopf und einen Anweisungsblock. Im Kopf wird vor jedem Durchlauf der Schleife getestet, ob die Schleife durchlaufen werden soll oder nicht. Falls der Test true ergibt, dann werden die Befehle im Anweisungsblock abgearbeitet; ergibt der Test false, dann wird die Schleife nicht (mehr) durchlaufen. Kurz könnte man sagen: "Solange der Test stimmt arbeite den Block ab."

Die until-Schleife

Die until-Schleife ist analog zur while-Schleife aufgebaut. Einziger Unterschied: Im Kopf der Schleife wird getestet, ob der Anweisungsblock nicht abgearbeitet werden soll.

until(test) # Kopf
{           # Beginn des Anweisungsblocks
  befehl1;
  befehl2;
  ...
}           # Ende des Anweisungsblocks

Die Schleife wird solange durchlaufen, bis der Test im Kopf true ergibt. Kurz könnte man sagen: "Arbeite den Block ab bis der Test wahr ist."

Die do-while-Schleife

Etwas anders funktioniert die do-while-Schleife. Es wird zuerst der Block abgearbeitet und dann geprüft, ob die Schleife weiter durchgeführt werden soll. Solange der Test wahr ergibt, wird weitergemacht, beim ersten false wird aufgehört.

do {
  befehl1;
  befehl2;
  ...
} while (test)

Die do-until-Schleife

Analog zur do-while-Schleife funktioiert die do-until-Schleife. Es wird zuerst der Block abgearbeitet und dann geprüft, ob die Schleife weiter durchgeführt werden soll. Es wird solange der Block durchgearbeitet, bis das erste Mal true getestet wird.

do {
  befehl1;
  befehl2;
  ...
} until (test)

Die foreach-Schleife

Die foreach-Schleife ist speziell für Arrays gemacht und ähnelt der for-Schleife:

foreach $element (@einArray) # Kopf
{           # Beginn des Anweisungsblocks
  befehl1;
  befehl2;
  ...
}           # Ende des Anweisungsblocks

Es werden einfach die Elemente des Arrays nacheinander durchlaufen.

Beispiele dazu:

# gibt vier Namen aus
foreach $element ("hans","fritz","franz","bob"){
  print $element."\n";
}

@Studenten=("hans","fritz","franz","bob");
# gibt die vier Studenten aus
foreach $element (@Studenten){
  print $element."\n";
}

# gibt die vier Studenten sortiert aus
foreach $element (sort(@Studenten)){
  print $element."\n";
}

foreach $element (sort(@Studenten)){
  $element.="XXX";
}
# gibt die vier Studenten sortiert aus wie oben
foreach $element (sort(@Studenten)){
  print $element."\n";
}

# verändert die Elemente von @Studenten
foreach $element (@Studenten){
  $element.="XXX";
}

Es braucht nicht unbedingt eine Arrayvariable übergeben werden.
Man benötigt keinen Zugriffsoperator.
Es kann auch ein Ergebnis eines Operators bzw. einer Funktion - falls es ein Array zurückgibt - an die foreach-Schleife übergeben werden.
Wird eine Arrayvariable übergeben, so wird per Referenz auf das Array zugegriffen; d. h., man arbeitet nicht mit einer Kopie eines Arrayelements, sondern mit dem Element selbst.

Vorzeitiges beenden einer Schleife mit last

Mit Hilfe des Befehls last kann man eine Schleife vorzeitig beenden:

@z=(1..10,-3,11..14);
foreach $z (@z) {
print $z.", ";
if ($z<0) { last; }
}

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3,

<STDIN> und while

Um mehrere Zeilen aus der Standardeingabe einzulesen, bedient man sich einer while-Schleife und dem <STDIN>-Operator:

$dieEingabe="";
$ausSTDIN="";
while ($ausSTDIN=<STDIN>) {
  # lese solange bis undef (wird
  # dann als false gelesen) kommt
  $dieEingabe.=$ausSTDIN
}

# oder kürzer
$dieEingabe="";
while(<STDIN>) {
  $dieEingabe.=$_;
}

Es wird zeilenweise von der Standardeingabe gelesen und in der Variablen $dieEingabe abgelegt.
Der Abbruch geschieht - genauso wie bei den Arrays - dann, falls undef eingegeben wird. Dieses wird unter DOS mit <Strg>-z und <RETURN> bzw. <Strg>-y und <RETURN> erzeugt. Unter UNIX geschieht das mit <Ctrl>-d (<Strg> entspricht <Ctrl>).
Im zweiten Beispiel wird völlig auf eine Variable verzichtet. Dazu gleich mehr ...

die Spezialvariable $_

Wenn man den Namen der Skalarvariablen weglässt, so speichert Perl bei bestimmten Operationen den Wert automatisch in die Spezialvariable $_. Dies erspart ... Zeit? ... Platz? ... Kompliziertheit? ... Klarheit?
Ok - diese Variable gibt's, also benutzen wir sie auch. Ein Beispiel kennen wir schon; hier das nächste:

@Array=(1..10);
foreach $a (@Array){
print $a;
}

# kürzer mit $_
foreach (@Array){
print; # statt $a jetzt $_ verwendet
}

Der print-Operator versteht also auch die implizite Variable $_: Werden ihm keine anderen Variablen übergegeben, dann kommt $_ zum Zuge.

Perl, Lehrstuhl Mathe II, Uni Bayreuth