Der Interpreter von Perl heißt einfach perl und befindet sich im Verzeichnis /usr/bin. Das ist deswegen so wichtig, weil in einem Perl-Skript angegeben wird, wie der Interpreter heißt. Dazu schreiben Sie in die erste Zeile eines Perl-Skripts:

#!/usr/bin/perl -w

Etwas ungewöhnlich ist die Option -w. Sie zeigt alle Warnungen in ausführlicher Form an. Die Dokumentation weist ausdrücklich darauf hin, diese Option zu verwenden.

Perl besitzt wie alle Programmiersprachen Variablen. Allerdings sind deren Typen etwas ungewöhnlich. Aber gerade das ist der Grund, warum Perl so extrem leistungsfähig ist. Um die verschiedenen Variablentypen zu unterscheiden, wird jeder Variablen ein Sonderzeichen vorangestellt.

Skalare nennt Perl die einfachen Variablen, die sowohl numerische Werte als auch Strings aufnehmen können. Enthält eine Variable eine Zahl, wo eine Zeichenkette erwartet wurde, wandelt Perl diese kurz entschlossen um. Auch umgekehrt wird eine Zeichenkette automatisch in eine Zahl umgewandelt, wenn eine Zahl erwartet wird. Ist der Inhalt nicht als Zahl zu interpretieren, ist ihr Wert eben 0.

Zahlenkonstanten können ganze Zahlen oder Fließkommazahlen sein. Zur Darstellung des Dezimalkommas verwendet Perl, wie im englischen Sprachraum üblich, den Punkt. Große Zahlen oder kleine Brüche stellt Perl mit Hilfe des vom Taschenrechner bekannten Buchstaben e dar. Hinter dem e steht der Exponent zur Basis 10, mit dem die Zahl zu multiplizieren ist. Um es einfacher zu sagen: Dort steht die Anzahl der Stellen, um die das Komma nach rechts zu verschieben ist. Die folgenden Zahlen sind alle gleich groß:

1.000000e6 10.00000e5 100.0000e4 1000.000e3 10000.00e2 100000.0e1 10000000 100000000e-1 1000000000e-2

hexadezimal und oktal

Zeichenkettenkonstanten werden in Anführungszeichen oder Hochkommata eingeschlossen. Der Unterschied zwischen beiden ist, dass innerhalb von Anführungszeichen Variablen ausgewertet werden und bei Hochkommata nicht.

In einer Zeichenkette gibt es für diverse Sonderzeichen spezielle Zeichen, die alle mit einem Backslash beginnen. Ihre Bedeutung ist in der folgenden Tabelle erklärt.

Symbol	Wirkung
\n	Line Feed
\t	Tabzeichen
\$	Dollarzeichen
\\	Backslash-Zeichen
\l	Nächstes Zeichen in Kleinbuchstaben umwandeln
\L .. \E	Zeichen zwischen \L und \E in Kleinbuchstaben umwandeln
\u	Nächstes Zeichen in Großbuchstaben umwandeln
\U .. \E	Zeichen zwischen \U und \E in Großbuchstaben umwandeln

Die Variablennamen von Skalaren werden durch ein $ eingeleitet. Danach muss ein Buchstabe oder ein Unterstrich erscheinen, und anschließend können in beliebiger Folge Buchstaben, Ziffern oder Unterstriche folgen. Ein Variablenname kann maximal 255 Buchstaben lang sein. Mein Tipp: Schöpfen Sie es nicht bis zum Letzten aus. Allerdings sollten Sie sich auch nicht auf zwei oder drei Buchstaben beschränken. Verwenden Sie so viele, dass klar wird, was die Variable enthält. Das folgende Beispiel ist auch für den Uneingeweihten leicht lesbar.

$rechnungsbetrag = $stunden * $stundensatz; $mwstbetrag = $rechnungsbetrag * $mwstsatz;

Dagegen werden Sie die folgenden zwei Zeilen vermutlich bereits in einem halben Jahr selbst nicht mehr verstehen, ohne sich enorm zu konzentrieren. Da Sie sich schon genug auf das Programmieren konzentrieren müssen, sollten Sie es sich ersparen, auch noch über die Bedeutung der Variablennamen nachgrübeln zu müssen.

$rgb = $std * $ss; $mb = $rgb * $ms;

Option -w

use strict

#/usr/bin/perl -w use strict; my $rechnungsbetrag; my $stunden; my $stundensatz; my $mwstsatz; my $mwstbetrag;

Der Mehraufwand, die Variablen ganz zu Anfang alle zu nennen, könnte den einen oder anderen Programmierer vielleicht sogar dazu verführen, hinter die Variable einen Kommentar zu schreiben, wozu die Variable gebraucht wird. Das würde wiederum denjenigen glücklich machen, der das Programm später warten muss. Und derjenige, der das Programm später warten muss, könnte im schlimmsten Fall der Autor selbst sein.

Oben wurde es schon ein wenig vorweggenommen: Die Variablen erhalten ihre Werte durch die Zuweisung. Das zuständige Zeichen ist das Gleichheitszeichen.

$name = "hugo"; $wert = 15;

Sie werden mit numerischen Variablen auch rechnen wollen. Dazu werden die Operatoren verwendet, die sich seit den Zeiten von Fortran inzwischen in fast allen Programmiersprachen durchgesetzt haben. Dabei werden die folgenden Operatoren jeweils zwischen zwei Operanden gestellt, weshalb man sie auch binäre Operatoren nennt.

Punkt vor Strich

Operator	Wirkung
+	Addition
-	Subtraktion
*	Multiplikation
/	Division
%	Modulo (Rest einer ganzzahligen Division)
**	Potenzierung

Aneinander\-hängen

$fullname = $firstname . " " . $lastname;

Vervielfältigen

$ruf = "hu" x 2;

Ersetzen

$apg =~ s/saulus/paulus/g;

my @primzahlen = (1,2,3,5,7,11,13,17,19); my @namensliste = ("Karl", "Friedrich", "Hans");

Bunt gemischte Elemente

Zugriff auf Arrayelemente

$wert = $primzahlen[4];

In diesem Fall wird das fünfte Element, also die 7, in die Variable $wert kopiert. Es ist nicht das vierte Element, da die Indizes bei 0 beginnen. Perl kann aber auch mehrere Elemente eines Arrays in ein anderes Array kopieren. In diesem Fall werden die einzelnen Indizes in der eckigen Klammer in der gewünschten Reihenfolge aufgezählt und durch Kommata getrennt:

@werte = @primzahlen[4,3,1];

Zuweisung an mehrere Variablen

($erst, $zweit, @neuprimzahlen) = @primzahlen;

Hier wird das erste Element des Arrays @primzahlen der Skalarvariablen $erst, das zweite der Skalarvariablen $zweit und der Rest des Arrays @primzahlen dem Array @neuprimzahlen zugewiesen. Das heißt, dass dem Array @neuprimzahlen die Werte 1 und 2 fehlen und dass es ansonsten die restlichen Werte von @primzahlen hat.

split()

@wort = split(/ /, $satz);

Der erste Parameter ist das Leerzeichen, das durch beliebige Zeichen eingeschlossen werden kann. Üblicherweise verwendet man Anführungszeichen oder Schrägstriche. $wort[0] hat anschließend das erste Wort von $satz, $wort[1] das zweite und so weiter.

Eine kleine Spielerei soll als Beispiel dienen. Mit der Funktion split() wird ein Name an der Stelle, wo sich Leerzeichen befinden, aufgespalten. Das erste Element ist dann der Vorname, und das zweite ist der Nachname.

#!/usr/bin/perl -w $ask = <STDIN>; chomp($ask); # wirf den Zeilenvorschub weg! @name = split(/ /, $ask); print $name[0]."\n"; print $name[1]."\n";

Da es Menschen gibt, die mehr als einen Vornamen besitzen, ist die Ermittlung des Nachnamens nicht besonders zuverlässig. An sich brauchen wir nicht das zweite, sondern das letzte Element des Arrays. Hier folgt die Änderung für die letzte Zeile:

print $name[$#name]."\n";

Dimension

Hash

%kfz = ('sl', 'Schleswig', 'fl','Flensburg','hh','Hamburg'); $kfz{'hg'} = 'Bad Homburg'; $kfz{'hg'} = 'Hochtaunuskreis'; $key="hg"; print "Schlüssel = $key, Wert = $kfz{$key}\n";

Definition

Werte hinzufügen und ändern

Zugriff auf Elemente

Löschen eines Elements

delete $kfz('hh');

Ein- und Ausgabe

Ausgabe

Eingabe

$ask = <STDIN>;

chomp

$ask = <STDIN>; chomp $ask;

#!/usr/bin/perl print "Skript name: ", $0, "\n"; print "Parameterzahl: ", $#ARGV, "\n"; print $ARGV[0], "\n"; print $ARGV[1], "\n"; print $ARGV[2], "\n";

Die Kombination $# liefert den höchsten Index des Arrays. Bei einem Parameter ist also $#ARGV gleich 0! Im Beispiel für den Aufruf des Skripts werden einmal zu viele und einmal gar keine Parameter übergeben:

gaston> argv.pl sonstwas und dann noch dies skript name: ./argv.pl Parameterzahl: 4 sonstwas und dann gaston> argv.pl skript name: ./argv.pl Parameterzahl: -1 gaston>

print $ENV{PRINTER};

Um einen neuen Wert für die Umgebungsvariable PRINTER zu setzen, wird ihr einfach ein neuer Wert zugewiesen:

$ENV{PRINTER}="laser";

Bedingungen

Operator	Bedeutung
==	gleich
!=	ungleich
<	kleiner
<=	kleiner oder gleich
>	größer
>=	größer oder gleich
<=>	Vergleich. Siehe unten

Der Vergleich <=> fällt etwas heraus, da er keinen booleschen Wert zurückgibt. Er liefert 0, wenn beide Werte gleich sind. Er liefert 1, wenn der linke Wert größer als der rechte ist, und -1, wenn der rechte Wert größer als der linke ist.

Für den Vergleich zweier Zeichenketten gibt es die folgenden Operatoren.

Operator}	Bedeutung
eq	Sind die Strings gleich?
ne	Sind die Strings ungleich?
lt	Ist der erste String kleiner?
le	Ist der erste String kleiner oder gleich?
gt	Ist der erste String größer?
ge	Ist der erste String größer oder gleich?
cmp	Wie strcmp in C: liefert -1 bei kleiner, 0 bei gleich und 1 bei größer

Auch der Vergleich cmp liefert keinen booleschen Wert, sondern eine Zahl.

Suchen in Zeichenketten

$a =~ /suchmich/i

if

if ( $wert > 5 ) { print "Mensch, der Wert ist ja über 5!\n"; }

else

elsif

#!/usr/bin/perl -w $ask = ; chomp($ask); # wirf den Zeilenvorschub weg! if ( $ask eq ärnold" ) { print "Hallo, Arnold!\n"; } elsif ($ask eq "willemer" ) { print "Hochverehrter Herr Willemer!\n"; } else { print "Was willst Du denn hier, $ask?\n"; }

Eingabe

Entscheidung

for

for ($i=0 ; $i<10 ; $i++ ) { print "$i\n"; }

In der Klammer hinter dem for stehen drei Anweisungen, die je durch ein Semikolon getrennt werden. Als Erstes erscheint die Startanweisung. Sie wird einmal vor dem Beginn der Schleife ausgeführt. In diesem Fall setzt sie den Inhalt des Skalars $i auf 0. Die zweite Anweisung ist die Schleifenbedingung. Sie wird vor jedem Durchlauf der Schleife überprüft. Trifft sie nicht mehr zu, wird die Schleife beendet. Der dritte Teil wird nach jedem Durchlauf am Ende des Schleifenblocks durchgeführt. Im Beispiel steht hier die Anweisung, den Skalar hochzuzählen.

Das folgende Beispiel zeigt alle Aufrufparameter des Perl-Skripts an.

#!/usr/bin/perl print ßkript name: ", $0, "\n"; print "Parameterzahl: ", $#ARGV, "\n"; print "Parameterliste: \n"; for ($i=0; $i<=$#ARGV; $i++) { print "$i.: ", $ARGV[$i], "\n"; }

Die Kombination $# liefert den höchsten Index des Arrays. Ist das Array leer, ist dieser Wert -1. Bei einem Parameter ist $#ARGV gleich 0! Aus diesem Grund läuft $i in der Schleife auch bis <= $#ARGV. Für den C-Programmierer etwas gewöhnungsbedürftig ist, dass $i auch innerhalb des Strings ausgewertet wird. Hier sehen Sie ein Beispiel für den Aufruf des Skripts:

gaston> argv.pl sonstwas und dann noch dies skript name: ./argv.pl Parameterzahl: 4 Parameterliste: 0.: sonstwas 1.: und 2.: dann 3.: noch 4.: dies gaston> argv.pl skript name: ./argv.pl Parameterzahl: -1 Parameterliste: gaston>

Schleife über eine Liste

foreach $i (@array) { print $i."\n"; }

Hier nimmt der Skalar $i nacheinander die Werte des Arrays @array an. In jedem Durchlauf wird also ein Element von @array angezeigt. Das folgende Beispiel wertet wieder die Aufrufparameter aus. Hier sehen Sie, wie foreach die Schleife erheblich vereinfacht:

#!/usr/bin/perl print "Parameterliste: \n"; for ($i (@ARGV) { print "$i \n"; }

Nun soll eine Hashvariable ausgewertet werden. Sie soll in der alphabetischen Reihenfolge ihrer Schlüssel angezeigt werden:

%kfz = ('sl', 'Schleswig', 'fl','Flensburg','hh','Hamburg'); $kfz{'hg'} = 'Bad Homburg'; foreach $key (sort keys(%kfz)) { print "Key = $key, Value = $kfz{$key}\n"; }

keys und sort

$i = 0; while ($i<3) { print "$i\n"; $i++; }

Die Bedingung wird zu Beginn geprüft. Trifft sie zu Beginn nicht zu, wird die Schleife nicht durchlaufen.

$i = 0; do { print "$i\n"; $i++; } while ($i<3);

Da hier die Bedingung am Ende geprüft wird, wird die Schleife einmal durchlaufen, auch wenn die Bedingung bereits zu Anfang nicht zutrifft.

$i = 0; until ($i>=3) { print "$i\n"; $i++; }

Im Gegensatz zur ersten while-Schleife wird hier die negierte Abfrage geprüft. Im Grunde ist das die gleiche Schleife wie die erste, die mit while erstellt wurde. Die Negierung einer Bedingung ist im Allgemeinen aber schlechter lesbar als die Verwendung von until statt while.

Zu guter Letzt sehen Sie noch die vierte mögliche Variante. Hier wird ebenfalls die Schleife mindestens einmal durchlaufen, bevor die Bedingung geprüft wird.

$i = 0; do { print "$i\n"; $i++; } until ($i>=3);

Zerlegen eines Arrays

while (@array) { ($a, $b, @neu) = @array; print $a." ".$b."\n"; @array = @neu; }

Im Innern der Schleife wird das Array durch die Zuweisung jeweils in zwei Skalare und ein neues Array aufgespalten. Die Skalare werden paarweise ausgegeben, und das Restarray wird dem Original zugewiesen.

CGI-Auswertung

Name=Willemer&Adresse=Ihre+Adresse%0D%0AOrt&Anrede=Frau

Das Skript soll die Zeichenkette aufbrechen, und in einem Hash ablegen und den Hash ausgeben. Statt der Ausgabe würde man in der Praxis die Werte in eine Datenbank stellen oder zu einer Datenbankabfrage umformen.

#!/usr/bin/perl -w use strict; my %input; my $zeile; my $key; my $wert; my @zuweisungen; my @neu; my $input = "Name=Otto&Adresse=Mein+Weg%0D%0AOrt&Anrede=Frau"; @zuweisungen = split("&", $input); while (@zuweisungen) { ($zeile, @neu) = @zuweisungen; ($key, $wert) = split("=", $zeile); $wert =~ s/\+/ /g; # + durch leer ersetzen! $input{$key} = $wert; @zuweisungen = @neu; } # Ausgabe foreach $key(sort keys(%input)) { print "Key = $key, Value = $input{$key}\n"; }

sub linie { print '-' x 79 . "\n; } \dots linie; \dots linie;

Funktionen haben den Vorteil, dass Programmzeilen nicht an verschiedenen Stellen des Programms wiederholt werden müssen. Das Vermeiden von Wiederholungen sorgt für weniger Fehlerquellen. Fehlerkorrekturen in Funktionen, die häufiger aufgerufen werden, lassen mehrere Stellen des Programms davon profitieren. Daneben sorgen Funktionen für Übersicht. Da Details in den Funktionen verborgen werden, entsteht ein Blick auf die Struktur des Gesamtprogramms.

Parameter

sub linie { print '-' x $\_[0] . "\n"; } \dots linie(5); \dots linie 15;

Lokale Variablen

Dateien

Schreiben und Lesen

Öffnen und Schließen

open(HANDLE, $filename) || die "Datei nicht zugreifbar"; close(HANDLE);

Fehlerbehandlung

Lesen

$zeile = ;

Schreiben

print HANDLE $value;

cat als Perl-Skript

#!/usr/bin/perl -w use strict; my $datei; # der jeweilige Dateiname my $zeile; # die Zeile, die aus der Datei gelesen wird. foreach $datei (@ARGV) { open(HANDLE, $datei) || die "Fehler beim Öffnen $datei\n"; while ($zeile = ) { print $zeile; } close HANDLE; }

Dateioperationen

Befehl	Wirkung
unlink $filename	Löschen einer Datei
rename $filename,$neuname	\"Andern des Namens einer Datei
mkdir $filename	Erzeugen eines Verzeichnisses
rmdir $filename	Löschen eines Verzeichnisses

Weitere Funktionen finden Sie auf der Manpage namens perlfunc.

Dateiprüfung

if ( -f '.rhosts' ) { unlink '.rhosts'; }

Die wichtigsten unären Operatoren:

Flag	Bedeutung
-r -w -x	Vom effektiven UID/GID les-, schreib- bzw. ausführbar
-R -W -X	Vom realen UID/GID les-, schreib- bzw. ausführbar
-f	Existiert als Datei
-d	Existiert als Verzeichnis
-l	Existiert als symbolischer Link

Aufruf von UNIX-Programmen

$datum = `date +%D`; print "$datum\n";

Der Befehl date wird aufgerufen, und seine Ausgabe an die Standardausgabe wird in den Skalar $datum umgeleitet. Die einschließenden Striche sind keine Apostrophe, sondern das Zeichen, das dieselbe Richtung hat wie der Backslash. Aus diesem Grund wird das Zeichen auch Backquote genannt. Die Funktion print() liefert das Ergebnis auf dem Bildschirm.

Das Gleiche funktioniert auch, wenn die Ausgabe des Befehls mehrere Zeilen umfasst. Sie müssen dessen Ausgabe allerdings in einem Array speichern. Als Beispiel wird hier der Befehl ls verwendet:

@dir = `ls`;

Mit dem Programmpaket Perl wird unter UNIX normalerweise eine umfangreiche Dokumentation in Form von Manpages installiert. Beim Aufruf von man perl bekommen Sie in erster Linie eine Übersicht über diese Manpages und was sie beinhalten.

Eine wichtige Informationsquelle im Internet ist die Webseite: