text: Galileo Computing :: Linux – 22.2 Die Skriptsprache Perl
  Im Folgenden werden wir Ihnen einen kurzen Crashkurs zur Programmierung mit Perl geben. Warum aber ausgerechnet Perl? Perl hat als Programmiersprache seine Stärken vor allem in der Verarbeitung von Textdaten mit beispielsweise regulären Ausdrücken. Demzufolge wird Perl sehr gern in der Webprogrammierung sowie im Bereich der Systemadministration eingesetzt – und zwar meist genau da, wo ein normales Shellskript an seine Grenzen stößt.
  Für Perl existieren zahlreiche Erweiterungen, sogenannte Module. Über die jeweils passenden Module können zum Beispiel Datenbanken angesprochen oder CGI-Skripte für dynamische Webseiten erstellt werden.
  Wie jedes Skript und wie auch bereits in der Kurzvorstellung der Sprache erwähnt wurde, startet jedes Perl-Skript mit der Angabe des Interpreters in der Form:
  Listing 22.128 Interpreter angeben
  Oft wird der Interpreter noch mit -wT aufgerufen, was viele Warnungsmeldungen des Interpreters aktiviert und dringend zu empfehlen ist.
  Meist folgen dann ein paar Kommentare über das Programm selbst, wie es aufgerufen wird und was es tut. Kommentare beginnen in Perl wie bei den meisten Skriptsprachen mit einer Raute (»#«).
  Nach ein paar einleitenden Kommentaren werden in der Regel die für das Skript benötigten Module eingebunden. Der dafür notwendige Befehl heißt use:
  Wenn man selbst Perl programmiert beziehungsweise ein fremdes Perl-Skript auf eigenen Systemen nutzen will, kann es vorkommen, dass man ein benötigtes Modul nicht installiert hat. Dann hilft der CPAN, eine Online-Sammlung quasi aller Perl-Module.
  Das Installieren neuer Module über den CPAN gestaltet sich dank der komfortablen CPAN-Shell recht einfach. Es reicht ein Aufruf des cpan-Programms:
  [... bei dem ersten Aufruf wird die CPAN-Shell initialisiert bzw. komplett installiert ...]
  Listing 22.129 Über den CPAN Module installieren
  Nach diesem Aufruf ist das entsprechende Modul – zumindest sofern es während der Installation keinen Fehler gab – auf dem System vorhanden und kann sofort in Skripten benutzt werden.
  Nach der Angabe der nötigen Module folgt der eigentliche Skriptcode. Ein erstes Beispielprogramm, das den Text »hello world!« ausgibt, sieht so aus:
  # gibt "hello world!" aus.
  # strenge Syntaxregeln aktivieren
  Listing 22.130 Hello-World in Perl
  Um das Programm auszuführen, reicht es aus, das Programm über das Execute-Flag als ausführbar zu markieren und es anschließend aufzurufen:
  $ chmod +x helloworld.pl
  Um nun ein Skript überhaupt mit etwas Dynamik ausstatten zu können, brauchen Sie das Wissen über Variablen – und werden diese im Folgenden erläutert.
  Variablentypen werden in Perl durch ein Präfix identifiziert. Die wichtigsten Variablentypen sind:
  $ – Skalare
  Skalare sind Variablen, die genau einen Wert speichern. Skalare haben keinen expliziten Typ, können also sowohl Zahlen als auch Zeichenketten speichern.
  @ – Arrays
  Arrays fassen mehrere Skalare zu einem Feld zusammen. Die einzelnen Einträge werden über eine Zahl indiziert.
  % – Hashes
  Hashes sind assoziative Arrays. Einträge werden also nicht über eine Zahl, sondern eine Zeichenkette indiziert.
  Vor der Benutzung sollten <Bei der Benutzung von use strict: müssen> Sie Variablen über das Schlüsselwort my deklarieren. Anders als in ANSI-C können Variablen jedoch überall deklariert werden, wo Sie es für nötig halten. Gern gesehen wird jedoch -- wie bei C üblich – eine Deklaration am Anfang eines Codeblocks.
  Am konkreten Beispielskript sieht das so aus:
  my $var1 = "Hallo";        # String
  my $var2 = 5;              # Zahl
  $array[1] = 2;             # eine Zahl im Array speichern...
  $array[2] = "foo";         # ...ein Text...
  $hash{'passwort'} = "xxx";  # ...im Hash...
  Listing 22.131 Variablen in Perl
  Das Beispiel zeigt auch, wie man auf den Inhalt von Arrays und Hashes zugreift: über den $-Operator. Das macht auch Sinn, wenn man bedenkt, dass man beim Zugriff einen bestimmten Wert auslesen will. Und konkrete, skalare Werte werden nun mal über $ angesprochen.
  Weiterhin können Sie sehen, dass es in Perl anders als in C keine strenge oder explizite Typdeklaration gibt. Es ist für Perl unwesentlich, ob Sie einen Text oder eine Zahl in einem Skalar speichern. Perl bestimmt den Typ einer Variable dynamisch beim Ausführen des Skripts anhand des benutzten Kontexts:
  my $var3 = "5";            # String? Zahl?
  print $var2 + $var3 . "\n";
  print $var1 + $var2 . "\n";
  print $var1 + $var3 . "\n";
  print $var1 . $var2 . "\n";
  print $var1 . $var3 . "\n";
  Listing 22.132 Typisierung
  In der Ausgabe sieht das dann so aus:
  $ ./typ.pl
  Listing 22.133 Typisierung #2
  Offensichtlich addiert der Operator + zwei Zahlen, während der Operator . zwei Strings miteinander verbindet. Im ersten Ausdruck werden die Variablen var2 und var3 als Zahlen interpretiert: $5 + 5 = 10$. Das Ergebnis wird als String interpretiert, mit einem Zeilenumbruch versehen und per print ausgegeben.
  In den nächsten beiden Ausdrücken wird versucht, einen String – bei dem man auch mit wirklich gutem Willen nichts als Zahl interpretieren kann – zu einer Zahl zu addieren. Offensichtlich wird der String dabei als $0$ interpretiert, denn heraus kommt beide Male $5$ als Ergebnis.
  In den letzten beiden Ausdrücken werden schließlich wieder Zahlen als Strings interpretiert und per . mit var1 verknüpft.
  Tabelle 22.3 Übersicht der arithmetischen Operatoren
  $x = $y ^{ $z}
  Die arithmetischen Operationen sind also im Wesentlichen analog zu denen in C.
  Mit Variablen kann man nun viele schöne Dinge machen, beispielsweise indem man Bedingungen in Kontrollstrukturen füttert. Im Prinzip kennen Sie if, for und while schon aus der Shell und von C – und auch bei Perl ändern sich die grundlegenden Prinzipien nicht.
  Bei allen Kontrollstrukturen müssen Sie Bedingungen schreiben – beispielsweise unter Benutzung der bekannten arithmetischen Vergleichsoperatoren (siehe Kapitel 22.1.5) oder auch durch RegEx-basierte Stringvergleiche, die wir später noch vorstellen werden.
  if – bedingte Anweisungen
  Wie bereits gesagt wurde, funktionieren bedingte Anweisungen mit if analog zu C, es gibt weitgehend identische Operatoren, und auch && und || funktionieren analog zu C. Die geschweiften Klammern sollten Sie aber nie vergessen, auch wenn Sie nur eine Anweisung nach if ausführen wollen.
  if ( $a == 1 && $b != 5 )
  Listing 22.134 if-Anweisung
  Im Unterschied zu C gibt es jedoch keine case-Anweisung. Anstatt case kann man jedoch if ... elsif ... else nutzen:
  } elsif ( $a == 2 ) {
  } elsif ( $a == 3 ) {
  # alle anderen Werte von $a
  Listing 22.135 if-elsif-else
  So weit gibt es eigentlich nichts Neues.
  Interessanter sind da schon for-Schleifen. Hier kann man nämlich einmal eine Syntax analog zu C und einmal eine Syntax analog zur Bash nutzen.
  Die aus C bekannte Variante schreibt sich wie folgt:
  for(my $i = 1; $i <= 100; $i++) {
  Listing 22.136 for analog zu C
  Man gibt einen Startwert, eine Bedingung und eine Anweisung an, die nach jedem Durchlauf ausgeführt wird. Aber durch das Schlüsselwort foreach ist auch eine Anwendung ähnlich zu for in der Bash möglich, da so eine Liste von Werten – im Sinne von Arrays oder Hashes – recht einfach durchlaufen werden kann:
  my @bar = ("mein Haus", "mein Auto", "mein Boot");
  foreach $foo (@bar)
  print "$foo !\n";
  Listing 22.137 »for« analog zur Bash
  Die Syntax von foreach erklärt sich eigentlich beim Lesen des Beispiels von selbst: Man gibt eine Variable an, mit der im Schleifenkörper das jeweils aktuelle Element bezeichnet werden soll, worauf das zu durchlaufende Array in Klammern folgt.
  In diesem Beispiel haben Sie auch gesehen, wie man ein Array verkürzt definieren kann: als eine Liste von Werten. Im nächsten Beispiel werden Sie sehen, wie man einen Hash verkürzt definieren und ihn mit foreach durchlaufen kann.
  my %hash = (1 => "3", foo => "bar");
  foreach $x (%hash)
  Listing 22.138 foreach mit Hash
  Wenn man einen Hash verkürzt definiert, ordnet man mittels des Operators »=>« einem Schlüssel einen Wert zu. Das man über foreach dann sowohl Schlüssel als auch Werte durchlaufen kann, zeigt der Output des Skripts:
  $ ./foreach.pl
  Listing 22.139 foreach mit Hash: Output
  Wieder analog zu C funktionieren einfache while-Schleifen. Man definiert eine Bedingung und einen Schleifenkörper, der so lange ausgeführt wird, wie die Bedingung wahr ist. Ist die Bedingung nie wahr, wird der Schleifenkörper auch nie ausgeführt.
  # natürlich sollte der Schleifenkörper jetzt irgendwann etwas an
  # $a oder $b ändern
  Listing 22.140 while-Schleife
  while (($s,$w) = each(%hash))
  print "Schlüssel: " . $s . " Wert: " . $w . "\n";
  Listing 22.141 while-Schleife mit Hashes
  Bei dieser Methode bekommt man im Gegensatz zu foreach unterschiedliche Variablen für Schlüssel und Wert. Die Schleife bricht sinnvollerweise ab, wenn es keine Werte mehr zu durchlaufen gibt.
  Die ebenfalls aus C bekannte do-while-Schleife verhält sich analog zur while-Schleife – mit dem Unterschied, dass die Bedingung erst nach dem Schleifenkörper geprüft wird. Das hat zur Folge, dass diese Schleife mindestens einmal ausgeführt wird, auch wenn die Bedingung immer falsch ist.
  # wird mindestens einmal ausgeführt
  } while ( 1 != 2 )
  Listing 22.142 do-while-Schleife
  Da eventuell in der Bedingung zugewiesene Variablen erst nach dem ersten Durchlauf zugewiesen werden, eignet sich do-while nicht zum Durchlaufen von Hashes oder Arrays. Folgendes funktioniert nicht wie gewünscht: <Beim ersten Durchlauf ist die Variale $s noch leer beziehungsweise mit einem alten Wert gefüllt.>:
  } while ( ($s,$w) = each(%hash) )
  Listing 22.143 do-while-Schleife falsch eingesetzt
  Spätestens an dieser Stelle müssen wir Ihnen auch eines der zentralen Prinzipien von Perl erläutern: TIMTOWTDI <Sprich: »Tim Toady«.> – »There is more than ONE way to do it«, Es gibt mehr als einen Weg, »es« zu tun. <Nicht nur im Kamasutra, sondern auch in Perl...>
  Perl ist bekannt dafür, das man gleiche Sachverhalte unterschiedlich formulieren kann. Dadurch wird Perl auch oft unterstellt, ziemlich unlesbar zu sein, frei nach dem Motto:
  »Write once, never understand again« <In Verballhornung des Java-Mottos »Write once, run anywhere«.>. Fakt ist aber, dass man zwar in Perl ziemlich furchtbaren, aber auch sehr schönen Code schreiben kann – die Freiheit liegt beim Programmierer.
  Ein Beispiel für diese Freiheit des Programmierers liefert die Negation. So gibt es für if und while jeweils eine Variante, die genau die Negation der Bedingung ausdrückt. So führt unless den zugehörigen Anweisungsblock nur aus, wenn die angegebene Bedingung falsch ist:
  # folgende Anweisungen sind äquivalent
  if (! $a == $b )
  unless ( $a == $b )
  Listing 22.144 unless
  Analog führt until den Schleifenkörper so lange aus, wie die angegebene Bedingung falsch ist. Somit ist until gewissermaßen die Negation von while:
  while (! $a == $b )
  until ( $a == $b )
  Listing 22.145 until
  Natürlich gibt es auch eine entsprechende do-until-Variante, die – je nach Lust und Laune des Programmierers – do-while ersetzen kann.
  Eine weitere Besonderheit ist, dass Sie alle Kontrollstrukturen – if, for, while, until und unless – bei einzelnen Anweisungen auch nachstellen können. Die Bedeutung verändert sich dadurch nicht:
  # Es ist egal, ob Sie...
  if ( $x == $y ) print "foo\n";
  # ...oder...
  print "foo\n" if ( $x == $y );
  # ...schreiben.
  Listing 22.146 Die Nachstellung
  Im Besonderen können bei Nachstellungen die geschweiften Klammern weggelassen werden. Jedoch sollte man mit Nachstellungen auch vorsichtig sein. Betrachten Sie beispielsweise folgenden Code:
  print "1\n" while ( 4 == 5 );
  do { print "2\n"; } while ( 4 == 5 );
  Listing 22.147 Achtung, eklig.
  Hätten Sie auf den ersten Blick gesehen, dass das Skript beide Schleifen unterschiedlich behandelt und den folgenden Output produziert?
  $ ./eklig.pl
  Listing 22.148 Achtung, eklig #2
  Zwar ist in beiden Listings 4 nicht gleich 5, jedoch wird eine do-while-Schleife immer mindestens einmal durchlaufen, während eine while-Schleife nur dann durchlaufen wird, wenn die Bedingung mindestens einmal wahr ist – und daran ändert auch eine Nachstellung nichts. Aufgrund der syntaktischen Ähnlichkeiten sollte man daher nachgestellte while-Schleifen nur mit äußerster Vorsicht einsetzen.
  Alle diese Möglichkeiten erlauben es, den Code der natürlichen Sprache anzunähern und damit lesbarer zu gestalten. Durch die Verwendung von until und unless können Sie »unnötige« Negationen verhindern und durch die Nachstellung unter Umständen den Lesefluss fördern. Perl lässt also viele Freiheiten, mit denen man sehr schönen Code schreiben, aber auch Schindluder treiben kann.
  Subroutinen lassen sich in Perl prinzipiell an jeder Stelle des Skripts definieren, jedoch findet man sie in der Regel am Anfang oder am Ende des Codes. Eingeleitet werden Subroutinen mit dem Schlüsselwort sub:
  sub meineFunktion {
  Listing 22.149 Subroutinen definieren
  Aufgerufen werden kann eine Subroutine schließlich wie ein ganz normaler Perl-Befehl:
  # Subroutinen definieren
  print "Hallo Welt!
  # Der "eigentliche" Code, das "Hauptprogramm"
  Listing 22.150 Subroutinen benutzen
  Dieses Beispiel produziert zwei Zeilen »Hallo Welt!«-Text als Ausgabe, da die entsprechende Subroutine im Hauptprogramm zweimal hintereinander aufgerufen wurde.
  Subroutinen lassen sich selbstverständlich auch mit Argumenten füttern. Dazu deklariert man am Anfang der Subroutine Variablen, denen man mittels des Schlüsselworts shift dann einen Wert zuweist. Per shift greift man auf die Argumente des Aufrufs zu, eine weitere Deklaration ist nicht erforderlich:
  sub Funktion {
  print $text . " " . $i . "\n";
  Funktion(1, "hallo");
  Listing 22.151 Argumente übergeben
  Dieses kleine Beispiel gibt den Text »hallo 1« aus. Das ist nicht sehr sinnvoll, aber zur Demonstration von shift soll dies erst einmal genügen.
  Rückgabewerte benutzen
  Normalerweise endet eine Subroutine, wenn ihr Ende erreicht ist, aber selbstverständlich kann sie auch Rückgabewerte an den Aufrufer zurückgeben beziehungsweise auch schon an anderer Stelle beendet werden. Anders als in C muss dies jedoch nicht explizit deklariert werden, da dem Schlüsselwort return einfach ein beliebiger Wert übergeben werden kann – oder eben auch nicht.
  return "Alles Ok\n";
  return "Nix ist Ok\n";
  print Funktion(1);
  print Funktion(0);
  Listing 22.152 Rückgabewerte definieren
  Zu regulären Ausdrücken gibt es ein eigenes Kapitel. Sie sollten also zum Beispiel wissen, worauf ein Ausdruck wie ^{h[abc]ll.$ matcht und worauf nicht. <Wenn nicht, sollten Sie noch mal in Kapitel 4 nachlesen.> Daher wollen wir in diesem Abschnitt nur kurz auf die Besonderheiten von regulären Ausdrücken in Perl eingehen.
  Unter Perl ist der Operator »=~« speziell für die Arbeit mit regulären Ausdrücken gedacht. Egal ob Sie prüfen wollen, ob ein Text auf einen regulären Ausdruck matcht, oder ob Sie eine Ersetzung auf Basis eines RegExs vornehmen wollen, =~ ist der Operator Ihrer Wahl.
  Wenn Sie beispielsweise überprüfen wollen, ob ein Text einem bestimmten Muster entspricht, setzen Sie ein »m« (»match«) vor den regulären Ausdruck. Die Anwendung ist so einfach wie im Beispiel zu sehen:
  my $text = "Hallo";
  if( $text =~ m/^H/ )
  print $text . " fängt mit H an!\n";
  Listing 22.153 Passt ein Text?
  So kann ohne Weiteres geprüft werden, ob eine Eingabe einem bestimmten Muster entspricht. Die regulären Ausdrücke selbst sind im Wesentlichen mit denen von sed identisch, mit dem Unterschied, dass Sie sich nicht über das Escapen von Sonderzeichen auf der Shell Gedanken machen müssen.
  Wenn Sie über einen regulären Ausdruck nicht nur Muster prüfen, sondern auch Veränderungen am Text vornehmen wollen, hilft Ihnen das »s«-Präfix weiter.
  Wie das funktioniert, zeigt folgendes kleines Beispiel:
  my $text = "vorher";
  $text =~ s/vor/nach/;
  Listing 22.154 Mit regulären Ausdrücken Text ersetzen
  Dieses kleine Skript ersetzt im Text »vorher« die Silbe »vor« durch »nach«. Natürlich sind auch weit kompliziertere Ersetzungen möglich, in diesem Kapitel werden wir jedoch nur einige wenige, aber wichtige Beispiele bringen.
  Normalerweise wird bei einer Ersetzung nur das erste gefundene Vorkommen ersetzt. Möchte man alle Vorkommen ersetzen, so muss man dem Suchausdruck ein »g« (»global«) folgen lassen:
  my $text = "texttexttext";
  $text =~ s/text/blah/;
  $text =~ s/text/blah/g;
  Listing 22.155 global.pl
  Die Ausgabe verdeutlicht noch einmal den Effekt, dass ohne das »g« nur das erste Vorkommen ersetzt wird:
  $ ./global.pl
  blahtexttext
  Listing 22.156 Globale Ersetzung
  Weiterhin kann man sich über die Benutzung von einfachen Klammern (»(« und »)«) Textteile merken. Diese gemerkten Textteile kann man im Ersetzungsteil über die Variablen $1, $2 usw. ansprechen:
  my $text = "passwort : user";
  $text =~ s/^(.*) : (.*)$/Der Benutzer $2 hat das Passwort $1!/g;
  Listing 22.157 klammer.pl
  Als Ausgabe liefert dieses Skript Folgendes:
  $ ./klammer.pl
  Der Benutzer user hat das Passwort passwort
  Listing 22.158 Zeichenketten vertauschen
  Dieser Mechanismus ist also im Besonderen geeignet, wenn Zeichenketten in Strings vertauscht werden sollen.
  Ähnlich dem Kommando tr in der Shell funktioniert der »tr«-Modifikator für reguläre Ausdrücke. Mit ihm können einzelne Zeichen in einem kompletten String ersetzt werden:
  my $text = "abcdefg";
  $text =~ tr/aceg/1234/;
  Listing 22.159 tr.pl
  $ ./tr.pl
  1b2d3f4
  Listing 22.160 Zeichen ersetzen
  So viel sei zur Benutzung regulärer Ausdrücke unter Perl gesagt, mehr Informationen zu regulären Ausdrücken an sich finden Sie im Kapitel 4.
  Die Arbeit mit Dateien gestaltet sich ähnlich wie bei C. So werden Dateien beispielsweise über sogenannte Filehandles identifiziert, die im Prinzip nichts anderes als Deskriptoren sind. Auch in Perl werden Dateien erst geöffnet, bevor sie gelesen beziehungsweise geschrieben werden können, und natürlich müssen Dateien auch wieder geschlossen werden.
  Dateien werden über den Aufruf open() geöffnet. Der Aufruf nimmt zwei Parameter entgegen: das zu benutzende Filehandle (den Deskriptor) sowie den zu öffnenden Dateinamen.
  Mithilfe der Zeichen <, > und |, die man dem Dateinamen voranstellt, kann man die Modi steuern, mit denen die Datei geöffnet werden soll.
  Die einzelnen Modi lauten wie folgt:
  »Datei
  Datei zum Schreiben öffnen. Wenn die Datei bereits existiert, werden die Daten an die Datei angehängt.
  |Datei
  Hier ist »Datei« ein ausführbares Programm. Zu diesem Programm wird eine Pipe geöffnet, in die man anschließend schreiben kann.
  Datei|
  In diesem Fall wird auch eine Pipe geöffnet, allerdings kann man jetzt aus der Pipe lesen.
  Möchte man also eine Datei »datei.txt« zum Lesen öffnen, kann man folgenden Code benutzen:
  open($fh, <datei.txt");
  Listing 22.161 open
  Dabei wird die Variable $fh als Filehandle initialisiert. Später kann über diese Variable auf den Inhalt der Datei lesend oder – bei entsprechenden open()-Modi – auch schreibend zugegriffen werden.
  Das Lesen erfolgt normalerweise über eine Schleife. Gelesen wird die Datei dann zeilenweise, und in jedem Schleifendurchlauf kann eine Zeile bearbeitet werden.
  Um eine Zeile im Schleifenkopf auszulesen, fasst man das Filehandle in zwei spitze Klammern:
  # Die Datei $fh zeilenweise auslesen
  # In $line finden Sie die aktuell gelesene Zeile
  Listing 22.162 Lesen
  Ist die Datei fertig gelesen, bricht die Schleife automatisch ab, da keine neue Zeile mehr definiert wird. Das Schreiben erfolgt ganz ähnlich wie die Ausgabe auf der Kommandozeile, nur wird hier das Filehandle vor dem zu schreibenden Text angegeben.
  # Den Text "Text" in die Datei schreiben
  print $fh "Text";
  Listing 22.163 Schreiben
  Nach dem Bearbeiten muss das Filehandle schließlich noch korrekt geschlossen werden:
  Listing 22.164 Datei schließen
  Im folgenden finden Sie ein kleines Beispielprogramm, das eine Datei, deren Name auf der Kommandozeile übergeben wird <Auf der Kommandozeile übergebene Parameter finden Sie im Array @ARGV.>, einliest und mit Zeilennummern versehen ausgibt. Sehen wir uns den Code des Programmes an, indem wir es durch sich selbst anzeigen lassen: