Homepage-Webhilfe Event-Banner

Perl-Crashkurs

Perl ist eine frei verfügbare Skriptsprache, welche von Larry Wall entwickelt wurde und 1987 erstmals erschien. Der ursprüngliche Einsatz von Perl war die Verarbeitung von Textdateien. Durch die schon damals stetig wachsende Bedeutung des World Wide Webs wurde Perl schon bald über die CGI-Schnittstelle angebunden, um dadurch dynamische Webseiten zu erzeugen.

Dieser Crashkurs befasst sich mit den Grundlagen der Skriptsprache Perl (z B. Syntax, Variablen, Bedingungen, Schleifen und Unterprogramme). Ein Tutorial zum Einsatz von Perl für dynamische Webseiten (CGI-Schnittstelle) finden Sie ebenfalls auf dieser Website. Um diesem Tutorial folgen zu können, sollten Sie bereits ein allgemeines Verständnis für die Programmierung haben.


Der Syntax von Perl ist von der Formatierung relativ frei, d. h. nicht benötigte Leerzeichen oder Zeilenumbrüche werden nicht interpretiert, sondern ignoriert. Anweisungen müssen jedoch stets mit einem Semikolon ; abgeschlossen werden. Grundsätzlich kann man sagen, dass der Syntax ähnlich wie bei der Programmiersprache C ist.

Die erste Zeile in einem Perl-Dokument ist die sogenannte Shebang-Zeile. Diese gibt den Pfad zum Perl-Interpreter an und beginnt mit den Zeichen #!. Die Shebang-Zeile spielt unter Windows nur bei Verwendung über die CGI-Schnittstelle eine Rolle. Die folgende Shebang-Zeile zeigt ein typisches Beispiel, wie es in einem Perl-Skript üblicherweise verwendet wird, wenn es auf einem Windows-Computer mit XAMPP eingesetzt wird:

#!C:\xampp\perl\bin\perl -w

Variablen werden in Perl mit dem Schlüsselwort my deklariert. Anschließend wird ein Datentyppräfix (dazu gleich mehr) und der Name der Variablen angegeben. Variablen sind dabei immer nur in dem Bereich gültig, wo sie definiert wurden (Gültigkeitsbereich, engl. scope) und müssen in diesem Bereich vom Namen eindeutig sein. Die Eindeutigkeit eines Namens bezieht sich jedoch auf den Datentyp, d. h. es darf zwei Variablen mit dem gleichen Namen geben, sofern diese von einem anderen Datentyp sind.

Der wichtigste Datentyp in Perl sind die sogenannten Skalare. Skalare sind typenlose Datentypen, in welchen Zahlen (Ganzzahlen oder Gleitkommazahlen), Zeichenketten und Referenzen gespeichert werden können. Als Präfix für Skalare wird das $-Zeichen verwendet.

my $meineVariable;

Nun können Sie der Variablen einen Wert zuweisen. Dafür notieren Sie den Variablennamen inkl. vorangestelltem Präfix einem Gleichheitszeichen = und dem zuzuweisenden Wert:

$meineVariable = 123;

Es ist natürlich auch möglich, die Variablendeklaration und die erste Zuweisung (auch als Variableninitialisierung bezeichnet) zu kombinieren:

my $meineVariable = 123;

Möchten Sie eine Variable wieder löschen, so können Sie den Befehl undef verwenden:

undef $meineVariable;

Wichtig: Wir empfehlen Ihnen dringendst die Verwendung des „strikten Modus“, um unsichere Konstrukte (wie z. B. das nicht definieren von Variablen) nicht zuzulassen.

use strict;

In Perl werden alle Zahlen (unabhängig ob es sich um eine Ganzzahl oder Gleitkommazahl handelt) als 32-Bit Gleitkommazahl nach IEEE754 gespeichert. Dadurch ist es möglich, sehr große, aber auch sehr kleine, Zahlen darstellen zu können. Jedoch sollte beachtet werden, dass dadurch auch Ungenauigkeiten entstehen können. Die Angabe von Zahlen kann direkt im Dezimalformat oder als Gleitkommazahl erfolgen. Bei der Angabe von Gleitkommazahlen ist jedoch darauf zu achten, dass als Trennzeichen der Punkt und nicht das Komma verwendet wird. Zahlen können zudem in der Exponentialschreibweise angegeben werden. Ganzzahlen können des Weiteren auch in der Hexadezimal- (0x-Präfix) oder in der Oktalschreibweise (vorangestellte 0) notiert werden.

$ganzzahl1 = 123;
$ganzzahl2 = -456;
$gleitkommazahl1 = 70.89;
$gleitkommazahl2 = -476.538;
$exponential1 = 2.54+1;
$exponential2 = 1000-7;
$hexadezimal = 0x1234;
$oktal = 0567;

Natürlich kann in Perl mit Zahlen nach Belieben gerechnet werden. Dafür stehen die Operatoren der Grundrechenarten zur Verfügung. Der Doppelstern-Operator ** ist ein weiterer mathematischer Operator, welcher eine Potenzrechnung ermöglicht. Perl beachtet die Punkt-Vor-Strich-Regelung und ermöglicht die Verwendung von Klammern.

$k = $c + 273.15;
$f = $c * 1.8 + 32;
$u = ($a + $b) * 2;

Übrigens: Formeln wie z. B. $a = $a + $b können durch den Ausdruck $a += $b abgekürzt werden. Dies ist natürlich auch für andere Operatoren wie -, * und / möglich.

Perl erlaubt zudem die Verwendung der Operatoren ++ und --, welche zur Inkrementierung (Addition von 1) bzw. Dekrementierung (Subtraktion von 1) einer Variablen genutzt wird. Dabei wird der ursprüngliche Wert der Variablen verändert.

$a++;
$a--;

Als Zeichenkette wird eine Aneinanderreihung von einzelnen Zeichen (dies können Ziffern, Buchstaben etc. sein) bezeichnet. Anders als in anderen Programmiersprachen kennt Perl jedoch keinen speziellen Datentyp für ein einzelnes Zeichen. Auch ein einzelnes Zeichen wird daher gespeichert wie eine Zeichenkette. Eine leere Zeichenkette kann ebenfalls notiert werden. Zeichenketten gehören ebenfalls zu den Skalaren und werden entweder in einfachen oder doppelten Anführungszeichen notiert.

$text1 = "Hier steht ein Text!";
$text2 = 'Hier steht ein Text!';

Beim obigen Beispiel macht es keinen Unterschied, ob Sie einfache oder doppelte Anführungszeichen verwenden. Deshalb wollen wir uns ein anderes Beispiel ansehen:

$sum = 123;
$text1 = "Das Ergebnis ist $sum";
$text2 = 'Das Ergebnis ist $sum';

In diesem Fall enthält $text1 nun die Zeichenkette "Das Ergebnis ist 123", wohingegen in der Variablen $text2 noch immer 'Das Ergebnis ist $sum' steht. Möchten Sie Escapezeichen (z. B. \n für einen Zeilenumbruch) verwenden, so müssen Sie doppelte Anführungszeichen verwenden. In einer Zeichenkette, welche in einfachen Anführungszeichen angegeben ist, würde die Sequenz \n einfach stehenbleiben.

Um zwei (oder mehrere) Zeichenketten zu kombinieren, kann der Punkt-Operator . verwendet werden:

$aussage = "Hallo!";
$frage = "Wie geht es dir?";
$text = $aussage." ".$frage;

Um mit Zeichenketten zu arbeiten, gibt es einige vordefinierte Funktionen. Funktionen (auch Unterprogramme genannt) können sogenannte Parameter (diese werden innerhalb von runden Klammern und durch Komma getrennt angegeben) besitzen und geben u. U. einen Wert zurück. Die Funktion length() ermittelt die Länge einer Zeichenkette und gibt diese zurück.

$text = "Hier steht ein Text!";
$len = length($text);

Mit Hilfe der Funktionen uc() und lc() können Sie alle Buchstaben einer Zeichenkette in Großbuchstaben (engl. upper case) oder in Kleinbuchstaben (engl. lower case) umwandeln. Zusätzlich gibt es noch die Funktionen ucfirst() und lcfirst(), welche lediglich den ersten Buchstaben umwandeln. Die Funktionen ändern dabei nicht den Inhalt der übergebenen Zeichenkette, sondern geben eine neue zurück.

$text = "Hier steht ein Text!";
$gross = uc($text);
$klein = lc($text);

Möchten Sie von einer Zeichenkette einen Teil extrahieren (eine sogenannte Teilzeichenkette), so kann Ihnen die Funktion substr() behilflich sein. Der Funktion substr() wird die Zeichenkette, aus welcher ein Teil extrahiert werden soll, die Startposition und ggf. eine Länge übergeben. Die Startposition ist 0 basierend, d. h. das erste Zeichen hat den Index 0. Der Parameter für die Länge kann weggelassen werden.

$text = "Hier steht ein Text!";
$teil = substr($text, 15, 4);

Neben den skalaren Variablen gibt es in Perl noch Arrays. Arrays zeichnen sich durch den Präfix @ aus und erlauben es, mehrere Skalare in einer Variablen zu speichern.

my @liste;

Arrays können natürlich bei der Deklaration auch gleich initialisiert werden. Dafür notieren Sie alle Werte durch Komma getrennt innerhalb eines runden Klammernpaars:

my @liste = ("rot", "grün", "blau", "gelb");

Der Zugriff auf einen Array-Eintrag erfolgt mit Hilfe eines Index. Der erste Eintrag hat den Index 0, der zweite Eintrag den Index 1 usw.. Zusätzlich sollten Sie beachten, dass beim Setzen oder Lesen eines Werts von einem Array das $-Zeichen (wie bei Skalaren) verwendet wird, da Sie nicht auf das Array, sondern nur auf einen Eintrag im Array zugreifen. Im folgenden Beispiel wird der 3. Wert des Arrays (Index 2) in die Variable $eintrag geschrieben:

$eintrag = $liste[2];

Natürlich können Sie auch einen Eintrag eines Arrays ändern:

$liste[2] = "schwarz";

Um ein Array zu verändern (abgesehen vom Zuweisen eines Werts), gibt es vier wichtige Funktionen: push(), unshift(), pop() und shift(). Die Funktion push() fügt dem Array einen oder mehrere Werte (durch Komma getrennt) am Ende hinzu. Auch die Funktion unshift() erweitert ein Array um Einträge, jedoch werden diese am Anfang des Arrays hinzugefügt. Beide Funktionen geben die neue Größe des Arrays zurück. Im Gegensatz zu push() und unshift() sind die Funktionen pop() und shift() dazu gedacht, einen Eintrag aus dem Array zu entfernen. pop() löscht den letzten Eintrag, wohingegen shift() den ersten Eintrag löscht. Von beiden Funktionen bekommen Sie den gelöschten Wert zurückgeliefert.

my @liste = ("CSS", "JavaScript", "PHP", "ASP.NET");
unshift(@liste, "HTML");
pop(@liste);
push(@liste, "Perl");

Übrigens: Um die Länge eines Arrays zu ermitteln, müssen Sie das Array lediglich einer skalaren Variablen zuweisen.

Ein nützlicher Syntax den Perl anbietet, ist die Zuweisung eines Arrays auf eine Liste von Skalaren:

my @farbanteile = (120, 170, 240);
my ($red, $green, $blue) = @farbanteile;

Hash-Tabellen (auch assoziative Arrays genannt) sind eine besondere Art von Arrays, die, anders als normale Arrays, keinen festen nummerischen Index verwenden, sondern einen benutzerdefinierten Schlüssel haben. Ein Eintrag in einer Hash-Tabelle besteht deshalb also aus einem Schlüssel und einem Wert. Die Kennung einer Hash-Tabelle ist das Prozentzeichen %.

my %farben;

Natürlich ist es auch möglich, eine Hash-Tabelle gleich bei der Deklaration mit Werten zu füllen:

my %farben = (
    red => 0xFF0000
    green => 0x00FF00
    blue => 0x0000FF
);

Möchten Sie nun einen Wert aus einer Hash-Tabelle lesen, so notieren Sie das Dollarzeichen $, gefolgt von dem Namen der Hash-Tabelle, einem Paar von geschweiften Klammern und dem Schlüssel.

$eintrag = $farben{green};

Natürlich kann auf diese Weise auch der Wert geändert werden:

$farben{green} = 0x008000;

Das Hinzufügen eines Werts erfolgt auf die gleiche Art.

$farben{black} = 0x000000;

Um in Perl etwas (auf die Konsole bzw. den Ausgabe-Stream) auszugeben, verwenden Sie den Befehl print:

print "Hallo!";
print "Wie geht es dir?";

Möchten Sie am Ende der Ausgabe einen Zeilenumbruch hinzufügen, so können Sie diesen entweder selbst in einer Zeichenkette angeben oder den Befehl say verwenden:

say "Hallo!";
say "Wie geht es dir?";

Bedingungen werden dazu benötigt, um Abfragen (Verzweigungen) oder Schleifen zu verwenden. Im Prinzip bestehen Bedingungen lediglich aus den Vergleichen von zwei Werten. Mehrere Vergleiche können über die Schlüsselwörter and (Und, als Zeichen auch &&), or (Oder, als Zeichen auch ||) und xor (Exklusiv-Oder) verknüpft werden. Eine Negierung (Umkehrung) des Wahrheitswerts kann mit Hilfe des Schlüsselworts not (als Zeichen auch !) durchgeführt werden. Die folgende Tabelle zeigt, welche Vergleichsoperatoren es in Perl gibt:

Operatoren Beschreibung
Zahlen Zeichenketten
== eq gleich
!= ne ungleich
< lt kleiner als
<= le kleiner als oder gleich
> gt größer als
>= ge größer als oder gleich
<=> cmp -1, falls kleiner; 0, falls gleich; +1, falls größer

Möchten Sie einen bestimmten Code nur dann durchführen, wenn eine Bedingung zutrifft, so können Sie eine Abfrage mittels if (einfache Verzweigung) durchführen:

if ($a > $b)
{
    print "$a ist größer als $b";
}

Wichtig: Das Weglassen der geschweiften Klammern ist in Perl nicht erlaubt.

Möchten Sie einen Code definieren, welcher ausgeführt werden soll, wenn die Bedingung nicht zutrifft, so können Sie den else-Block verwenden.

if ($a > $b)
{
    print "$a ist größer als $b";
}
else
{
    print "$a ist nicht größer als $b";
}

Des Weiteren ist es möglich, weitere Bedingungen zu stellen, falls die ersten Fälle nicht zutreffen. Hierfür benötigen Sie dann den elsif-Block:

if ($a > $b)
{
    print "$a ist größer als $b";
}
elsif ($b > $a)
{
    print "$b ist größer als $a";
}
else
{
    print "$a und $b sind gleich";
}

Um einen Code nur auszuführen, wenn die Bedingung nicht zutrifft, müssen Sie die Bedingung entweder negieren oder den unless-Block verwenden. Der Code innerhalb des unless-Blocks wird nur ausgeführt, wenn die Bedingung nicht zutrifft.

unless ($a > $b)
{
    print "$a ist nicht größer als $b";
}

Möchten Sie einen Vorgang mehrmals ausführen, so benötigen Sie eine Schleife. Schleifen haben ebenfalls eine Bedingung, welche i. d. R. angibt, ob der Codeblock innerhalb der Schleife ausgeführt werden soll oder nicht. Die Bedingung einer Schleife wird immer vor der Ausführung des eigentlichen Codes überprüft. Die einfachste Schleife ist die while-Schleife:

my $zaehler = 0;
while ($zaehler <= 5)
{
    say $zaehler;
    $zaehler++;
}

Dieser Code würde nun die Zahlen 0 bis 5 ausgeben (da die Bedingung nicht mehr zutrifft, wenn $zaehler den Wert 6 hat). Für solche Zählvorgänge werden jedoch meistens for-Schleifen verwendet, da diese einen ausgeprägten Schleifenkopf haben, die genau für dieses Verfahren entworfen sind:

for (my $zaehler = 0; $zaehler <= 5; $zaehler++)
{
    say $zaehler;
}

Das Beispiel erzeugt die gleiche Ausgabe wie das Beispiel zur while-Schleife, ist jedoch übersichtlicher. Eine weitere Schleife ist die foreach-Schleife. Hiermit können wir den Zählvorgang noch weiter vereinfachen:

foreach my $zaehler (0..5)
{
    say $zaehler;
}

Eine weitere beliebte Variante zur Verwendung der foreach-Schleife ist das Abarbeiten eines Arrays:

my @farben = ("red", "green", "blue");
foreach my $farbe (@farben)
{
    say $farbe;
}

Die Schlüsselwörter for und foreach können gegeneinander ausgetauscht werden. Jedoch empfehlen wir Ihnen, die hier vorgestellten Varianten zu verwenden.

Wie bereits oben erwähnt, gibt die Bedingung einer Schleife an, ob der Schleifeninhalt ausgeführt werden soll oder nicht. Anders ist dies bei der until-Schleife. Der Schleifeninhalt wird hier immer dann ausgeführt, wenn die Bedingung nicht zutrifft. Die Schleife wird also erst dann beendet, wenn die Bedingung zutrifft.

my $zaehler = 0;
until ($zaehler == 5)
{
    say $zaehler;
    $zaehler++;
}

Um den Ablauf einer Schleife zu beeinflussen, können Sie die Befehle next und last verwenden. next springt dabei erneut zum Schleifenkopf, wohingegen last die Schleife beendet. Das folgende Beispiel gibt daher nur die Zahlen 0, 2 und 3 aus:

my $zaehler = 0;
while ($zaehler < 5)
{
    if ($zaehler == 1)
    {
        $zaehler++;
        next;
    }
    if ($zaehler == 4)
    {
        last;
    }
    say $zaehler;
    $zaehler++;
}

In Perl ist es Ihnen natürlich auch möglich, Unterprogramme (besser bekannt als Funktionen) zu schreiben, um diese mehrmals an unterschiedlichen Stellen nutzen zu können. Zur Definition eines Unterprogramms benötigen Sie das Schlüsselwort sub.

sub Hallo
{
    print "Hallo Welt!";
}

Möchten Sie eine Funktion aufrufen, so notieren Sie den Namen der Funktion, gefolgt von einem runden Klammernpaar:

Hallo();

Alternativ ist es auch möglich, die Funktion aufzurufen, indem das &-Zeichen, gefolgt von dem Funktionsnamen angegeben wird.

&Hallo;

Das Weglassen des &-Zeichen (und der Klammern) ist dann möglich, wenn die Funktion oberhalb des Aufrufs definiert wurde oder ein Prototyp oberhalb des Aufrufs notiert ist:

Hallo;

Funktionen können auch einen Wert zurückgeben. Dafür muss in der Funktion lediglich das Schlüsselwort return mit dem zurückzugebenden Wert angegeben werden.

sub getPi
{
    return 3.141592654;
}

Möchten Sie einer Funktion einen Wert übergeben, so müssen Sie diese lediglich innerhalb der runden Klammern durch Komma getrennt angeben. Um von der Funktion aus, auf die Parameter zuzugreifen, können Sie das vordefinierte Array @_ verwenden.

sub getRechteckUmfang
{
    return ($_[0] + $_[1]) * 2;
}

Ein Aufruf würde beispielsweise wie folgt aussehen:

my $umfang = getRechteckUmfang(12, 17);

Um das aktuelle Datum und die aktuelle Uhrzeit zu ermitteln, können Sie die Funktion localtime() verwenden. Die Funktion localtime() erwartet keine Übergabeparameter und gibt ein Array zurück, in welchem die Sekunden (0-59), die Minuten (0-59), die Stunden (0-23), der Tag des Monats (1-31), der Monat (0-11), das Jahr (Anzahl der Jahre seit 1900) und ein Bit, ob es sich um die Sommerzeit handelt, enthalten sind (in dieser genannten Reihenfolge). Eine weitere Funktion, welche im Prinzip fast genau gleich arbeitet, ist gmttime(). gmttime() gibt jedoch die UTC-Zeit zurück, wohingegen localtime() die Lokalzeit zurückgibt. Bei Verwendung der gmttime()-Funktion ist das Sommerzeit-Bit also immer 0.

my ($sekunde, $minute, $stunde, $tag, $monat, $jahr, $sommer) = localtime();
my $sekundenSumme = ((($stunde * 60) + $minute) * 60) + $sekunde;

Um Zeitmessungen durchzuführen, eignet sich die Funktion time(). Diese gibt den aktuellen UNIX-Zeitstempel zurück, welcher die Anzahl an Sekunden seit dem 01.01.1970 00:00:00 repräsentiert.

$zeitstempel = time();

Bevor wir auf den Inhalt einer Datei zugreifen oder diesen verändern können, müssen wir die Datei öffnen. Dazu dient die Funktion open(). Als erster Parameter wird eine Art Variablenname (frei definierbarer aber eindeutiger Name des Streams, auch als Dateihandle bezeichnet) angegeben. Der nächste Parameter gibt den Dateinamen (ggf. mit Pfad) an. Vor der Angabe des Speicherorts müssen Sie noch den Modus angeben, in welchem Sie die Datei öffnen möchten. Die gängigsten Modi sind < (lesender Zugriff), > (schreibender Zugriff, Datei wird angelegt oder überschrieben) und >> (schreibender Zugriff, Datei wird angelegt oder der Inhalt an das Ende der Datei angehängt).

open(DATEI, "<datei.txt");

Sind Sie mit dem Dateizugriff fertig, so sollten Sie die Datei wieder schließen. Hierfür verwenden Sie die Funktion close():

close(DATEI);

Möchten Sie den kompletten Inhalt der Datei einlesen, so müssen Sie den Namen des Dateihandles in eckigen Klammern notieren und z. B. einem Array zuweisen:

my @zeilen = <DATEI>;

Das Auslesen eines einzelnen Zeichens können Sie mit der Funktion getc() erledigen. Schlägt das Lesen fehl (z. B. weil sich der Dateizeiger am Ende der Datei befindet) so wird undef zurückgegeben.

$zeichen = getc(DATEI);

Haben Sie eine Datei mit Schreibzugriff geöffnet und möchten etwas in die Datei schreiben, so notieren Sie den print (oder say) Befehl, bei welchem Sie zwischen dem Befehl und dem zu schreibenden Inhalt den Namen des Dateihandles notieren:

print DATEI "Hallo Welt!";

Möchten Sie die Dateiposition innerhalb der Datei ermitteln, so können Sie die Funktion tell() aufrufen:

$position = tell(DATEI);

Natürlich ist es auch möglich, die Dateiposition zu setzen. Hier kann Ihnen die Funktion seek() helfen. Als Parameter wird das Dateihandle, das Positionsoffset und die Positionierungsart (0 = absolute Positionierung, 1 = Positionierung zur aktuellen Dateiposition, 2 = Positionierung zum Dateiende) übergeben.

seek(DATEI, 50, 0);

Die Funktion rename() ermöglicht es, Dateien umzubenennen. Als Parameter werden zwei Dateinamen übergeben:

rename("log.txt", "log.bak");

Eine weitere nützliche Funktion ist delete(). Diese erlaubt es, eine Datei zu löschen:

delete("log.bak");
Um unsere Webseite für Sie optimal zu gestalten und fortlaufend verbessern zu können, verwenden wir Cookies. Durch die weitere Nutzung der Webseite stimmen Sie der Verwendung von Cookies zu. Weitere Informationen OK