Perl/Schleifen

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

[Bearbeiten] for-Schleifen

for-Schleifen in Perl verhalten sich, je nach Zahl ihrer Parameter, verschieden.

[Bearbeiten] for(Initialisierung; Schleifen-Bedingung; Continue-Anweisung){ ... }

Die Form mit drei Parametern ist aus der Sprache C übernommen und eignet sich für numerisches Iterieren.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Deutsch = qw( Januar Februar März April);
my @Franzoesisch = qw( janvier fevrier mars avril);
my @Italienisch = qw( gennaio febbraio marzo aprile);
my @Englisch = qw( january february march april);
 
my $out = sprintf( "%-12s %-12s %-12s %-12s\n",
      "Deutsch",
      "Französisch",
      "Italienisch",
      "Englisch",
   );
 
for(my $i = 0; $i < @Deutsch; $i++) {
  $out .= sprintf( "%-12s %-12s %-12s %-12s\n",
      $Deutsch[$i],
      $Franzoesisch[$i],
      $Italienisch[$i],
      $Englisch[$i],
   );
}
print "Content-type:text/plain\n\n",$out;
Das Script gibt die ersten Vier Monate des Jahres in vier Sprachen aus und listet sie tabellarisch auf.

Zuerst werden die Monatsnamen in vier Arrays gespeichert. Danach folgt eine formatierte Titelzeile für die Ausgabe. (Siehe sprinf())

In der for Schleife wird der Iteratier mit my $i=0 initialisiert. Danach wird bei jedem Durchgang der Schleife zuerst geprüft, ob die Bedingung $i < @Deutsch wahr ist. Da @Deutsch 4 Array-Elemente enthält, wird die Bedingung genau dann falsch, wenn $i=4. Am Ende der Schleife wird durch $i++ $i um 1 inkrementiert.

Im Anschluss an das for-Konstrukt folgt ein Anweisungsblock, markiert wie üblich durch geschweifte Klammern { und }. Dazwischen können beliebig viele Anweisungen stehen. Diese Anweisungen werden so oft ausgeführt, wie die Schleife durchlaufen wird.

Im Beispiel wird die Ausgabe vorbereitet, indem bei jedem Durchgang das Element aus jedem der vier Sprach-Arrays in einen formatierten String geschrieben wird.

Dabei wird der Schleifenzähler $i zur Abfrage des Arrayelements verwendet.

[Bearbeiten] for(Liste){...}

In der Form mit einem Parameter ist die for-Schleife identisch mit foreach(){}. In dieser Form ist sie nützlich wie folgt.

Beispiel
my $variable = <>;
chomp $variable;
 
for($variable){
  /^q/i and quit();
  /^s/i and save();
  /^v/i and verbose();
  /^h/i and help();
}
Im Beispiel wird die Usereingabe in $variable gespeichert und der linefeed aus der Eingabe entfernt (Siehe chomp)

mit for($variable) wird der Wert von $variable im Standard-Schleifen-Alias $_ gespeichert. Dadurch sind sehr kompakt notierte Abfragen möglich.

/^q/i and quit(); ist expliziter $_ =~ /^q/i and quit();

Siehe auch perldoc perlsyn#For-Loops

[Bearbeiten] foreach-Schleifen

Diese Sorte Schleifen ist in Perl speziell für das Durchlaufen von Listen und Arrays gedacht. Eine Liste wird dabei Element für Element abgeklappert. Abhängig davon können Sie Anweisungen ausführen.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
 
 
my @Sachen = ("mein Haus","mein Auto","mein Boot");
foreach (@Sachen) {
  print "$_<br>\n";
}
 
my @Schwaechen = ("Nikotin","Alkohol","das andere Geschlecht");
my $Schwaeche;
foreach $Schwaeche (@Schwaechen) {
  print "$Schwaeche<br>\n";
}
 
print "</body></html>\n";
Das Beispiel zeigt zwei leicht abweichende Varianten, mit einer foreach-Schleife umzugehen. In beiden Fällen wird jeweils ein Array deklariert und mit Anfangswerten versehen, einmal @Sachen und einmal @Schwaechen. Hinter dem Schlüsselwort foreach wird in Klammern einfach der Array angegeben. In dem Anweisungsblock, der dahinter in geschweiften Klammern folgt, können beliebig viele Anweisungen stehen.

Im ersten der obigen Beispiele wird von der vordefinierten Variablen $_ Gebrauch gemacht. In ihr ist im Anweisungsblock einer foreach-Schleife stets der aktuelle Wert des Schleifendurchlaufs gespeichert, was in diesem Fall das jeweils aktuelle Element des Arrays @Sachen ist.

Im zweiten Beispiel wird anstelle von $_ ein eigener Skalar namens $Schwaeche benutzt. Wenn ein solcher Skalar zwischen dem Schlüsselwort foreach und der Klammer mit dem Array notiert wird, ist im Anweisungsblock in diesem Skalar jeweils der aktuelle Wert des Schleifendurchlaufs enthalten, im zweiten Beispiel also der jeweils aktuelle Wert aus @Schwaechen.
Beachten Sie: Die Schlüsselwörter for und foreach besitzen zwar jeweils einen semantisch anderen Hintergrund, sind aber syntaktisch beliebig gegeneinander austauschbar. Perl erkennt selbständig, was für einen Typ Schleife Sie verwenden wollen. So können Sie beispielsweise auch folgendes schreiben:
for(1 .. 1000) {
  print "tausendmal berührt\n";
}
Der Code gibt einfach tausendmal den Text aus, ist aber im Grunde eine foreach-Schleife, welche die Liste der Zahlen von 1 bis 1000 abarbeitet.

[Bearbeiten] while-Schleifen

Diese Art von Schleifen eignet sich, wenn Sie vorher nicht wissen, wie oft die Schleife durchlaufen wird. Sie formulieren einfach eine Bedingung, und die Schleife wird so oft durchlaufen, wie die Bedingung wahr ist. Dass die Bedingung irgendwann falsch und die Schleife beendet wird, dafür müssen Sie im Anweisungsblock, der von der Schleife abhängig ist, selber sorgen.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
 
my $Startzeit = time();
my $Endzeit = $Startzeit + 1;
my $Jetztzeit = 0;
my $i = 0;
 
while ($Jetztzeit <= $Endzeit) {
  $Jetztzeit = time();
  $i++;
}
print "$i mal durchlaufen<br>";
 
print "</body></html>\n";
Das Script ermittelt zunächst mit der Perl-Funktion time den aktuellen Zeitpunkt und speichert das Ergebnis im Skalar $Startzeit. Gespeichert wird dabei eine Zahl, nämlich die Anzahl Sekunden vom 1.1.1970, 0.00 Uhr bis zum aktuellen Zeitpunkt. Dann wird ein Skalar $Endzeit deklariert, der einen Wert zugewiesen bekommt, der um 1 höher ist als der von $Startzeit. Zwei weitere Skalare $Jetztzeit und $i werden deklariert und mit 0 initialisiert.

Die Schleife wird durch das Schlüsselwort while eingeleitet. In Klammern wird eine Bedingung formuliert. Im Beispiel wird die Bedingung "$Jetztzeit kleiner oder gleich $Endzeit" formuliert. Hinter der Bedingung folgt in geschweiften Klammern ein Anweisungsblock mit beliebig vielen Anweisungen. Ausgeführt werden diese Anweisungen so oft, wie die Schleife durchlaufen wird und die Bedingung noch wahr ist.

Die Schleifenbedingung ist im Beispiel ja zunächst auf jeden Fall wahr, da $Jetztzeit mit 0 initialisiert wurde und daher auf jeden Fall kleiner ist als $Endzeit. Innerhalb der Schleife bekommt $Jetztzeit jedoch durch Aufrufen der Funktion time einen neuen Wert zugewiesen, der logischerweise mindestens so hoch ist wie der von $Startzeit. Die Schleife wird dadurch so lange durchlaufen, bis $Jetztzeit durch den time-Aufruf einen Wert zugewiesen bekommt, der größer ist als $Endzeit. Dann wird die Schleife beendet. Wie oft das der Fall ist, wissen Sie natürlich vorher nicht, insofern ist die while-Schleife hier ideal.

Innerhalb der Schleife wird außerdem noch $i als Zählervariable mit $i++ jeweils um 1 erhöht. Der aktuelle Wert von $i wird nach Ablauf der Schleife ausgegeben. Im Fenster des aufrufenden Browsers wird man also am Ende sehen können, wie oft die Schleife durchlaufen wurde.

[Bearbeiten] do-Schleifen

Bei while-Schleifen kann es passieren, dass die abhängigen Anweisungen nie ausgeführt werden, nämlich dann, wenn die Schleifenbedingung schon beim ersten Schleifendurchlauf unwahr ist. Eine do-Schleife sorgt dafür, dass die Anweisungen auf jeden Fall einmal ausgeführt werden, da die Bedingung der Schleife erst am Ende abgeprüft wird.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
 
my $Bedingung = "Abbruch";
my $Irgendwas;
do {
 $Irgendwas = $Bedingung;
 print "Hier steht $Irgendwas";
} until ($Irgendwas eq $Bedingung);
 
print "</body></html>\n";
Das Beispiel demonstriert die typische Funktionsweise einer solchen Schleife. Zunächst wird ein Skalar $Bedingung mit dem Anfangswert Abbruch versehen. Ein weiterer Skalar namens $Irgendwas wird deklariert, erhält aber keinen Wert. Die Schleife wird mit do eingeleitet. Dahinter folgt in geschweiften Klammern ein Anweisungsblock, der beliebig viele Anweisungen enthalten kann. Im Beispiel wird dem Skalar $Irgendwas gleich zu Beginn der Wert von $Bedingung zugewiesen, also Abbruch. Anschließend wird dieser Inhalt zur Kontrolle ausgegeben. Nach der schließenden geschweiften Klammer, die den Anweisungsblock beendet, ist das Wort until notiert und dahinter in Klammern die eigentliche Schleifenbedingung. Im Beispiel wird abgeprüft, ob $Irgendwas und $Bedingung gleich sind, also den gleichen Inhalt haben. Da dies ja innerhalb der Schleife zugewiesen wurde, ist die Schleifenbedingung also erfüllt. Damit wird die Schleife abgebrochen. Denn until ist wie "solange bis" zu lesen. Im Gegensatz zur while-Schleife, deren Anweisungsblock ausgeführt wird, solange die Bedingung wahr ist, wird hier der Anweisungsblock ausgeführt, bis die Schleifenbedingung wahr ist. Im Beispiel wird die Schleife einmal durchlaufen, obwohl die Schleifenbedingung gleich im ersten Durchlauf wahr ist. Der Grund ist eben, dass zuerst der abhängige Code ausgeführt und erst dann die Bedingung überprüft wird.
Beachten Sie: do-Schleifen sind eigentlich keine echten Schleifen, weshalb dort Sprungbefehle wie last, next und redo nicht funktionieren.

Es gibt in Perl auch do-Schleifen, deren Bedingung kein until, sondern ein while vorangestellt ist. Dann müssen Sie die Schleifenbedingung negativ formulieren.

[Bearbeiten] Schleifen bei Hashes

So wie sich Arrays prima mit [#foreach-Schleifen| foreach]-Schleifen "traversieren", also Element für Element durchlaufen lassen, besteht dieser Wunsch natürlich auch bei Hashes. Da ein Hash-Element jedoch immer aus zwei Werten besteht, von denen der erste der Schlüssel ist und der zweite der eigentliche Datenwert, stehen zwei Methoden zur Verfügung, entweder durch den keys-Operator oder den each-Operator.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
 
my %Familie = (Frau => "Eva", Tochter => "Anja", Sohn => "Florian");
 
foreach my $schluessel (keys %Familie) {
   print $schluessel, " hei&szlig;t ", $Familie{$schluessel}, "<br>\n";
}
 
foreach (keys %Familie) {
   print $_, " hei&szlig;t ", $Familie{$_}, "<br>\n";
}
 
print "</body></html>\n";
Im Beispiel wird die Schleife dreimal durchlaufen und gibt solche Sätze aus wie Frau heißt Eva.

Das Beispiel deklariert einen Hash namens %Familie und weist ihm drei Schlüssel-Wert-Paare zu. Anschließend wird $schluessel als Iterator-Alias definiert. Innerhalb der Schleifenbedingung wird mit keys über alle Hashkeys iteriert. Mit $Familie{$schluessel} wird der Hashwert ausgegeben.

In einer zweiten Variante wird auf einen expliziten Alias verzichtet und statt dessen der Standard Iterator-Alias S_ verwendet und mit $Familie{$_} der Hashwert ausgegeben.


Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Testausgabe</title>\n";
print "</head><body>\n";
 
my %Familie = (Frau => "Eva", Tochter => "Anja", Sohn => "Florian");
my $Schluessel;
my $Wert;
 
while (($Schluessel, $Wert) = each(%Familie)) {
   print $Schluessel, " hei&szlig;t ", $Wert, "<br>\n";
}
 
while ($Schluessel = each(%Familie)) {
   print $Schluessel, " hei&szlig;t ", $Familie{$Schluessel}, "<br>\n";
}
 
print "</body></html>\n";
Das Beispiel deklariert einen Hash namens %Familie und weist ihm drei Schlüssel-Wert-Paare zu. Anschließend werden zwei Skalare $Schluessel und $Wert deklariert, die innerhalb der Schleife benötigt werden. Die Schleife wird als while-Schleife formuliert. Innerhalb der Schleifenbedingung wird jedoch die Perl-Funktion each aufgerufen. Diese liefert wahlweise eine Liste mit zwei Elementen, nämlich dem jeweils nächsten Schlüssel und dem zugehörigen Wert, oder - im skalaren Kontext - nur den jeweils nächsten Schlüssel des übergebenen Hashes.

Das Beispiel-Script zeigt beide Varianten. In der ersten Variante wird die Liste mit den beiden Elementen in dem Ausdruck ($Schluessel, $Wert) gespeichert. $Schluessel enthält dann den jeweils aktuellen Schlüssel des Hashs, und $Wert den zugehörigen Datenwert. Im Beispiel wird die Schleife dreimal durchlaufen und gibt solche Sätze aus wie Frau heißt Eva.

In der zweiten Variante wird die each-Funktion im skalaren Kontext aufgerufen, da der Rückgabewert nur in $Schluessel gespeichert wird. Die innerhalb der Schleife formulierte print-Anweisung gibt daher das Gleiche aus wie in der ersten Variante. Diesmal ist jedoch keine Variable $Wert verfügbar. Über ein Konstrukt wie $Familie{$Schluessel} kann aber auf den jeweils aktuellen Wert zugegriffen werden.

[Bearbeiten] Block-Labels zur Schleifenkontrolle

Schleifen können mehrere Schichten haben. Wenn man mit den Funktionenlast die Schleife verlassen will oder next eine nächste Iteration initiieren will, in welche Schleife soll gesprungen werden? Block-Labels erlauben die Beschriftung einer Schleife.

Beispiel
OUTER: for(my $x; $x<10; $x++){
  INNER: for(my $y; $y<10; $y++){
    $Bedingung_1 and last INNER;
    $Bedingung_2 and last OUTER;
    $Bedingung_3 and next INNER;
    $Bedingung_4 and next OUTER;
    # ...
  }
}
Im Beispiel liegen zwei Ebenen von Schleifen vor. Jede hat ihr eigenes Label. In Perl kann jeder Block sein eigenes Label erhalten. Im Beispiel können unter verschiedenen Bedingungen die Weiterführung des Programmes kontrolliert definiert werden.

Siehe auch

[Bearbeiten] Rekursion

Rekursion ist dann ein Mittel, wenn man mit Schleifen nicht mehr weiter kommt. Ein typischer Anwendungsfall für Rekursion ist das Traversieren von baumartigen Strukturen. Auf gut Deutsch: wenn Sie beispielsweise einen ganzen Verzeichnisbaum einlesen wollen, ohne die Datei- und Verzeichnisstruktur vorher zu kennen, dann ist das ein typischer Fall für eine rekursive Anwendung. Bei der Rekursion wird eine Subroutine definiert, innerhalb derer es eine Anweisung gibt, die die Subroutine von neuem aufruft. Dadurch entsteht ein Verschachtelungseffekt. Rekursion ist allerdings aus Computersicht nicht ganz unkritisch. Deshalb muss sie sauber programmiert sein.

Das folgende Beispiel zeigt, wie Sie eine Datei- und Verzeichnisstruktur ab einem gegebenen Startverzeichnis einlesen und an den aufrufenden Browser HTML-formatiert übermitteln lassen können. Das Beispiel ist allerdings nicht ganz trivial.


Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my $Startverzeichnis = "/var/www/selfhtml.org/de/dokumente/perl";
my @Alle;
my $Totalbytes = 0;
 
my $out;
 
Ermitteln($Startverzeichnis);
@Alle = sort(@Alle);
foreach (@Alle) {
  $out .= $_ . "\n";
}
 
print <<"ENDE";
Content-type: text/html
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><title>Testausgabe</title>
</head><body>
<h1>Dateibaum</h1>
<pre>Startverzeichnis: <b>$Startverzeichnis</b></pre>
<hr><pre>
$out
</pre><hr>
<pre>Insgesamt: [$Totalbytes Bytes]</pre>
</body></html>
ENDE
 
sub Ermitteln {
  my $Verzeichnis = shift;
  my $Eintrag;
  my $Pfadname;
  my $HTML_Eintrag;
  my $Bytes;
  local *DH;
 
  unless (opendir(DH, $Verzeichnis)) {
    return;
  }
  while (defined ($Eintrag = readdir(DH))) {
    next if($Eintrag eq "." or $Eintrag eq "..");
    $Pfadname = $Verzeichnis."/".$Eintrag;
    if(-d $Pfadname) {
      $HTML_Eintrag = $Verzeichnis."/".$Eintrag." [VERZEICHNIS]";
    }
    else {
      $Bytes = -s $Pfadname;
      $Totalbytes += $Bytes;
      $HTML_Eintrag = $Verzeichnis."/".$Eintrag." [$Bytes Bytes]";
    }
    push(@Alle, $HTML_Eintrag);
    Ermitteln($Pfadname) if(-d $Pfadname);
  }
  closedir(DH);
}
Zunächst werden drei wichtige Variablen deklariert: $Startverzeichnis speichert das Verzeichnis, ab dem die Suche starten soll, @Alle ist die Liste, in der später die eingelesenen Einträge gespeichert werden, und $Totalbytes ermittelt die Bytezahlen aller Dateien.

Danach wird mit der HTML-Ausgabe begonnen. Unterhalb davon steht die Anweisung Ermitteln($Startverzeichnis);. Dies ist ein Aufruf der Subroutine Ermitteln, die etwas weiter unten mit sub Ermitteln eingeleitet wird. Diese Subroutine ist zugleich diejenige, die sich in dem Anweisungsblock, den sie einschließt, in ihrer vorletzten Anweisung selbst wieder aufruft und so die Rekursion bewirkt.

Mit der Anweisung Ermitteln($Startverzeichnis); passiert damit das gesamte Einlesen der Datei- und Verzeichnisstruktur. Anschließend wird die Liste mit der Funktion sort alphabetisch sortiert und dann Eintrag für Eintrag aus einer foreach-Schleife heraus ausgegeben.

Das Herzstück des Scripts ist die Subroutine Ermitteln. Darin wird zunächst eine Reihe von Arbeitsvariablen deklariert. Da die Subroutine sich ja selber wieder aufruft, stellt sich die Frage, ob es dabei nicht zu einem Kuddelmuddel mit den Namen der Variablen kommt. Die Antwort ist nein. Denn jedes Ausführen der Subroutine erzeugt eine eigene Instanz der Routine im Arbeitsspeicher, und da die Variablen lokal mit my deklariert sind, bleibt ihre Gültigkeit auf eine Instanz beschränkt. Eine offensichtliche Ausnahme bildet die Anweisung local *DH, die das Verzeichnishandle DH lokal deklariert. Da my nicht auf Datei-/Verzeichnishandles (bzw. Typeglobs) angewendet werden kann, wird hier zu dieser Lösung gegriffen, die intern zwar etwas anders arbeitet, aber den gewünschten Effekt hat. Eine andere Variante wäre, das Standardmodul Symbol zu verwenden und sich in jeder Instanz der Subroutine ein neues Verzeichnishandle zu schaffen. Das Verfahren mag "sauberer" erscheinen, ist es aber im Endeffekt nicht. Außerdem ist die Variante mit local bedeutend schneller. Die vielen Instanzen der Subroutine bei vielen Verzeichnissen führen aber auch dazu, dass immer mehr Arbeitsspeicher benötigt wird. Das ist ein wichtiger Nachteil der Rekursion. Konstrukte mit vielen rekursiven Selbstaufrufen sollten Sie daher in CGI-Scripts, die auf öffentlichen Webservern sehr häufig und in mehreren Prozessen gleichzeitig aufgerufen werden können, vermeiden.

Die Subroutine Ermitteln erwartet einen Verzeichnispfadnamen, der ihr übergeben wird. Mit $Verzeichnis = shift; wird der übergebene Pfadname im Skalar $Verzeichnis gespeichert (siehe dazu auch die Perl-Funktion shift). Anschließend wird mit der Funktion opendir das übergebene Verzeichnis geöffnet. Seine Einträge werden in einer while-Schleife mit der Funktion readdir eingelesen. Die beiden Einträge mit den Werten . und .., die in jedem Verzeichnis vorkommen und das aktuelle bzw. das übergeordnete Verzeichnis symbolisieren, werden mit dem Sprungbefehl next übersprungen. Andernfalls würde sich die Rekursion in einer Endlosschleife verheddern.

Mit dem Dateitestoperator -d in if(-d $Pfadname) wird abgefragt, ob der jeweils aktuelle Verzeichniseintrag wieder ein Verzeichnis, also ein Unterverzeichnis, ist. Abhängig davon wird ein HTML-Eintrag für die auszugebende Liste vorbereitet. Weiter unten wird dann mit -d noch einmal abgefragt, ob der Eintrag ein Unterverzeichnis ist, und davon abhängig die Subroutine Ermitteln mit dem Unterverzeichnis erneut aufgerufen.

Nachdem die Verzeichnisstruktur abgearbeitet ist und alle Instanzen der Subroutine Ermitteln beendet sind, geht es im oberen Teil des Scripts weiter mit @Alle = sort(@Alle);.
Meine Werkzeuge
Namensräume

Varianten
Aktionen
Übersicht
Schnell‑Index
Mitmachen
Werkzeuge
Spenden
SELFHTML