Kontakt aufnehmen
Wir stellen ein: PHP-Entwickler (m/w/d) Key Account Manager (m/w/d)

CGI: Kontrollstrukturen

Die Kontrollstrukturen in Perl wie bedingte Anweisungen und Schleifen ähneln im Großen und Ganzen denen anderer Programmiersprachen. Darüber hinaus existieren aber auch besondere Konstrukte mit einfacher Handhabung.

Bedingte Anweisungen

Der einfachste aller Kontrollmechanismen ist es, die Ausführung von Anweisungen von der Erfüllung von Bedingungen abhängig zu machen.
Die reservierten Begriffe if ("wenn"), elsif ("oder wenn"), else ("oder") und unless ("wenn nicht") können in Perl eine Bedingung einleiten. Dem Programmierer ist es dabei mehr oder weniger freigestellt, ob er die Bedingung(en) vor oder nach der Anweisung, deren Ausführung von der (den) Bedingung(en) abhängig sein soll, notieren möchte. Die vorangestellte Variante ist jedoch die am häufigsten anzutreffende, da sie die Ausführung mehrerer Anweisungen nach Erfüllung einer (komplexen) Bedingung erlaubt.

Vorangestellte Bedingungen mit if ,else, elsif und unless

Die einfachste bedingte Anweisung ist die mit der einfachen if-Bedingung:

$Zahl = 1;                
if ($Zahl < 1){ print "Zahl ist kleiner 1"; }

if erwartet als Argument eine Bedingung, welche true (wahr) oder false (unwahr) sein kann. Ist diese Bedingung wahr, wird der nachstehende Anweisungsblock ausgeführt. Der Begriff Anweisungsblock deutet bereits auf eine wichtige Notationsregel hin: Die Anweisungen, welche hinter einer Bedingung stehen, müssen stets - auch, wenn es nur eine ist - in geschweiften Klammern notiert werden.

Mithilfe des Begriffs else lässt sich zum if-Zweig ein alternativer Zweig konstruieren, dessen Anweisungen dann ausgeführt wird, wenn die darüber notierte if-Bedingung nicht erfüllt ist:

if ($Zahl < 1){ print "Zahl ist kleiner 1"; }
else { print "Zahl ist größer oder gleich 1"; }

Mit dem reservierten Begriff elsif können weitere Bedingungen angeknüpft werden, deren Auswertung jedoch nur erfolgt, wenn die davor notierten Bedingungen sämtlich unwahr sind:

if ($Zahl < 1){ print "Zahl ist kleiner 1"; }
elsif ($Zahl >= 2){ print "Zahl ist größer 2 oder gleich 2"; }
else{ print "Zahl ist größer oder gleich 1 und kleiner 2"; }

Bezogen auf das Beispiel hieße das, dass das Argument $Zahl >= 2 nur das überprüft wird, wenn $Zahl größer oder gleich 1 ist, d.h. die Auswertung von $Zahl < 1 den Wert false ergibt.

Das Gegenteil der if-Bedingung ist die Bedingung mit unless, deren Anweisungsblock nur dann ausgeführt wird, wenn die Auswertung der Bedingung den Wert false liefert:

unless($Zahl < 1){ print "Zahl ist größer oder gleich 1"; }

Nachgestellte Bedingungen mit if und unless

Möchte man die Ausführung lediglich einer (!) Anweisung von einer (komplexen) Bedingung abhängig machen, so erlaubt Perl die Notation der Bedingung nach der Anweisung, deren Ausführung von ihr abhängen soll. Geschweifte Klammern fallen in diesem Fall weg:

print "Zahl ist kleiner 1" if ($Zahl < 1);
print "Zahl ist größer oder gleich 1" unless ($Zahl < 1);

Des Weiteren ist hier zu beachten, dass die Verknüpfung von Anweisung und Bedingung vom Perl-Interpreter als eine Bedingung interpretiert wird, so dass der Strichpunkt (;) wie bei Anweisungen üblich erst am Ende der Zeile (hinter der Bedingung) notiert wird.

Alternative zur einfachen if-else-Konstruktion

Unter Verwendung des Operators ?: können einfache if-else-Konstruktionen in Perl verkürzt dargestellt werden, wobei pro Zweig nur eine Anweisung notiert werden kann, da die Notation von geschweiften Klammern auch hier wegfällt:

$Zahl < 1 ? 
  print "Zahl ist kleiner 1" : 
  print "Zahl ist größer oder gleich 1";

#verkürzt für:
if ($Zahl < 1){ print "Zahl ist kleiner 1"; }
else{ print "Zahl ist größer oder gleich 1"; }

Die Anweisung des if-Zweiges wird bei dieser Schreibweise also hinter dem Fragezeichen (?) und die des else-Zweiges hinter dem Doppelpunkt (:) notiert.
Hier ist wiederum zu beachten, dass der gesamte Ausdruck vom Perl-Interpreter als eine einzige Bedingung interpretiert wird, so dass der Strichpunkt (;) wieder erst am Ende der Zeile notiert werden muss.

Schleifen

Die Anwendung von Schleifen ist immer dann sinnvoll, wenn Anweisungen mehrmals ausgeführt werden sollen. Für die unterschiedlichen Anforderungen gibt es in Perl unterschiedliche Schleifentypen.

while-Schleifen

Bei while-Schleifen wird zunächst die oberhalb des Schleifenkörpers notierte Bedingung überprüft, welche als Ausführungsbedingung der Schleife gilt. Denn nur, wenn die Auswertung dieser true ergibt, wird der nachfolgende Schleifenblock ausgeführt, solange die Auswertung der einleitenden Bedingung false liefert:

$Zahl = 0;

while($Zahl < 4) #"solange $Zahl kleiner 4"
{
  print "Zahl ist kleiner 4:";
  print $Zahl; #Gibt Wert von $Zahl, also im Endeffekt 0123, aus
  $Zahl++;     #Inkrementation von $Zahl
}

until-Schleifen

Einfache until-Schleifen funktionieren im Prinzip ähnlich wie einfache while-Schleifen, mit dem einzigen Unterschied, dass die Ausführungsbedingung anders formuliert wird. Hier wird nämlich der nachfolgende Schleifenblock ausgeführt wird, bis die Auswertung der einleitenden Bedingung true liefert:

$Zahl = 0;

until($Zahl == 4) #"bis $Zahl gleich 4"
{
  print "Zahl ist kleiner 4:";
  print $Zahl; #Gibt Wert von $Zahl, also im Endeffekt 0123, aus
  $Zahl++;     #Inkrementation von $Zahl
}

do-while und do-until Schleifen

While- und until-Schleifen lassen sich auch mit der do-Schleife kombinieren:

$Zahl = 0;

do
{                                
  print "Zahl ist kleiner 4:";
  print $Zahl;
  $Zahl++;     #Inkrementation von $Zahl
}
while($Zahl < 4) #"solange $Zahl kleiner 4"

#oder:

do
{                                
  print "Zahl ist kleiner 4:";
  print $Zahl; 
  $Zahl++;     #Inkrementation von $Zahl
}
until($Zahl == 4) #"bis $Zahl gleich 4"

Dies führt von der Ausgabe her zum selben Ergebnis wie bei den beiden einfachen Formen. Bei diesen beiden Konstrukten wird der Schleifenblock jedoch ausgeführt, bevor die Bedingung (erstmals) geprüft wird. In Bezug auf die do-until-Schleife hat dies den Vorteil, dass die von der Bedingung abhängigen Anweisungen im Schleifenblock auf jeden Fall mindestens einmal ausgeführt werden, wobei es bei dem einfachen until-Konstrukt passieren kann, das der Anweisungsblock der Schleife nie ausgeführt wird, da die Ausführungsbedingung von vornherein unwahr ist.

for-Schleifen

Diese Art einer Schleife beruht auf einer Zählvariablen, welche vorgibt, wie oft der Anweisungsblock der Schleife ausgeführt wird. Anders als bei den anderen Schleifenkonstrukten wird ihr Wert jedoch einem bestimmten Prinzip folgend außerhalb des Anweisungsblocks verändert:

for($Zahl = 0; $Zahl < 4; $Zahl++) 

  print $Zahl;
}

Die erste Anweisung des for-Arguments initialisiert die Zählvariable $Zahl mit dem Anfangswert 0. Darauf folgend wird die Abbruchsbedingung der Schleife - zwangsläufig ein Endwert der Zählvariable $Zahl - (hier: (wenn) $Zahl < 4) formuliert. Die letzte Anweisung des for-Arguments gibt an, auf welche Weise der Wert der Zählvariable $Zahl verändert werden soll (hier: Inkrementation).
Der nachfolgende Schleifenblock wird also ausgeführt, bis die Auswertung der Abbruchsbedingung true liefert, also die Zählvariable ihren Endwert erreicht hat.
In Bezug auf Listen kann man eine for-Schleife ähnlich wie eine foreach-Schleife einsetzen:

for (0..3)
{
  print $_;
  #Gibt akt. Element der Liste aus 
}

foreach-Schleifen

Dieser Schleifentyp kann in Perl auf Listen bzw. Arrays angewendet werden. Die Schleife wird dann sooft ausgeführt, wie Elemente in der Liste bzw. in dem Array enthalten sind:

#Listen:
foreach (0..3)
{
  print $_;
  #Gibt akt. Element der Liste aus 
}

#oder:

foreach $Zahl (0..3)

  print $Zahl;
  #Gibt akt. Element der Liste (Wert von $Zahl) aus
}


#Arrays:

@Array = ("String",4,6,"String2");

foreach (@Array) 

  print $_;
  #Gibt akt. Element von @Array aus
}

#oder:

foreach $Elem (@Array) 

  print $Elem; 
  #Gibt akt. Element von @Array (Wert von $Elem) aus
}

Die spezielle Variable $_ enthält in der Schleife standardmäßig den Wert des aktuellen Elements der Liste bzw. des Arrays. Durch Notation eines selbst gewählten Variablenamens zwischen foreach und dem dazugehörigen Argument kann man dieser selbst gewählten Variable den Wert von $_ zuweisen.

Weiterlesen: ⯈ Programmsteuerung

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Karriere bei a coding project - Wir freuen uns auf dich!

Alle unsere Stellen sind Remote oder an unseren Standorten in Münster und Wuppertal verfügbar:

// Warum Du Dich für uns entscheiden solltest

  • Regelmäßig neue Projekte, die Du von Grund an mit planen und aufbauen kannst
  • Arbeit in einem wachsenden IT-Unternehmen
  • So viel Home-Office wie Du möchtest - Und einen Arbeitsplatz in unserem Büro in Münster
  • Wöchentliche Vorträge: Jeden Freitag hält ein Mitarbeiter einen Vortrag über ein Fachthema seiner Wahl
Karriere

Cookie-Einstellungen

Helfen Sie dabei, uns noch besser zu machen. Wir nutzen Cookies und ähnliche Technologien, um die Website auf Ihre Bedürfnisse anzupassen. Zur Datenschutzerklärung

Auswahl speichern