Galileo Computing < openbook >
Galileo Computing - Professionelle Buecher. Auch fuer Einsteiger.
Galileo Computing - Professionelle Buecher. Auch fuer Einsteiger.


Kompendium der Informationstechnik
 von Sascha Kersken
EDV-Grundlagen, Programmierung, Mediengestaltung
Buch: Kompendium der Informationstechnik
gp Kapitel 5 Grundlagen der Programmierung
  gp 5.1 Die Programmiersprache C
    gp 5.1.1 Das erste Beispiel
    gp 5.1.2 Elemente der Sprache C
    gp 5.1.3 Die C-Standardbibliothek
  gp 5.2 Java
    gp 5.2.1 Grundlegende Elemente der Sprache Java
    gp 5.2.2 Objektorientierte Programmierung mit Java
  gp 5.3 Perl
    gp 5.3.1 Das erste Beispiel
    gp 5.3.2 Elemente der Sprache Perl
  gp 5.4 Zusammenfassung

gp

Prüfungsfragen zu diesem Kapitel (extern)


Galileo Computing

5.3 Perl  downtop

Bis jetzt wurden in diesem Kapitel zwei kompilierte Programmiersprachen behandelt, eine prozedurale und eine objektorientierte. In diesem Abschnitt wird eine völlig anders konzipierte Variante erläutert: Perl ist eine interpretierte Skriptsprache, die verschiedene nützliche Eigenschaften von C, den UNIX-Shell-Skriptsprachen sowie den Textprozessorsprachen sed und awk in sich vereint.

Perl wurde 1987 von Larry Wall entwickelt, als er im Rahmen eines Programmierauftrags umfangreiche Datenbestände koordinieren musste, die auf Rechnern an beiden Küsten der USA verteilt waren. Heute wird Perl vorwiegend von UNIX-Systemadministratoren verwendet, um ihre tägliche Arbeit zu erleichtern, außerdem ist Perl die klassische Sprache für CGI-Skripte (siehe Kapitel 18, Serverseitig dynamische Websites).

Perl-Distributionen

Obwohl Perl unter UNIX entwickelt wurde und eng mit den besonderen Eigenschaften dieses Betriebssystems verknüpft ist, ist der Perl-Interpreter für viele verschiedene Betriebssysteme verfügbar. Wenn Sie eine UNIX-Variante verwenden, ist Perl mit Sicherheit bereits auf Ihrem Rechner installiert. Falls Sie mit Windows arbeiten, bietet sich die hierfür optimierte Perl-Distribution ActivePerl an, die Sie unter www.activestate.com herunterladen können. Für Mac  OS 9 ist die einzige Wahl die etwas abgespeckte Version MacPerl (www.macperl.com).

Um ein Perl-Programm auf Ihrem Rechner auszuführen, müssen Sie es dem Perl-Interpreter übergeben. Unter UNIX geschieht dies durch die Shebang-Zeile zu Beginn des Skripts, die dem System das Verzeichnis mitteilt, in dem sich der Interpreter befindet:

#!/usr/bin/perl

Eine auf diese Weise präparierte Datei müssen Sie nur noch mittels chmod +x ausführbar setzen, um sie zu starten. Unter Windows wird dagegen auf der Kommandozeile der Perl-Interpreter explizit aufgerufen:

C:\>perl meinprogramm.pl

Dennoch wird auch unter Windows die Shebang geschrieben; für Einsatzgebiete wie die CGI-Programmierung ist sie dort auch wichtig. Natürlich sieht sie ein wenig anders aus als unter UNIX, zum Beispiel so:

#!C:/perl/bin/perl.exe

Beachten Sie, dass auch unter Windows, anders als üblich, der / (Slash) als Pfadtrennzeichen verwendet wird.

Empfehlenswert ist übrigens die folgende Variante der Shebang:

#!/usr/bin/perl -w

Die Option -w schaltet ausführliche Warnmeldungen ein, die Sie auf mögliche Ungenauigkeiten oder Zweideutigkeiten hinweisen können. Dies kann auf Dauer Ihren Programmierstil erheblich verbessern.


Galileo Computing

5.3.1 Das erste Beispiel  downtop

Damit Sie Perl genauer mit den anderen in diesem Kapitel vorgestellten Programmiersprachen vergleichen können, sehen Sie hier die Perl-Fassung des »Hallo Welt«-Programms (Listing 5.6):

Listing 5.6   Das erste Perl-Beispiel

#!/usr/bin/perl -w
print "Hallo Welt!\n";
print "Ihr Name, bitte: ";
$name = <>;
chomp $name;
print "Hallo $name!";

Speichern Sie das Skript unter hallo.pl und führen Sie es aus, wie oben beschrieben.

Wie Sie sehen, ist dieses Perl-Skript die bisher kürzeste Variante dieses Programms. Das liegt vor allem daran, dass Perl-Skripte keine besonderen Formalitäten einhalten müssen: Es gibt kein explizites Hauptprogramm; ein Skript ist im einfachsten Fall lediglich eine Folge normaler Anweisungen. Im Folgenden werden die Zeilen des »Hallo Welt«-Skripts nacheinander beschrieben:

gp  print "Hallo Welt!\n";
print "Ihr Name, bitte: ";
Mit Hilfe von print werden Inhalte auf die Standardausgabe geschrieben. In Perl können Sie die Klammern um Funktionsargumente weglassen; dies ist nicht immer übersichtlich, aber speziell bei print allgemein üblich.
gp  $name = <>;
Mit Hilfe des etwas merkwürdig aussehenden Operators <> wird eine Zeile Text von der Standardeingabe gelesen. Wie weiter unten besprochen wird, kann zwischen den Klammern auch eine Datei angegeben werden, aus der gelesen werden soll.
    Im vorliegenden Fall wird die gelesene Zeile in der Variablen $name gespeichert. In Perl beginnen die Namen der verschiedenen Arten von Variablen mit speziellen Zeichen. Eine Variable, die einen einzelnen Wert speichern kann (Skalar genannt), fängt zum Beispiel mit einem Dollarzeichen an.
       
gp  chomp $name;
Die Funktion chomp entfernt den Zeilenumbruch vom Ende eines Strings. Der Zeilenumbruch, mit dem die eingegebene Zeile endet, wird nämlich von <> mit eingelesen und kann in vielen Fällen stören.
gp  print "Hallo $name!";
Einer der wichtigsten Vorteile der Einleitung von Variablennamen durch spezielle Zeichen besteht darin, dass innerhalb von Strings eine Variablensubstitution durchgeführt wird: Da Variablen an ihren Anfangszeichen erkennbar sind, kann der Perl-Interpreter sie auflösen.

Galileo Computing

5.3.2 Elemente der Sprache Perl  toptop

Im Folgenden werden verschiedene wichtige Bestandteile von Perl systematisch vorgestellt.

Variablen

Variablen funktionieren in Perl ein wenig anders als in typisierten Compilersprachen wie C oder Java. Wie viele andere interpretierte Skriptsprachen ist Perl nämlich eine untypisierte Sprache. Variablen besitzen keinen festen Datentyp, sondern ihr gespeicherter Inhalt wird je nach Kontext interpretiert. Außerdem können sie nacheinander verschiedene Werte annehmen, sodass Zuweisungen wie die folgenden erlaubt sind:

$a = "hallo";   # String
$a = 3;         # ganze Zahl
$a = 4.678;     # Fließkommazahl

Eine Variable existiert automatisch durch die erste Wertzuweisung und muss nicht deklariert werden. Dadurch werden Programme einerseits kürzer und kompakter, aber andererseits werden Fehler nicht so leicht bemerkt, weil Perl sich nicht beschwert, wenn Sie sich bei einem Variablennamen verschreiben. Eine Variable, die in einem Ausdruck verwendet wird, ohne dass ihr ein Wert zugewiesen wurde, hat den speziellen Wert undefined. Dies führt möglicherweise zu unerwarteten Ergebnissen, nicht aber zu einer Fehlermeldung.

Strenge Wertüberprüfung

Für längere Programme bietet es sich deshalb an, die strenge Wertüberprüfung zu aktivieren. Diese Option verlangt, dass jede Variable bei ihrer ersten Verwendung explizit deklariert wird. Die Wertüberprüfung wird zu Beginn eines Programms (meist unmittelbar unter der Shebang) folgendermaßen eingeschaltet:

use strict;

Innerhalb eines normalen Perl-Skripts werden Variablen bei strenger Wertüberprüfung durch ein vorangestelltes my deklariert:

#!/usr/bin/perl
use strict;
my $zahl1;     # explizite Deklaration 
my $zahl2 = 3; # implizite Deklaration bei Wertzuweisung
$zahl3 = 7;    # Fehlermeldung: Nicht deklariert!

Variablenarten

Perl kennt drei verschiedene Arten von Variablen: Skalare, Arrays und Hashes.

gp  Ein Skalar ist eine normale »Einzelvariable«. Ihr Wert ist ein einzelner String, eine Zahl oder eine Referenz auf ein beliebiges Element. Die Namen von Skalaren beginnen mit einem Dollarzeichen, zum Beispiel $wert.
gp  Ein Array ähnelt der gleichnamigen Datenstruktur in C und Java, ist aber erheblich flexibler. Die Anzahl der Elemente im Array kann dynamisch erhöht oder vermindert werden. Der Name der gesamten Array-Variablen beginnt mit dem Zeichen @, beispielsweise @werte.
gp  Ein Hash, auch assoziatives Array genannt, ähnelt einem gewöhnlichen Array. Das Besondere daran ist allerdings, dass die Indizes für die einzelnen Felder keine aufeinander folgenden Integer-Werte sind, sondern beliebige Strings sein können. Der Name eines Hashs beginnt mit % wie etwa %wochentage.

Ein Array kann auf zwei verschiedene Arten erzeugt werden: Entweder weisen Sie dem gesamten Array eine Liste als Wert zu oder Sie erstellen sofort ein einzelnes Element des Arrays:

@sprachen = ("C", "Java", "Perl");  # Liste zuweisen
$betriebssysteme[0] = "Linux";      # Einzelnes Element
$betriebssysteme[1] = "MacOS X";
$betriebssysteme[2] = "MacOS 9";
$betriebssysteme[3] = "Windows";

Da die Elemente von Arrays Skalare sind, ist das Vorzeichen für ein einzelnes Element kein @, sondern ein $.

Listen

Bei der Formulierung ("C", "Java", "Perl") handelt es sich übrigens um eine Liste. Listen können nicht nur in Arrays gespeichert werden, sondern auch ein interessantes Eigenleben führen. Sie können sogar eine Liste skalarer Variablen als LVALUE verwenden! Dies ermöglicht beispielsweise die folgende praktische Schreibweise für den Tausch der Werte zweier Variablen:

($a, $b) = ($b, $a);

In jeder anderen Sprache benötigen Sie für einen solchen Tausch eine dritte Variable als Zwischenspeicher und müssen drei Anweisungen schreiben. In Java sieht die Tauschoperation für zwei int-Variablen zum Beispiel so aus:

int c = a;            // Wert von a retten
a = b;                // a wird überschrieben
b = c;                // b erhält den alten Wert von a
 

Perl definiert darüber hinaus eine Reihe nützlicher Funktionen zur Behandlung von Arrays und Listen. Einige wichtige Beispiele sind folgende:

$w = pop(@array);     # Den letzten Wert des Arrays ab-
                      # trennen und zurückgeben
push (@array, $w);    # Skalar an ein Array anhängen
$w = shift (@array);  # Den ersten Wert des Arrays ab-
                      # trennen und zurückgeben
unshift (@array, $w); # Skalar vor das erste Element
                      # eines Arrays setzen

Mit Hilfe der Funktionen pop, push, shift und unshift können Sie allerdings nicht nur einzelne Elemente von Arrays abtrennen oder ihnen hinzufügen, sondern auch Listen. Beispielsweise hängt die folgende Anweisung eine Liste mit zwei weiteren Programmiersprachen an das weiter oben definierte Array @sprachen an:

push (@sprachen, ("C++", "C#"));

foreach-Schleifen

Interessant ist auch die Fähigkeit von Perl, eine automatische Schleife über alle Elemente eines Arrays zu bilden. Dazu wird die spezielle Kontrollstruktur foreach verwendet. Das folgende Beispiel gibt die Namen dreier in einem Array gespeicherter Prozessoren untereinander aus:

@prozessoren = ("Pentium 4", "Athlon", "PowerPC");
foreach $prozessor(@prozessoren) {
   print "$prozessor\n";
}

Wenn Sie die Angabe der Schleifenzählervariablen (hier $prozessor) weglassen, stellt Perl übrigens automatisch die spezielle Variable $_ dafür zur Verfügung. Diese wird von vielen Funktionen automatisch verwendet, wenn kein anderes Argument angegeben wird. Die obige foreach-Schleife ließe sich also auch so schreiben:

foreach (@prozessoren) {
   print;             # $_ ausgeben
   print "\n";        # der fehlende Zeilenumbruch
}

Sie können ein Array auch zu einem Skalar zusammenfassen und umgekehrt. Die Anweisung split (/Muster/, String) zerlegt den angegebenen String an den Stellen, an denen das Muster (ein regulärer Ausdruck) vorkommt, und konvertiert ihn in ein Array. join (Ausdr, Array) fasst die Elemente des angegebenen Arrays zu einem String zusammen und setzt jeweils den angegebenen Ausdruck dazwischen:

$syslist = "Linux,MacOS X,MacOS 9,Windows";
@systeme = split (/,/, $syslist);
                      # ergibt Array mit Systemnamen
@sprachen = qw(C Java Perl);
$sprachlist = join (", ", @sprachen);
                      # ergibt "C, Java, Perl"

Hashes

Ein Hash kann ebenfalls durch die Definition eines einzelnen Elements eingerichtet werden:

$wtage{'Mo'} = 'Montag';

Auch einzelne Elemente von Hashes sind skalar und beginnen deshalb mit einem $. Der Index eines Hash-Elements wird als Schlüssel (key) bezeichnet. Alternativ können Sie das ganze Hash auf einmal definieren:

%wtage = (Mo => 'Montag', Di => 'Dienstag',
          Mi => 'Mittwoch', Do => 'Donnerstag',
          Fr => 'Freitag', Sa => 'Samstag',
          So => 'Sonntag');

Die spezielle Schreibweise Schlüssel => Wert erlaubt es, die Anführungszeichen um die Schlüsselnamen wegzulassen.

Auch über die Elemente eines Hashs lässt sich eine foreach-Schleife bilden. Dazu wird dem Namen des Hashs das spezielle Schlüsselwort keys vorangestellt. Die oben definierten Wochentage können Sie zum Beispiel so ausgeben:

foreach $key (keys %wtage) {
   print "$key ist die Abkürzung für ${wtage{$key}}\n";
}

Wie Sie sehen, ermöglichen geschweifte Klammern hinter dem $-Zeichen die Auflösung komplexer Variablenkonstrukte innerhalb von Strings.

Referenzen

Ein weiteres interessantes Konstrukt im Zusammenhang mit Variablen ist die Referenz. Sie ist im Wesentlichen mit einem Zeiger in C oder einer Objektreferenz in Java vergleichbar: Referenzen verweisen auf beliebige Variablen, Subroutinen oder sonstige Elemente; eine Referenz wird durch einen \ dargestellt. Beispiele:

$v_ref = \$var;       # Referenz auf ein Skalar
$a_ref = \@array;     # Referenz auf ein Array
$h_ref = \%hash;      # Referenz auf ein Hash

Die umgekehrte Operation heißt Dereferenzierung. Sie wird in Perl durchgeführt, indem Sie dem Namen der Referenz das Zeichen für den Variablentyp voranstellen, auf den die Referenz verweist:

$$v_ref = 3;          # indirekt auf $var zugreifen
@$a_ref.push ("hi");  # indirekt auf @array zugreifen
%$h_ref = (name => 'Klaus', alter => 42);
                      # indirekt auf %hash zugreifen
$$a_ref[0] = "hallo"; # indirekt auf ein Element
                      # von @array zugreifen

Referenzen sind unter anderem als Übergabewerte für Subroutinen nützlich (siehe unten). Eine weitere Möglichkeit, die sie bieten, ist die Konstruktion verschachtelter Arrays und Hashes, für die es keine andere Lösung gibt:

@schmitz = ("Klaus", "Erika", "Michael");
@mueller = ("Heinz", "Gisela", "Claudia");
@familien = (\@schmitz, \@mueller);

Um nun beispielsweise auf das erste Mitglied der zweiten Familie zuzugreifen, können Sie $familien[1][0] schreiben und erhalten "Heinz".

Ausdrücke und Operatoren

Viele der in Perl verfügbaren Literale und Operatoren entsprechen denjenigen von C. Die besondere Flexibilität von Perl ergibt sich jedoch erst aus einer Reihe wichtiger Unterschiede. Einige von ihnen werden hier vorgestellt.

Für numerische Literale gelten dieselben Regeln wie in C. In Perl können Sie allerdings zusätzlich einen Unterstrich als Tausendertrennzeichen einsetzen, um große Zahlen übersichtlicher zu machen:

$milliarde = 1_000_000_000;  # Wert: 1000000000

Die Raute (#) leitet übrigens den einzigen in Perl erlaubten Kommentar ein. Er reicht vom Auftreten dieses Zeichens bis zum Zeilenende.

Besonderheiten bei String-Literalen

Für die Formulierung von String-Literalen bestehen in Perl erheblich mehr Möglichkeiten als in C, ein separates Literal für ein einzelnes Zeichen existiert dagegen nicht. Im einfachsten Fall steht ein String-Literal in einfachen oder in doppelten Anführungszeichen. Während in doppelten Anführungszeichen die bereits angesprochene Variablensubstitution durchgeführt wird, bleiben Strings in einfachen Anführungszeichen stets wörtlich erhalten:

$geld = 100;
print "Ich habe $geld \$.\n"; # Wert: Ich habe 100 $.
print 'Ich habe $geld $\n';   # Wert: Ich habe $geld $\n

In einfachen Ausführungszeichen wird also nicht nur die Variablensubstitution, sondern auch die Ersetzung von Escape-Sequenzen wie \n unterdrückt. Lediglich \' für das einfache Anführungszeichen selbst und \\ für den Backslash werden aufgelöst.

In doppelten Anführungszeichen müssen Sie dagegen eine Reihe spezieller Zeichen als Escape-Sequenz schreiben, wenn Sie diese Zeichen als solche verwenden möchten. Neben den zu erwartenden Fällen \« und \\ betrifft dies auch \$ (das Dollarzeichen), \@ (für ein @) und \%.

Neben den beiden Arten von Anführungszeichen definiert Perl noch weitere Schreibweisen für String-Literale. Diese haben den Vorteil, dass Sie die Zeichen " oder ' – je nachdem – einfach als solche verwenden können:

gp  q/String/ ersetzt die einfachen Anführungszeichen, steht also für 'String'.
gp  qq/String/ wird statt doppelter Anführungszeichen gesetzt, ist also ein Ersatz für "String".
gp  qw/Ausdr1 Ausdr2 Ausdr3/ stellt keinen String dar, sondern ist eine kompakte Schreibweise für eine Liste einzelner Wörter. Die Langschreibweise dieser Liste wäre ('Ausdr1', 'Ausdr2', 'Ausdr3').

Das besonders Interessante an diesen speziellen Quoting-Verfahren ist, dass Sie statt des Slashs (/) auch verschiedene andere Zeichen verwenden können, um den Inhalt abzugrenzen. Sie können sich individuell für Zeichen entscheiden, die im jeweiligen String selbst nicht vorkommen. Gängige Beispiele sind q!String!, q(String) oder q{String}. Entweder werden also zwei gleiche Zeichen wie /.../, !...! oder |...| verwendet oder zwei entgegengesetzte Klammern einer beliebigen Sorte.

String-Vergleichsoperatoren

Was die Operatoren angeht, berücksichtigt Perl das Problem, dass die Inhalte von Variablen als unterschiedliche Datentypen interpretiert werden können, und definiert deshalb zwei Sätze von Vergleichsoperatoren. Die »normalen« Vergleichsoperatoren wie ==, != oder <= sind ausschließlich für numerische Vergleiche vorgesehen. Für String-Vergleiche werden die folgenden separaten Operatoren definiert:

gp  eq (equals) überprüft die Gleichheit zweier String-Werte, ist also immer dann wahr, wenn die beiden Strings identisch sind.
gp  ne (not equals) ist dagegen wahr, wenn die beiden Strings verschieden sind.
gp  lt (less than) ist wahr, wenn der erste String kleiner ist als der zweite, also weiter vorn im Alphabet beziehungsweise im Zeichensatz steht.
gp  gt (greater than) ist wahr, wenn der erste String größer ist als der zweite.
gp  le (less than or equals) ist wahr, wenn der erste String kleiner oder gleich dem zweiten ist.
gp  ge (greater than or equals) ist wahr, wenn der erste String größer oder gleich dem zweiten ist.

Beachten Sie, dass der Vergleich numerischer Werte mit Hilfe der String-Vergleichsoperatoren (wodurch sie natürlich als Strings interpretiert werden) zu anderen Ergebnissen führen kann als der numerische Vergleich derselben Werte. Beispielsweise gilt natürlich 21 < 111. Da das Zeichen »2« aber im Zeichensatz erst nach der »1« kommt, ist die Beziehung "21" lt "111" dagegen falsch.

Perl verwendet einen anderen Operator für die Verkettung von Strings als Java, nämlich den Punkt (.). Dies erspart Ihnen die Verwirrung, die durch die Verwendung von + in Java entstehen kann. Dank der Variablensubstitution wird der Operator in der Praxis aber ohnehin selten benötigt.

HIER-Dokumente

Genau wie die im vorigen Kapitel vorgestellten UNIX-Shells unterstützt Perl die Verwendung von HIER-Dokumenten. Dies ist nützlich, um größere Mengen Text auszugeben oder einer Variablen zuzuweisen:

print << "ENDE";
Perl
macht
Spaß!
ENDE
 
$zeilen = << "SCHLUSS";
Perl-Programmierung
macht Freude.
SCHLUSS

Beachten Sie, dass die Schluss-Markierung in einer eigenen Zeile stehen muss, und zwar ganz am Anfang dieser Zeile. Wenn sie die letzte Zeile im Skript bildet, müssen Sie daran denken, dahinter (Enter) zu drücken, weil es sich sonst nicht um eine vollständige Zeile handelt.

Wenn die Schluss-Markierung in doppelten Anführungszeichen steht, wie in den beiden Beispielen, wird innerhalb des Textes übrigens Variablensubstitution durchgeführt.

Eine weitere interessante Besonderheit von Perl besteht darin, dass Sie logische Operatoren nicht nur für Ausdrücke verwenden können, sondern auch zur logischen Verknüpfung von Anweisungen. Bei der Verknüpfung zweier Anweisungen mittels || (oder dem Synonym or) wird die zweite Anweisung nur dann ausgeführt, wenn die erste fehlschlägt. Dies liegt an der Short-Circuit-Logik der logischen Operatoren: Wie die meisten Programmiersprachen hört Perl mit der Auswertung eines logischen Operators auf, sobald das Ergebnis feststeht. Bei einer Oder-Verknüpfung steht das Ergebnis »wahr« fest, wenn der erste Ausdruck wahr ist. Dies ist bei einer erfolgreich ausgeführten Anweisung der Fall. Bekannt ist beispielsweise die folgende Formulierung zum Öffnen einer Datei:

open (FILE, "<datei.txt") or die "Kann nicht öffnen!\n";

Dies lässt sich in der Tat mit »Öffne die Datei oder stirb!« beschreiben – die Anweisung die bricht die Ausführung eines Skripts mit einer Fehlermeldung ab.

Umgekehrt wird die zweite Anweisung bei einer &&- beziehungsweise and-Verknüpfung nur dann ausgeführt, wenn die erste Erfolg hatte – andernfalls steht das Gesamtergebnis »falsch« bereits fest.

Besonderheiten bei Kontrollstrukturen

Im Großen und Ganzen funktionieren die Kontrollstrukturen in Perl genau wie in C oder Java. Allerdings existiert in Perl kein switch/case; die zusätzliche Schleifenanweisung foreach wurde dagegen bereits behandelt.

Die wichtigste Besonderheit besteht darin, dass die geschweiften Klammern bei if, while etc. auch dann erforderlich sind, wenn nur eine Anweisung von der Kontrollstruktur abhängen soll. Außerdem wird ein verschachteltes »else if« in Perl durch das spezielle Schlüsselwort elsif ausgedrückt.

Eine Alternative für ein if, von dem nur eine Anweisung abhängt und das kein else besitzt, ist das nachgestellte if:

print "\$a ist 0!\n" if !$a;

ist ein Synonym für folgende Fallentscheidung:

if (!$a) {
   print "\$a ist 0!\n";
}

Eine weitere Perl-Spezialität ist die zusätzliche Kontrollstruktur unless, die das Gegenteil von if darstellt und ebenfalls vor- oder nachgestellt sein kann. Die abhängigen Anweisungen werden genau dann ausgeführt, wenn die Bedingung nicht zutrifft:

die "\$b existiert nicht!\n" unless defined $b;

Die Funktion defined überprüft, ob die angegebene Variable existiert.

Subroutinen

Anstelle von Funktionen können Sie in Perl so genannte Subroutinen definieren. Sie werden durch das Schlüsselwort sub eingeleitet und durch ihren Namen aufgerufen. Das folgende einfache Beispiel zeigt, wie eine Subroutine definiert und aufgerufen wird:

tuwas;                # Subroutine tuwas aufrufen
...
sub tuwas
{
   print "Hi! Ich tue etwas: Text ausgeben.\n";
}

Es ist vollkommen egal, an welcher Stelle Sie Subroutinen in einem Perl-Skript definieren. Allerdings ist es üblich, sie am Ende des Skripts unter dem globalen Code unterzubringen.

Subroutinen können Argumente entgegennehmen. Sämtliche übergebenen Werte befinden sich in dem speziellen Array @_, dessen einzelne Elemente Sie sinnvollerweise mittels shift abtrennen sollten, weil Sie sie dadurch in der richtigen Reihenfolge einlesen können. Dazu genügt sogar die Angabe von shift ohne Argument, weil diese Funktion in diesem Fall automatisch auf @_ zugreift. Das folgende Beispiel definiert eine Subroutine namens print_summe, die zwei übergebene Werte zusammenaddiert und ausgibt:

sub print_summe
{
   $w1 = shift;
   $w2 = shift;
   $summe = $w1 + $w2;
   print "Summe: $summe\n";
}

Diese Subroutine können Sie beispielsweise folgendermaßen aufrufen:

print_summe (3, 7);

Die folgende Subroutine erhöht jedes Element eines als Referenz übergebenen Arrays um 1:

sub list_inc
{
   $listref = shift;
   foreach (@$listref) {
      $_++;
    }
}

Ein Aufruf dieser Subroutine sieht etwa so aus:

@list = qw(2 4 6 8 10);
list_inc (\@list);    # @list ist nun (3, 5, 7, 9, 11)

Eine Subroutine kann übrigens auch Werte zurückgeben. Dazu wird wie in C und Java die Anweisung return verwendet.

Mit Dateien arbeiten

Perl besitzt eine besonders einfache Syntax für das Lesen und Schreiben von Dateien. Dies ist eine der wichtigsten Eigenschaften der Sprache für Systemadministratoren, die Perl gern als mächtigen Ersatz für Shell-Skripte verwenden.

Um eine Datei zu öffnen, wird die folgende Syntax verwendet:

open (DATEIHANDLE, "...Pfad");

Statt ... steht vor dem Pfad die Angabe des Zugriffsmodus: < öffnet die Datei zum Lesen, > zum Schreiben (wobei eine existierende Datei dieses Namens verloren geht) oder >> zum Anhängen.

Dateihandles

Das DATEIHANDLE ist ein Bezeichner, über den Sie auf die Datei zugreifen können. Im Gegensatz zu Variablen besitzt es kein einleitendes Zeichen und wird üblicherweise vollständig in Großbuchstaben geschrieben.

Das folgende Beispiel versucht, die Datei test.txt im aktuellen Verzeichnis zum Lesen zu öffnen, liest eine Zeile daraus und gibt diese aus. Anschließend wird die Datei mittels close geschlossen:

open (FILE, "<test.txt")      or die "Kann test.txt nicht öffnen!";
$line = <FILE>;
chomp $line;
print "Gelesen: $line\n";
close FILE;

Wenn Sie alle Zeilen aus der Datei lesen möchten, bietet sich die folgende Kurzfassung an:

while ($line = <FILE>) {
   chomp $line;
   print "Gelesen: $line\n";
}

Die Bedingung bleibt dabei automatisch wahr, solange das Dateiende noch nicht erreicht ist.

Wenn Sie eine Datei zum Schreiben (oder Anhängen) öffnen, können Sie folgendermaßen eine Zeile Text hineinschreiben:

open (FILE, ">test.txt")
     or die "Kann test.txt nicht öffnen!";
print FILE "Eine Zeile Text.\n";
close FILE;

Es ist wichtig, dass zwischen dem Namen des Dateihandles und dem Text, den print ausgeben soll, kein Komma, sondern nur ein Leerzeichen stehen darf!

Auf ähnlich einfache Weise können Sie übrigens Verzeichnisinhalte lesen. Das folgende Beispiel gibt die Namen sämtlicher Dateien des aktuellen Verzeichnisses (repräsentiert durch ".") aus:

opendir (DIR, ".");
while ($filename = readdir DIR) {
   print "$filename\n";
}
closedir DIR;

Reguläre Ausdrücke

Eine der wichtigsten Fähigkeiten von Perl ist der Umgang mit regulären Ausdrücken. Es werden erheblich mehr Optionen angeboten als bei dem UNIX-Programm grep. Reguläre Ausdrücke werden in Kapitel 6, Konzepte der Programmierung, näher vorgestellt, deshalb sollen an dieser Stelle zwei kurze Beispiele genügen.

Um ein Muster in einem String zu finden, wird der Operator =~ verwendet:

print "Perl gefunden!" if $text =~ /perl/i;

Dies gibt »Perl gefunden!« aus, wenn in der Variablen $text die Zeichenfolge »perl« vorkommt, und zwar ohne Berücksichtigung von Groß- und Kleinschreibung (Modifikator /i).

Das folgende Beispiel ersetzt in der Variablen $text jedes Vorkommen von »Java« durch »Perl«:

$text =~ s/Java/Perl/g;

Der Operator s/// (substitute) ersetzt den gefundenen regulären Ausdruck durch den angegebenen String. Der Modifikator /g steht für »global« (sämtliche Vorkommen ersetzen).

  

Einstieg in PHP 5

Einstieg in Java

C von A bis Z

Einstieg in C++

Einstieg in Linux

Einstieg in XML

Apache 2




Copyright © Galileo Press GmbH 2004
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de