Claus Schönleber

Hitchhacker´s Guide To PERL

V1.2 [Juni 2004]

Einleitende Worte

Perl ist eine interpretierte Sprache, die unter Unix entwickelt wurde. Zwar gibt es auch Versionen für andere Betriebssysteme, aber die volle Schönheit von Perl ergibt sich nur unter Unix. Unter anderem liegt das daran, daß Perl integrativ wichtige Eigenschaften der Betriebssystemfamilie benutzt.

Wie viele Sprachen teilt sich Perl in die eigentlichen Sprachelemente und in eine Sammlung von nützlichen Funktionen auf. Die Sprachelemente sind schnell gelernt, das Wissen über die Bestandteile der Funktionssammlung ergibt sich mit der Zeit.

Dieser Einführungstext bezieht sich auf Perl unter Unix. Unter anderen Betriebssystemen unterscheidet sich die Ausführung von Perl etwas; lesen Sie dort einfach die Anleitung Ihrer Perl-Version.

Perl ist eine vollständige Programmiersprache, denn sie enthält die drei Grundstrukturen, die dafür benötigt werden:

1. Folgen
2. Maschen (Verzweigungen)
3. Schleifen

"Hallo Welt!"

#!/usr/bin/perl

Nun starten Sie es mit der Befehlszeile:
 

perl kr.pl

Hallo Welt

Warum man "#!/usr/bin/perl" in die erste Zeile schreibt? Weil ein Perl-Programm auch automatisch aufgerufen werden kann, zum Beispiel als Skript über eine Webseite. Dann muß klar sein welcher Perl-Interpreter zuständig ist und wo er zu finden ist. Es empfiehlt sich darüberhinaus, den Interpreter stets mit "perl -w" aufzurufen. Das resultiert im Fehlerfalle zu genaueren und ausführlicheren Informationen.

Variablen, Datentypen und Konstanten

Die Hauptunterscheidung zu anderen Sprachen ist die Benennung der Variablen. Jedem Variablenbezeichner wird ein Symbol vorangestellt, daß über die Verwendung der Variable, nicht aber über deren Typ entscheidet.
 

Beispiele für Variablenbezeichner:
 

Dabei ist zu beachten, daß der Präfix ($, @, %) nicht fest mit dem Variablennamen verknüpft ist, sondern eine Zugriffsmethode darstellt. So spricht man durch "@teilnehmer" das gesamte Feld, mit "$teilnehmer [5]" das Element 5 aus dem Feld "teilnehmer" an. Denn ein Element aus einem Feld ist ein skalarer Wert.

Ein weiteres Beispiel:
 

#!/usr/bin/perl

$hubbel=17;
$bubbel=23;

print "$hubbel + $bubbel = ",$hubbel + $bubbel;

17 + 23 = 40

Interessant ist die Ausgabezeile. Wie man leicht bemerkt, ist die Ausgabeanweisung "print", ähnlich wie in BASIC. Zeichenketten werden in Anführungszeichen gesetzt. Die Wirkung ist die unter Unix erwartete:
 

Zusätzlich gibt es die unter C bekannten Symbole für Sonderzeichen. Hier die Liste:
 

Spezielle Variablen (Auswahl)

Operatoren

++, --

**

*, /, %

+, -

<<, >>

> ; gt

>= ; ge

< ; lt

<= ; le

= = ; eq

!= ; ne

Perl beherrscht auch reguläre Ausdrücke. Wer sie kennt, liebt sie und lese sie in anderen Dokumentationen nach. Wer sie nicht kennt, sollte sie kennenlernen. Und auch auch in diesem Falle sei auf die reichhaltige Literatur verwiesen.

Perl unterscheidet sich allerdings von den "hohen" Sprachen durch seine umgangssprachliche Natur. Es gibt Varianten, die zwar untereinander ähnlich bis identisch sind, aber je nach Geschmack alles formaler oder weniger formal aussehen lassen. Einer der Gründe, warum sich Perl-Programme nicht so leicht auf Anhieb erschließen: Für ein und dasselbe Problem gibt es manchmal mehrere syntaktische Varianten.

Anweisungen (statements)

einfache Anweisungen (simple statements)

Das letzte Beispiel ist eine Eingabeanweisung, die das Setzen des Wertes der Variablen $i über die Tastatur erlaubt. Wie man leicht sehen kann, werden in Perl einfach Unixeigenschaften übernommen. Dem erfahrenen Unixanwender fallen deswegen bestimmte Ansätze in Perl leichter als Benutzern anderer Betriebssysteme.

Zusammengesetzte Anweisungen (compound statements)

Verzweigungen

#!/usr/bin/perl
# Berechnung eines Schaltjahres. Ohne Eingabe

$jahr = 1997;

$ist_schaltjahr = ($jahr % 4 == 0) && ($jahr % 100 != 0) || ($jahr % 400 == 0);

print $jahr, ": ";
if (! $ist_schaltjahr)
{
   print "Kein ";
}
print "Schaltjahr\n"

Ausgabe:

$ perl sj.pl
1997: Kein Schaltjahr

Der logische Ausdruck sollte stets geklammert werden. Es ist zwar nicht immer nötig, aber es ist nicht falsch und Klammerungen erhöhen die Lesbarkeit eines Programms.

Die vollständige Syntax der bedingten Verzweigung sieht so aus (Teile in "[...]" sind optional)
:

Dabei muß der logische Ausdruck stets in geschweifte Klammern "{...}" gesetzt werden, anders als bei Sprachen wie C oder Java, in denen man die Klammern weglassen kann, wenn der Block nur aus einer einzelnen Anweisung besteht.

Schleifen

• Abweisende Schleifen prüfen vor Eintritt in den Schleifenblock die Abbruchbedingung. Ergibt sich dadurch schon ein Abbruch, so wird der Schleifenblock gar nicht erst ausgeführt.
• Nicht abweisende Schleifen prüfen die Abbruchbedingung nach dem Ausführen des Schleifenblockes. Somit wird der Schleifenblock auf jeden Fall mindestens einmal durchlaufen, unabhängig von der Abbruchbedingung.

• Zählschleifen: Es ist schon vor dem Eintritt in die Schleife bekannt, wie häufig der Schleifenblock durchlaufen werden soll. Deswegen wird die Abbruchbedingung der Schleife durch einen Zähler realisiert.
• Bedingte Schleifen: Es kann erst während des Schleifendurchlaufs die Abbruchbedingung getestet werden. Die Anzahl der Schleifendurchläufe ist zu Anfang unbekannt. Deswegen wird die Abbruchbedingung durch einen logischen Ausdruck realisiert, der keinen Zähler überprüft, sondern eine beliebige andere - meist äußere - Bedingung.

Zählschleifen

#!/usr/bin/perl 

print "Zaehlschleife...\n"; 

$n = "Hubbel ";

for ($i = 1; $i <=3 ; $i++)
{ 
          print $i." mal ".$n."\n"; 
}  

Zaehlschleife...
1. mal Hubbel
2. mal Hubbel
3. mal Hubbel

 Der Schleifenkopf einer "for"-Schleife besteht im Steuerteil aus drei Teilen:

(Einführen der Laufvariablen und Setzen des Startwertes ; Abbruchbedingung ; Inkrement/Dekrement)

C-Programmierer erkennen die typische Formulierung des Inkrements. Die Zeichenkette "++" bedeutet ein implizites Inkrement. Natürlich bedeutet dann "--" das implizite Dekrement.

In allen Programmiersprachen gibt es eine eiserne Regel:
 

Auch wenn es Ihre Programmierumgebung zuläßt, lassen Sie es! Es ist nicht cool, unlesbare Programme zu schreiben.

 Perl untertützt einige weitere Varianten von Zählschleifen, zum Beispiel das Abarbeiten von kleinen, bekannten Listen. Alle folgenden Beispiel führen dasselbe aus, die Ausgabe aller ganzen Zahlen von 1 bis 5:
 

for ((1,2,3,4,5)) { print $_."\n" }

foreach ((1,2,3,4,5)) { print $_."\n" }

foreach (1..5) { print $_."\n" }

foreach $nr (1..5) { print $nr."\n" }

Bedingte Schleifen

while / until

 #!/usr/local/bin/perl -w

$i = 0;

while($i < 5) {
  print "$i\n";
  $i++;
}

#!/usr/local/bin/perl -w

$i = 0;

until($i == 5) {
  print "$i\n";
  $i++;
}

Zu beachten sind bei der negierten "until"-Version, daß das Rechnen mit logischen Ausdrücken nicht intuitiv möglich ist. Wenn Sie damit keine Erfahrung haben, beschäftigen Sie sich bitte erst damit. Stichwort ist zum Beispiel "DeMorganschen Regeln".

do..until

print "Eingabeende mit -q-\n";

do
{
        print "Eingabe: ";

        $i = <stdin>;
        chomp ($i);
} until ($i eq "q");

print "Geschafft!\n";

Eingabeende mit -q-
Eingabe: a
Eingabe: b
Eingabe: q
Geschafft!

Damit sind alle Strukturen vorhanden, die zum Programmieren benötigt werden. Perl unterstützt Unterprogramme im alten Sinne (leider keine Funktionen oder Prozeduren, was hier sehr bedauert wird...). Am Ende des Dokumentes wird darauf eingegangen.

Funktionen

• n: numerischer Ausdruck, ganzzahlig
• r: numerischer Ausdruck, ganzzahlig oder mit Kommaanteil
• s: Zeichenkettenausdruck
• l: logischer Ausdruck

Mit Ausnahme von atan2 ( ) dürfen alle mathematischen Funktionen auch ohne explizites Argument benutzt werden; es wird dann statt dessen der Wert von $_ eingesetzt. Im Folgenden sollen einige Funktionen in einem gemeinsamen Beispiel vorgeführt werden.

Das Beispiel arbeitet eine Zeichenkette ab, die von einem Webclient an einen Webserver geschickt wurde, den sogenannten query string. In diesem Beispiel soll es spezielle Sonderbedingungen geben, um es nicht zu schwierig zu machen. Ein querystring besteht aus einer Liste von Paaren "variable=value", die durch "&" getrennt werden. Beispiel:

q=hubbel+bubbel&kl=XX&pg=q&Translate=on

suchbegriff=Hans+Dampf

$input = $ENV{QUERY_STRING};
($var,$val) = split("=",$input);
$plus = index ($val,"+");
if ($plus >= 0)
{
        substr ($such,index ($such,"+"),1," ");
}

Interessanterweise kann man in Perl in einer Zuweisung mehrere Variablen mit Werten belegen. Wenn der Ausdruck rechts von "=" eine Liste ist, dann darf links von "=" eine Liste von Variablen stehen, die einen entsprechenden Typ aufweisen und in entsprechender Anzahl vorhanden sein müssen. Die betreffende Zeile im Beispiel ist fett hervorgehoben.

Dateien

Um mit Dateien umgehen zu können, werden wie üblich "file handler", Dateibezeichner verwendet. Diese Bezeichner sind der interne Zeiger auf die Dateien und werden mit dem Plattendateinamen zu Beginn der Dateiarbeit verknüpft.

Das Öffnen einer Datei geschieht mit der "open"-Anweisung, die auch über die Art des Zugangs entscheidet. Das Symbol ">" öffnet zum Schreiben (Neuanlegen), das Symbol ">>" (Schreiben, ahängen) hängt Daten an eine bestehende Datei an. Die Symbole werden unmittelbar dem Plattendateinamen vorangestellt.
 
 

Hier ein Beispiel, das eine Datei zum Schreiben öffnet, schließt, zum Lesen öffnet und die Daten ausgibt (der Operator "my" in der for-Schleife erzeugt eine lokale Variable; dazu mehr am Ende des Dokuments):
 

$filename = "datafile.dat";

open (DATA,">" . $filename);
for (my $i = 1; $i <= 5; $i++)
{
        print DATA $i."-line\n";
}
close (DATA);

open (DATA,$filename) || warn "File open error\n";
while (<DATA>)
{
        print "$_";
}
close (DATA);

1
2
3
4
5

Unterprogramme

Das Deklarieren eines Unterprogramms erfolgt mit dem Wort "sub", gefolgt vom Unterprogrammnamen. Es gibt noch andere Möglichkeiten, aber die hier soll für unsere Zwecke ausreichen. Der Zugriff auf Unterprogramme wird durch den Aufruf des Namens des Unterprogramms, dem ein "&" vorangestellt wird, durchgeführt.
 
 

sub swap
{
        my $h = $a;
        $a = $b;
        $b = $h;
}

$a=<STDIN>;
chop ($a);
$b=<STDIN>;
chop ($b);
print "Vor Aufruf: a=",$a," b=",$b,"\n";
&swap ($a,$b);
print "Nach Aufruf: a=",$a," b=",$b,"\n";

Im Beispiel geschieht keine ordentliche Parameterübergabe. Es werden einfach globale Variablen manipuliert, Seiteneffekte garantiert. Also schlechter Stil. Alle Argumente werden dem Unterprogramm über das Feld "@_" übergeben, allerdings als lineare Liste (flat list of scalars). Will man (Hash-)Felder übergeben, so ergeben sich Probleme. Dies ist allerdings nicht Aufgabe dieses Textes. Lesen Sie in der weiterführenden Literatur nach, wie man dann vorgeht.

Lokale Variablen

• local
• my

local

Dies entspricht einer "lokal globalen Variablen". Wird eine Variable als "local" definiert, so ist der Geltungsbereich nicht nur der definierende Block, sondern auch alle aufgerufenen Untermoduln. Also "relativ global" zum definierenden Block. Heißen auch "dynamische" Variablen.

my

Einer "normalen lokalen" Variablen am ähnlichsten. Es gilt ein lexikalischer (syntaktischer) Geltungsbereich, also nur innerhalb des definierenden Blocks, nicht jedoch in von hier aus aufgerufenen Unterprogrammen. Diese Variante sollte im Normalfall benutzt werden.

Danksagung

Vielen Dank an Thomas Treffehn (treffehn@brochier.de) für Hinweise auf Fehler in diesem Dokument.

Weiterführende Links:

• http://www.perlworkshop.de/
• http://www.perl-archiv.de/
• http://perl-seiten.bei.t-online.de/
• http://de.selfhtml.org/cgiperl/index.htm
• http://www.perl.de/

Suchmaschinen (Stichwort "Perl"):

• Google
• AltaVista
• Yahoo