Woche 2

# Tag 13

# Gültigkeitsbereiche , Module und das Importieren von Code

In der heutigen Lektion kommen wir auf die Themen Raum und Zeit zu sprechen - eine Ergänzung unserer früheren Diskussionen von Wahrheit und Gier. Mit Raum beziehe ich mich auf die sogenannten Namensbereiche von Variablen: Sie erfahren, wie Variablennamen über lokale und globale Gültigkeitsbereiche hinweg verwaltet werden und wie man mit Paketen globale Variablen programmübergreifend verwalten kann. Verbunden mit dem Thema Raum ist die Fähigkeit, Code von anderen Modulen entweder zur Kompilier- oder zur Laufzeit in Ihr Skript zu importieren - womit wir beim Thema Zeit wären. Heute erfahren wir,

- warum globale Variablen Probleme verursachen können und wie sich diese Variablen kontrollieren lassen,
- mehr über lokale Variablen: mehr als nur `my` und Subroutinen,
- wie man externen Code importiert und verwendet und
- wie man Module der Standardbibliothek und von CPAN verwendet.

## Globale Variablen und Pakete

Der Gültigkeitsbereich einer Variablen bezieht sich, allgemein ausgedrückt, auf die Verfügbarkeit und die Existenz einer Variablen in Ihrem Skript. Von einem globalen Gültigkeitsbereich spricht man, wenn eine Variable in allen Teile eines Skripts verfügbar ist und so lange existiert, wie das Skript ausgeführt wird. Von einem lokalen Gültigkeitsbereich spricht man hingegen, wenn eine Variable nur begrenzt gültig ist und, je nachdem welcher Teil Ihres Perl-Skripts gerade ausgeführt wird, existiert oder nicht.

Wir beginnen dieses Kapitel mit einem Überblick über globale Variablen und den globalen Gültigkeitsbereich. Anschließend widmen wir uns dem lokalen Gültigkeitsbereich.

### Globale Variablen und ihre Probleme

Das ganze Buch hindurch haben wir in den meisten Beispielen globale Variablen und deren globalen Gültigkeitsbereich verwendet - mit Ausnahme von gelegentlichen lokalen Variablen in Subroutinen. Und dafür gibt es auch einen guten Grund: Globale Variablen lassen sich leicht erstellen und verwenden. Jede Variable, die nicht explizit mit `my` (oder, wie Sie bald lernen werden, mit `local`) deklariert wurde, ist automatisch eine globale Variable. Unabhängig vom Kontext, in dem Sie verwendet wurde, steht sie zu jedem Zeitpunkt in Ihrem Skript zur Verfügung.

So lassen sich schnell einfache Skripts schreiben. Doch im gleichen Zuge, in dem Ihre Skripts an Umfang zunehmen, wird die Verwendung von globalen Variablen immer problematischer. Es gibt mehr Variablen, die überwacht werden müssen, und mehr Variablen, die Platz belegen. Globale Variablen, die auf unerfindliche Weise mitten in einem Skript auftauchen, sind teilweise schwer zu debuggen - und es stellt sich die Frage, wann diese Variable aktualisiert wird und von welchem Teil des Skripts? Wissen Sie überhaupt noch, wozu diese globale Variable eingesetzt wurde?

Bei der Erstellung größerer Skripts unter Verwendung von globalen Variablen besteht darüber hinaus die nicht unerhebliche Gefahr, dass Sie zufällig einen Variablennamen vergeben, der bereits irgendwo in Ihrem Skript verwendet wurde. Dieses Problem erschwert nicht nur das Debuggen Ihres Skripts, es wirkt sich auch nachteilig aus, wenn Sie Ihre Skripts in den Code von anderen Programmentwicklern integrieren oder wiederverwendbare Perl-Bibliotheken erzeugen wollen. Damit wird das Risiko gleichlautender Variablennamen in mehreren Codeteilen zu einem sehr realen und nur schwer zu lösenden Problem.

Die beste Möglichkeit, Namenskonflikte durch globale Variablen zu umgehen, besteht darin, auf globale Variablen zu verzichten. Organisieren Sie Ihre Skripts in Subroutinen, und deklarieren Sie Ihre Variablen als lokal zu diesen Subroutinen. Daten, die von mehreren Subroutinen benötigt werden, können mit Hilfe von Argumenten von Subroutine an Subroutine weitergereicht werden. Viele Software- Entwickler sind der Meinung, dass alle Programme - wie klein und spezialisiert sie auch sein mögen - nach diesem Prinzip geschrieben werden sollten, denn das Vermeiden von globalen Variablen entspräche professionellem Software-Design.

In der Realität hingegen benutzt jeder hin und wieder globale Variablen. Besonders in Situationen, in denen jeder Teil des Skripts auf die gleichen gespeicherten Daten einer Liste oder einer anderen Struktur zugreifen muss. Damit kommen wir zu einer weiteren Möglichkeit, globale Variablen zu organisieren und zu verwalten: den Paketen.

### Was ist ein Paket?

Ein Paket ist eine Möglichkeit, Ihre globalen Variablen so zusammenzufassen, dass sie im eigentlichen Sinne nicht länger global sind. Mit anderen Worten, jedes Paket definiert seinen eigenen Namensbereich. Mit Paketen können Sie steuern, welche globalen Variablen anderen Paketen verfügbar sein sollen und welche nicht. Damit lassen sich die Probleme mit gleichlautenden Variablennamen über verschiedene Codeteilen hinweg vermeiden.

Die Chancen stehen nicht schlecht, dass Sie Ihre eigenen Pakete nur entwickeln müssen, wenn Sie Perl-Module, Bibliotheken oder Klassen in objektorientierter Perl- Programmierung erstellen - alles Themen, die weit über den Rahmen dieses Buches hinausgehen. Doch auch, wenn Sie keine eigenen Pakete entwickeln, sind Pakete überall präsent, wo Perl-Skripts geschrieben oder ausgeführt werden, auch wenn Sie es nicht merken. Mit minimalen Kenntnissen der Funktionsweise von Paketen im Hinterkopf wird es Ihnen nicht nur leichterfallen, zu verstehen, wie Perl Variablen und Namensbereiche in Ihren Skripts handhabt, sondern auch wie Code aus Modulen importiert wird. Außerdem wird Ihnen dieses Wissen zugute kommen, wenn Sie soweit sind, dass Sie Ihren Code in Bibliotheken oder Module umwandeln wollen. Machen Sie sich so früh wie möglich mit den zugrundeliegenden Regeln vertraut, dann haben Sie es später um so leichter.

### Wie Pakete und Variablen zusammenarbeiten

Der Gedanke, der den Paketen zugrunde liegt, besteht darin, dass jede Zeile in Perl in der Umgebung des aktuellen Pakets kompiliert wird - wobei es sich bei dem Paket um das Standardpaket oder ein selbst definiertes Paket handeln kann. Jedes Paket kommt mit einem Satz an Variablennamen (auch Symboltabelle genannt), der bestimmt, ob eine Variable für Perl verfügbar ist und wie der aktuelle Wert der Variablen lautet. Die Symboltabelle enthält alle Namen, die Sie möglicherweise in Ihrem Skript verwenden - Skalare, Arrays, Hashes und Subroutinen.

Wenn Sie in Ihrem Skript auf einen Variablennamen Bezug nehmen (zum Beispiel `$x`), wird Perl versuchen, diese Variable in der Symboltabelle des aktuellen Pakets zu finden. Wenn Sie Perl anweisen, das Paket zu wechseln, wird `$x` in dem neuen Paket gesucht. Sie können Variablen aber auch über ihre kompletten Paketnamen ansprechen. Damit teilen Sie Perl mit, in welcher Symboltabelle sich die Variable befindet und wie ihr Wert lautet. Paketnamen bestehen aus dem Namen des Pakets, zwei Doppelpunkten und dem Namen der Variablen. Das Sonderzeichen, das anzeigt, ob die Variable ein Skalar, eine Liste, ein Hash etc. ist, steht noch vor dem Paket.

So würden Sie sich zum Beispiel mit `$main::x` auf eine Skalarvariable `$x` beziehen, die in dem Paket `main` gespeichert ist. `$x` ohne weitere Angaben würde die Skalarvariable `$x` in dem aktuellen Paket bezeichnen. Beide Variablen tragen den gleichen Namen, aber da sie in verschiedenen Paketen existieren, haben deren Werte nichts miteinander zu tun (und existieren in anderen Paketen überhaupt nicht).

Das von Ihnen bisher verwendete Standardpaket lautet `main`, wasIhnen vielleicht bisher verborgen geblieben ist. Wenn Sie globale Variablen in Skripts erzeugen und verwenden, die nicht explizit ein eigenes Paket definieren, werden diese Variablen tatsächlich in dem Paket `main` erzeugt (vielleicht ist Ihnen dies bereits in den Fehlermeldungen aufgefallen - in einigen heißt es `Name` `main::foo used only once...`). Die ganze Zeit, wenn ich also von globalen Variablen gesprochen habe, war ich nicht ganz korrekt: Globale Variablen sind streng genommen Variablen des Pakets `main`.

Beachten Sie, dass die Verteilung von globalen Variablen auf Pakete deren Verwaltung nicht unbedingt vereinfacht, wenn Sie sehr viele davon verwenden. Hundert globale Variablen in `main` sind genauso schwierig zu verwalten wie hundert globale Variablen in einem neuen Paket namens `meinPaket`. Die Verwendung lokaler Variablen und das Übergeben von Daten zwischen einzelnen Subroutinen bleibt auch weiterhin die beste Empfehlung für Ihre eigene kleine Perl-Welt.

Für die Erzeugung eines neuen Pakets oder zum Wechseln zwischen Paketen gibt es die Funktion `package`:

    package meinpaket;    #  definiert oder wechselt zu einem Paket, das nicht
                          # main lautet

Der Gültigkeitsbereich von Paketdefinitionen entspricht in etwa dem von lokalen Variablen: Paketdefinitionen innerhalb einer Subroutine oder eines Blocks kompilieren den ganzen Code innerhalb dieser Subroutine oder dieses Blocks als Teil des neuen Pakets und kehren dann zu dem umschließenden Paket zurück. Durch den Aufruf von `package` zu Beginn eines Skripts definieren Sie ein neues Paket für den gesamten Block.

Wie ich bereits vorher erwähnt habe, definieren Sie eigene Pakete vornehmlich dann, wenn Sie Code für eigene Bibliotheken oder Module aufsetzen. Einige Punkte in Bezug auf Pakete sollten Sie sich merken:

- Jeder Variablenname und -wert wird für das aktuelle Paket in einer Symboltabelle gespeichert.
- Sie können auf einen Variablennamen Bezug nehmen, indem Sie entweder nur den Variablennamen (für das aktuelle Paket) oder den Variablennamen mit dem vorangestellten Paketnamen angeben. Damit legen Sie fest, welche Symboltabelle Perl nach dem Wert der Variablen überprüft.
- Das Standard-Paket lautet `main`.

### Globale Variablen, die keinem Paket angehören

Ein Möglichkeit, globale Variablen zu erzeugen, die keine Namenskonflikte provozieren, besteht darin, Pakete zu erzeugen. Es gibt jedoch noch einen anderen sehr geläufigen Trick, mit dem man globale Variablen erzeugen kann: Man deklariert die globalen Variablen als lokal zu ihrem eigenen Skript.

Wenn Sie Ihre globalen Variablen mit dem Modifizierer `my` deklarieren, wie es bei lokalen Variablen innerhalb von Subroutinen der Fall ist, dann gehören diese globalen Variablen keinem Paket an, nicht einmal `main`. Dennoch sind sie in Ihrem Skript immer noch global und für alle Teile des Skripts verfügbar (einschließlich der Subroutinen). Es treten jedoch keine Namenskonflikte mit anderen Variablen aus Paketen auf, auch nicht für die Variablen aus dem Paket `main`. Globale Variablen, die mit `my` deklariert wurden, haben auch leistungsmäßig einen Vorteil, denn Perl muss nicht bei jeder Referenzierung dieser Variablen auf die dazugehörige Symboltabelle zugreifen.

Aufgrund der Vorteile von globalen Variablen, die außerhalb von Paketen deklariert wurden, wird in der Perl-Programmierung empfohlen, möglichst in allen, außer vielleicht den einfachsten Perl-Skripts, diese Art von Variablen zu verwenden. Dazu müssen Sie in Ihren eigenen Skripts lediglich bei der Deklaration der globalen Variablen (genau wie bei den lokalen Variablen) den Modifizierer `my` mit angeben:

    my %namen = (); # globales Hash für Namen

Perl verfügt außerdem über einen besonderen Mechanismus, der dafür sorgt, dass Sie all Ihre Variablen ordnungsgemäß verwenden - seien es lokale Variablen innerhalb von Subroutinen oder globale Variablen, die nicht in einem Paket definiert wurden. Nehmen Sie als oberste Zeile Ihres Skripts »`use strict`;« mit auf, um diesen Mechanismus einzuschalten:

    #!/usr/bin/perl -w
    use strict;

    my $x = '';  # OK
    @foo = ();   # bricht Ausführung des Skripts ab

    # Rest Ihres Skripts

Wenn Sie `use strict` verwenden, wird Perl bei der Ausführung Ihres Skripts eine Fehlermeldung ausgeben, wenn es auf nicht zuzuordnende globale Variablen trifft, und das Programm abbrechen. Tatsächlich wird `use strict` bei allen Variablen, die nicht mit `my` deklariert, ohne Paketnamen referenziert oder von irgendwoher importiert wurden, eine Fehlermeldung ausgeben. Betrachten Sie `use strict` als einen noch strengeren Auslöser von Variablenwarnungen als `-w`.

Es gibt jedoch einen seltsamen Nebeneffekt des Befehls `use strict`: Er moniert auch die Platzhaltervariable in einer `foreach`-Schleife, so zum Beispiel `$key` in folgendem Beispiel:

    foreach $key (keys %namen) {
      ...
    }

Der Grund dafür liegt darin, dass die implizit lokale `foreach`-Variable im Grunde genommen eine globale Variable ist, die vorgibt, lokal zu sein. Sie ist zwar nur in der `foreach`-Schleife verfügbar und verhält sich somit wie eine lokale Variable, aber intern wird sie anders deklariert (die zwei Möglichkeiten, lokale Variablen zu deklarieren, beschreibe ich weiter hinten in diesem Kapitel im Abschnitt »Lokale Variablen mit `my` und `local`«.) Um Fehlermeldungen von `use strict` zu vermeiden, müssen Sie ein »`my`« vor den Variablennamen setzen:

    foreach my $key (keys %namen) {
      ...
    }

Im weiteren Verlauf dieses Buches wird in allen Beispielen der Befehl `use strict` verwendet, und globale Variablen werden als `my`-Variablen deklariert.

## Lokaler Gültigkeitsbereich und Variablen

Eine lokale Variable steht, wie Sie bereits in Kapitel 11, »Subroutinen erstellen und verwenden«, erfahren haben, nur einem bestimmten Teil des Skripts zur Verfügung. Nachdem die Ausführung dieses Teils des Skripts abgeschlossen ist, hört die Variable auf zu existieren. Darüber hinaus sind lokale Variablen nur beschränkt für andere Teile des Skripts verfügbar. So können sie privat zu dem Gültigkeitsbereich sein, in dem sie definiert wurden, oder nur für die Teile des Skripts zur Verfügung stehen, die zeitgleich mit dem Teil des Skripts ausgeführt werden, in dem die Variable definiert wurde.

### Lokale Variablen und lokaler Gültigkeitsbereich

In Kapitel 11 haben wir mit `my` definierte lokale Variablen innerhalb von Subroutinen betrachtet. Eine Subroutine definiert einen lokalen Gültigkeitsbereich. Die lokale Variable steht dann dem ganzen Code, der innerhalb dieser Subroutine definiert wurde, zur Verfügung.

Eine Subroutine ist jedoch nicht der einzige Ort, in dem ein lokaler Gültigkeitsbereich erzeugt werden kann. Jeder Block, der von geschweiften Klammern eingeschlossen ist, definiert einen lokalen Gültigkeitsbereich, und jede Variable, die in diesem Block definiert wurde, verliert nach diesem Block ihren Gültigkeitsbereich. Damit ist es möglich, lokale Variablen innerhalb von Schleifen oder Bedingungen und sogar innerhalb von freien Blöcken zu definieren, wenn es dort Codeteile gibt, die von einem neuen lokalen Gültigkeitsbereich profitieren.

Die folgenden Codefragmente definieren alle einen lokalen Gültigkeitsbereich. Jede Deklaration der Variablen `$s` erfolgt lokal zum einschließenden Block, und jedes `$x` unterscheidet sich von allen anderen Versionen von `$x`. Beachten Sie vor allem die Verwendung der lokalen Variablen in der `foreach`-Schleife. Dort ist die Variable lokal zur gesamten Schleife und nicht zu jeder Iteration. `$x` wird wie erwartet fünfmal inkrementiert:

    if ($foo) {      # Bedingung
        my $x = 0;
        print "X in der Bedingung: $x\n";
        $x++;
    }

    foreach (1..5) {  # Schleife
        my $x += $_;
        print "X in der Schleife: $x\n";
    }

    {                # freier Block
        my $x = 0;
        print "X im freien Block: $x\n";
        $x++;
    }

Es gibt noch eine weitere Regel im Zusammenhang mit Variablen und Gültigkeitsbereich, die Sie sich merken sollten: Lokale Variablen, die den gleichen Namen wie globale Variablen tragen, verbergen die Werte der gleichlautenden globalen Variable. Den ganzen lokalen Gültigkeitsbereich hindurch gilt der Wert der lokalen Variablen, und mit dem Verlassen des lokalen Gültigkeitsbereichs treten die ursprüngliche globale Variable und ihr Wert wieder in Kraft.

Diese Eigenheit ist einerseits sehr bequem, kann andererseits aber auch sehr verwirrend sein. Im allgemeinen wird empfohlen, gleiche Namen für lokale und globale Variablen zu vermeiden, es sei denn, es bestehen plausible Gründe dafür.

Bei Bedarf können Sie jedoch durch Angabe des kompletten Paketnamens jederzeit auf die globale Variable Bezug nehmen, auch innerhalb eines lokalen Gültigkeitsbereichs. Voraussetzung ist allerdings, dass Sie weder `use strict` verwendet noch Ihre globalen Variablen mit `my` deklariert haben:

    $foo = 0;  # global
    {
       my $foo = 1;        # lokal
       print "$foo\n";     # gibt 1 aus
       print "$main::foo\n";  # gibt 0 aus
    }
    print "$foo\n";        # gibt 0 aus

### Lokale Variablen mit my und local

Lokale Variablen können nicht nur mit `my`, sondern auch mit `local` definiert werden. Der Modifizierer `local` wird auf die gleiche Weise wie der Modifizierer `my` verwendet und kann eine oder mehrere Variablen einschließen:

    local ($x, $y);

Da stellt sich die Frage nach dem Unterschied. Der auffälligste Unterschied zwischen diesen beiden Arten von lokalen Variablen ist der, dass der Gültigkeitsbereich für lokale Variablen, die mit `local` definiert wurden, durch die Ausführung des Skripts festgelegt wird und nicht durch die Anordnung des Codes. Eine `my`-Variable ist nur bis zum nächsten umschließenden Block oder zur nächsten Subroutinendefinition gültig. Wenn Sie von Ihrer Subroutine aus eine neue Subroutine aufrufen, hat die zweite Subroutine keinen Zugriff auf die Variablen der ersten Subroutine. Lokale Variablen, die mit `local` deklariert wurden, sind innerhalb des aktuellen Blocks oder der aktuellen Subroutine sowie für alle darin enthaltenen Subroutinen gültig.

> Technisch betrachtet haben `my`-Variablen einen lexikalischen und `local`-Variablen einen dynamischen Gültigkeitsbereich. Diese Begriffe müssen Sie nicht lernen, es sei denn Sie sind ein Informatiker oder wollen anderen Informatikern imponieren.

Ein Beispiel zu den unterschiedlichen Gültigkeitsbereichen von `my`- und `local`- Variablen finden Sie im Abschnitt »Vertiefung« - für den Fall, dass Sie die Unterschiede zwischen `local` und `my` genauer untersuchen wollen. Am besten fahren Sie jedoch damit, Ihre lokalen Variablen mit `my` und nicht mit `local` zu deklarieren, da `my`-Variablen sich enger an die Definition eines lokalen Gültigkeitsbereichs, wie er in anderen Programmiersprachen verwendet wird, anlehnen und leichter zu verwenden und zu verwalten sind.

## Perl-Module verwenden

Erfolgreich ein Perl-Skript zu schreiben, besteht zur einen Hälfte darin, bewußt Code aufzusetzen, und zur anderen Hälfte darin, bewußt Code nicht aufzusetzen. Genauer gesagt, sollten Sie wissen, wann Sie von den vorgegebenen Perl-Funktionen Gebrauch machen oder die Bibliotheken und Module anderer Programmierer nutzen sollten, um sich die Programmierung leichter zu machen.

Wenn Sie in Perl eine Aufgabe zu bewältigen haben, die ziemlich komplex scheint, aber unter Umständen bereits von anderen Programmierern zu früheren Zeiten in Angriff genommen wurde, stehen die Chancen recht gut, dass Ihnen bereits jemand die Arbeit abgenommen hat. Und in guter Perl-Manier könnte dieser Jemand seinen Code verpackt in einem Modul oder einer Bibliothek zum Herunterladen im Internet zur Verfügung gestellt haben. Handelt es sich um eine häufig zu erledigende Aufgabe von allgemeinem Interessse, so könnte das passende Modul sogar Teil der ausgelieferten Standardversion von Perl sein. Die meiste Zeit werden Sie wahrscheinlich damit verbringen, sich diese Bibliotheken zunutze zu machen, indem Sie sie in Ihre Perl-Skripts importieren und einige Codezeilen hinzufügen, um so den importierten Code Ihrer speziellen Situation anzupassen. Und das war's dann auch schon.

In etlichen der folgenden Kapitel dieses Buches werden wir einer Reihe von Modulen begegnen, die Ihnen als Teil der Standardversion von Perl, als Teil der Version für Ihre spezifische Plattform oder als herunterladbare Datei des Comprehensive Perl Archive Network (CPAN) zur Verfügung stehen. In diesem Abschnitt lernen Sie deshalb die Grundlagen zur Nutzung dieser Module kennen: Sie erfahren, was ein Modul ist, wie man es importiert und wie man es in eigenen Skripts verwendet.

### Zur Terminologie

Zuerst möchte ich einige Begriffe klären. Ich habe mit den Begriffen Funktion, Bibliothek, Modul und Paket um mich geworfen, und deshalb ist es notwendig, genau zu klären, was damit jeweils gemeint ist.

Eine vordefinierte Funktion ist, wie ich bereits erwähnt habe, eine Funktion, die mit Perl ausgeliefert wird und Ihnen zum Einbauen in Ihre Skripts zur Verfügung steht. Sie brauchen keine speziellen Schritte auszuführen, um eine vordefinierte Funktion aufzurufen.

Eine Perl-Bibliothek ist eine Sammlung von Perl-Code, die in anderen Skripts wiederverwertet werden kann. Dies ist die Beschreibung von früheren Perl- Bibliotheken, die mittels des Operators `require` in andere Perl-Skripts importiert werden. In jüngster Zeit wird der Begriff »Bibliothek« immer häufiger gleichgesetzt mit einem Perl-Modul, was dazu führt, dass die bisherigen Bibliotheken und ihr Operator `require` veraltet sind. Das Importieren von Code mit `require` werde ich in einem der hinteren Abschnitte dieses Kapitels noch eingehender beschreiben.

Ein Perl-Modul ist eine Sammlung von wiederverwendbarem Perl-Code. Perl-Module definieren ihre eigenen Pakete, wobei jedes Paket seinen eigenen Satz an Variablen definiert. Sie nutzen die Module, indem Sie sie mit dem `use`-Operator in Ihre Skripts importieren. Anschließend können Sie (normalerweise) die Subroutinen (und manchmal auch die Variablen) in diesem Modul wie alle anderen beliebigen Subroutinen (oder Variablen) referenzieren. Manche Module sind objektorientiert programmiert. Als Folge werden sie etwas anders behandelt, die grundlegende Vorgehensweise ist jedoch die gleiche.

Zusätzlich gibt es noch die Pragmas. Dabei handelt es sich um eine besondere Art von Perl-Modulen, die darauf Einfluß nehmen, wie Perl ein Skript kompiliert und ausführt (die meisten normalen Perl-Module haben nur Einfluß auf die eigentliche Ausführung). Ansonsten verhalten sich beide gleich. `use strict` ist ein Beispiel für die Verwendung eines Pragmas. Auf Pragmas werde ich noch weiter hinten in diesem Kapitel eingehen.

### Wo findet man passende Module?

Wo aber befinden sich diese Module? Wenn Sie über Perl verfügen, sind Sie bereits im Besitz einer Reihe von Modulen, mit denen Sie experimentieren können, ohne weitere Schritte unternehmen zu müssen. Die Standard-Perl-Bibliothek (standard Perl library) ist eine Sammlung von Modulen, Pragmas und Skripts, die mit der Standardversion von Perl ausgeliefert wird. Verschiedene Versionen von Perl für unterschiedliche Plattformen können unterschiedliche Standardbibliotheken aufweisen - so hat die Windows-Version von Perl einige Module, um auf Windows-spezifische Fähigkeiten zuzugreifen. Diese Module müssen Sie zu ihrer Verwendung lediglich importieren, und es entfällt die Notwendigkeit, sie herunterzuladen oder zu installieren.

Der »offizielle« Satz an Bibliothekmodulen ist in der Hilfsdokumentation perlmod vollständig beschrieben und umfaßt Module zu folgenden Themen:

- Schnittstellen zu Datenbanken
- Einfache Netzwerke
- Spracherweiterungen, modul- und plattformspezifische Unterstützung zur Software-Entwicklung, dynamisches Laden von Modulen und Funktionen
- Textverarbeitung
- Objektorientierte Programmierung
- Höhere Mathematik
- Programmieren mit Dateien, Verzeichnissen und Befehlszeilenargumenten
- Fehlerbehandlung
- Datum und Uhrzeit
- Lokale (zur Erstellung internationaler Skripts)

In Anhang B, »Überblick über die Perl-Module«, finden Sie darüber hinaus weitere Informationen zu vielen der Module in der Standardbibliothek.

Zur Windows-Version von Perl gehören die Standard-Win32-Module für Windows- Erweiterungen. Zu diesen gehören unter anderem:

- `Win32::Process`: Erzeugung und Einsatz von Windows-Prozessen
- `Win32::OLE`: Für OLE-Automation
- `Win32::Registry`: Zugriff auf die Windows-Registrierdatenbank
- `Win32::Service`: Verwaltung der Windows-NT-Dienste
- `Win32::NetAdmin`: Einrichten von Benutzern und Gruppen im Netz

MacPerl umfaßt `Mac`-Module für den Zugriff auf die Mac-Toolbox, einschließlich AppleEvents, Dialoge, Dateien, Schriftarten, Videos, Internet-Konfigurationen, QuickDraw und Spracherkennung (wow!). Einige der `Mac`- und `Win32`-Module werde ich Ihnen in Kapitel 18, »Perl und das Betriebssystem«, vorstellen.

Zusätzlich zu der Standard-Perl-Bibliothek gibt es noch das Comprehensive Perl Archive Network, auch als CPAN bekannt. CPAN ist eine Sammlung von Perl- Modulen, Skripts, Dokumentationen und anderen Werkzeugen zu Perl. Perl- Programmierer in der ganzen Welt schreiben Module und schicken sie dann an das CPAN. Um die Module von CPAN zu nutzen, müssen Sie sie herunterladen und in Ihre Perl-Version installieren. Manchmal müssen diese Module auch mit einem C- Compiler kompiliert werden. Ich möchte diesen Abschnitt mit den Modulen beginnen, die bereits installiert vorliegen. Zu CPAN werden wir später in diesem Kapitel kommen.

### Module importieren

Um Zugriff auf den Code aus einem beliebigen Modul Ihres Skripts zu erhalten, müssen Sie dieses Modul mit dem `use`-Operator und dem Namen des Moduls importieren:

    use CGI;
    use Math::BigInt;
    use strict;

Der `use`-Operator importiert die Subroutine und die Variablennamen, die von diesem Modul definiert und exportiert wurden, in das aktuelle Paket, so dass Sie sie verwenden können - so als hätten Sie sie selbst definiert (mit anderen Worten, das Modul enthält ein Paket, das eine Symboltabelle definiert; durch das Importieren dieses Moduls wird die Symboltabelle in die aktuelle Symboltabelle Ihres Skripts geladen).

Modulnamen können in vielen Formen auftreten: Ein einzelner Name benennt ein einfaches Modul, zum Beispiel `CGI`, `strict`, `POSIX` oder `Env`. Ein Name, der aus zwei oder mehr Teilen besteht, die durch zwei Doppelpunkte getrennt sind, bezieht sich auf Teile von größeren Modulen (sie beziehen sich, um genau zu sein, auf Pakete, die innerhalb anderer Pakete definiert sind). So bezieht sich zum Beispiel der Name `Math::BigInt` auf den Teil `BigInt` des `Math`-Moduls oder `Win32::Process` auf den Teil `Process` des `Win32`-Moduls. Modulnamen beginnen in der Regel mit einem Großbuchstaben.

Wenn Sie den Code eines Moduls mit dem `use`-Operator in Ihr Skript importieren, sucht Perl in einem besonderen Satz von Verzeichnissen, dem sogenannten `@INC`- Array, nach der Datei dieses Moduls. `@INC` ist eine spezielle Perl-Variable, die alle Verzeichnisse enthält, die in der Perl-Befehlszeile mit der Option `-I` aufgeführt wurden, gefolgt von den Verzeichnissen für die Standard-Perl-Bibliothek (/usr/lib/perl5`` und verschiedenen Unterverzeichnissen unter Unix, perl\lib unter Windows, MacPerl:lib unter Macintosh) und einem Punkt (`.`), der für das aktuelle Verzeichnis steht. Der endgültige Inhalt von `@INC` variiert von System zu System, und verschiedene Versionen von Perl können unter Umständen standardmäßig verschiedene Werte für `@INC` aufweisen. Auf meinem System, einer Linux-Maschine mit Perl 5.005_02 lautet der Inhalt von `@INC`

    /usr/lib/perl5/5.00502/i486-linux
    /usr/lib/perl5/5.00502
    /usr/lib/perl5/site_perl/5.005/i486-linux
    /usr/lib/perl5/site_perl/5.005
    .

Wenn Sie ein Modul importieren wollen, das in einem anderen Verzeichnis abgelegt ist, verwenden Sie das Pragma `lib` zu Beginn Ihres Skripts und geben das Verzeichnis an.

    use lib '/home/meineDaten/perl/lib/'
    use Meinmodul;

Die Dateien der Perl-Module haben den gleichen Namen wie die Module selbst und verwenden die Extension `.pm`. Viele Module enthalten ganz normalen Perl-Code mit ein wenig Extracode, damit sie sich wie Module verhalten. Wenn Sie also neugierig sind und wissen möchten, wie sie funktionieren, sollten Sie sich den Code einmal anschauen. Andere Module hingegen enthalten oder nutzen plattformspezifischen kompilierten Code, der nicht gerade besonders aussagekräftig ist.

> Die letztgenannten Module verwenden die sogenannten Perl-Extensionen, manchmal auch XSUBS genannt, mit denen Sie kompilierte C-Bibliotheken in Perl-Module einbinden können. Die Arbeit mit Extensionen geht weit über den Rahmen dieses Buchs hinaus; in Kapitel 20 werde ich Ihnen aber zumindest einige Tips geben, wo Sie weiterführende Informationen finden.

### Module verwenden

Mit `use` können Sie also ein Modul importieren. Und dann? Nun, nach dem Import können Sie den Code aus dem Modul nutzen. Wie Sie dabei vorgehen, hängt davon ab, ob das Modul einfacher Art oder objektorientiert ist (in der Dokumentation für das jeweilige Modul läßt sich feststellen, ob das Modul objektorientiert ist oder nicht).

Betrachten wir zum Beispiel das Modul `Carp`, das Teil der Standard-Perl-Bibliothek ist. Das `Carp`-Modul umfaßt die Subroutinen `carp`, `croak` und `confess` zur Erzeugung von Fehlermeldungen - ähnlich den vordefinierten Funktionen `warn` und `die`. Durch das Importieren des `Carp`-Moduls werden auch die drei Subroutinennamen in das aktuelle Paket importiert. Damit erhalten Sie Zugriff auf diese Subroutinen, so als ob es vordefinierte Funktionen wären oder Subroutinen, die Sie selbst definiert hätten:

    use Carp;
    open(OUT, ">ausgabedatei"
              || croak "ausgabedatei kann nicht geöffnet werden\n";

> Nebenbei erwähnt, entsprechen die Subroutinen `carp` und `croak` auch insofern den Funktionen `warn` und `die`, als sie zur Ausgabe von Fehlermeldungen verwendet werden (und im Falle von `die` und `croak` danach die Ausführung abbrechen). Die `Carp`-Subroutinen sind aber besser für die Verwendung in Modulen geeignet, da sie angeben, wo ein Fehler aufgetreten ist. Für den Fall, dass ein Skript ein Modul importiert, das eine Subroutine mit einem Aufruf von `carp` enthält, wird `carp` das Paket und die Zeilennummer des umschließenden Skripts angeben und nicht die Zeilennummer innerhalb des Moduls selbst (was für das Debuggen nicht besonders sinnvoll wäre). Auf `Carp` gehe ich im Zusammenhang mit CGI-Skripts in Kapitel 16 noch näher ein.

Einige Module sind objektorientiert. In der objektorientierten Programmierung spricht man statt von Funktionen und Subroutinen von »Methoden«, die dann allerdings anders ausgeführt werden als normale Funktionen. Für importierte objektorientierte Module müssn Sie eine besondere Syntax verwenden, um auf den Code zuzugreifen. (Ihr Skript muss allerdings nicht notwendigerweise objektorientiert sein; das sollte Ihnen kein Kopfzerbrechen bereiten. Sie können objektorientiertes Perl mit normalem Perl problemlos mischen.) Im folgenden sehen Sie ein Beispiel für ein CGI-Modul (das wir in Kapitel 16 noch eingehender untersuchen werden):

    use CGI;
    my $x = new CGI;
    my $name = $x->param("meinname");
    print $x->header();
    print $x->start_html("Hallo!");
    print "<H2>Hallo $name!\n";
    print $x->end_html();

Sieht seltsam aus, nicht wahr? Wenn Sie mit der objektorientierten Programmierung vertraut sind, ist Ihnen klar, dass Sie hier ein neues CGI-Objekt erzeugen, die Referenz auf das Objekt in der Variablen `$x` speichern und dann die Methoden mit der ->- Syntax aufrufen.

Ist Ihnen die objektorientierte Programmierung fremd, scheint alles nur seltsam. Hier eine Erläuterung in Kürze:

- Die Zeile `my $x = new CGI`; erzeugt ein neues CGI-Objekt und speichert eine Referenz darauf in der Variablen `$x`. `$x` ist kein normaler Skalar, wie ein Array oder ein String. In diesem Fall ist es eine Referenz auf ein spezielles CGI-Objekt.
- Um Subroutinen (genauer gesagt Methoden) aufzurufen, die in dem Modul definiert sind, bedienen Sie sich der Variablen, die das Objekt enthält, des `->`- Operators und des Namens der Subroutine. Demzufolge ruft die Zeile `$x- >header()` die Subroutine `header()` auf, die in dem in `$x` gespeicherten Objekt definiert ist.

Verwenden Sie die gleiche Notation für die anderen Subroutinen des Moduls, und Sie werden keine Schwierigkeiten haben. Auf Referenzen und Objektorientierung komme ich noch in Kapitel 19, »Mit Referenzen arbeiten«, zu sprechen.

### Symbole manuell importieren

Das Importieren eines Moduls mittels `use` bindet die Variablen und Subroutinennamen ein, die von dem besagten Modul definiert und exportiert wurden. Das Hauptaugenmerk in dem vorigen Satz liegt auf den Wörtern und exportiert - manche Module exportieren alle ihre Variablen, manche nur einige davon, und andere wiederum exportieren überhaupt keine. Mit `use` erhalten Sie Zugriff auf den ganzen Code des Moduls, jedoch nicht notwendigerweise so, als ob Sie ihn selbst geschrieben hätten. Deshalb ist es manchmal erforderlich, einige Extraschritte zu unternehmen, um auf ganz bestimmte Teile des Moduls Zugriff zu bekommen.

Wenn ein Modul, das Sie verwenden wollen, keine Variablen oder Subroutinennamen exportiert, werden Sie das früh genug herausfinden - spätestens wenn Sie versuchen, diese Namen zu verwenden, überschüttet Sie Perl mit Fehlermeldungen über nicht definierte Elemente. Es gibt jedoch zwei Möglichkeiten, um auf die von Ihnen gewünschten Elemente des Moduls zuzugreifen:

- Sie können die gewünschten Variablen oder Subroutinen referenzieren, indem Sie den vollständigen Paketnamen angeben.
- Sie können diese Symbole (Variablen oder Subroutinennamen) manuell in die `use`-Anweisung importieren.

Bei der ersten Möglichkeit müssen Sie für den Zugriff lediglich den Paketnamen vor die gewünschte Variable oder Subroutine stellen. Dieser Weg ist besonders dann zu empfehlen, wenn Sie in Ihrem Code gleichlautende Variablen oder Subroutinen haben und einen Namenskonflikt vermeiden wollen:

    # Aufruf von aufsummieren, definiert im Modul Meinmodule
    $ergebnis = &Meinmodule::aufsummieren(@werte);
    # aendert Wert der Variable $total (definiert in Meinmodule)
    $Meinmodule::total = $ergebnis;

Dabei gilt es zu beachten, dass ein Paketname, der bereits zwei Doppelpunkte enthält, in voller Länge vor den Variablennamen gesetzt wird:

    $Text::Wrap::columns = 5;

Die zweite Möglichkeit, alle benötigten Symbole zu importieren, ist dann geboten, wenn Sie beabsichtigen, die Subroutinen eines Moduls recht häufig in Ihrem Code aufzurufen. Durch das Importieren erreichen Sie, dass Sie den Paketnamen nicht jedesmal mit angeben müssen. Sie importieren einen Namen von einem Modul in das aktuelle Paket, indem Sie ihn an das Ende des `use`-Befehls anhängen. In der Regel geschieht dies mit Hilfe der Funktion `qw`, mit der Sie Anführungszeichen weglassen und neue Symbole schnell übernehmen können:

    use MeinModule qw(ersteSub, zweiteSub, dritteSub);

Wichtig ist, dass es sich hierbei um Symbolnamen und nicht um Variablennamen handelt. Es gibt keine Sonderzeichen vor den Namen, und alle Variablen in dem Modul, die diesen Namen tragen, werden importiert (das Symbol `foo` importiert zum Beispiel `$foo`, `@foo` und `&foo` und so weiter). Spezielle Variablen lassen sich mit Verwendung des jeweiligen Präfix importieren:

    use MeinModule qw($zaehlen);

Einige Module sind so definiert, dass sie einen Satz an Variablen aufweisen, die standardmäßig importiert werden, und einen Satz, der nur bei Bedarf importiert wird (ein Blick auf den Code wird Ihnen zeigen, dass das Hash `%EXPORT` in der Regel die standardmäßig exportierten Symbole enthält; `%EXPORT_OK` enthält die optionalen Symbole). Der einfachste Weg, beide zu importieren, besteht darin, `use` zweimal aufzurufen: einmal für die standardmäßigen Symbole und noch einmal für alle optionalen Symbole:

    use Meinmodule;    # importiert alle Standardnamen
    use Meinmodule qw(dies, das);   # importiert auch dies und das

### Import-Tags

Einige der größeren Module ermöglichen es Ihnen aus Effizienzgründen, nur einen Teilbereich ihrer Elemente zu importieren. Diese Module verwenden spezielle Import- Tags. Wenn Sie mit einem Modul arbeiten, das Import-Tags verwendet, so können Sie anhand der Dokumentation des Moduls herausfinden, welche Tags das Modul unterstützt. Sie können aber auch anhand des Hash `%EXPORT_TAGS` im Quelltext erkennen, welche Tags Sie verwenden können (Tags werden vom Modul exportiert und in Ihren Code importiert).

Um einen Teilbereich eines Moduls zu importieren, fügen Sie das Tag an das Ende der `use`-Anweisung an:

    use CGI qw(:standard);

Obwohl Sie das Import-Tag auch direkt in Anführungszeichen anhängen könnten, ist obige Form gebräuchlicher und vereinfacht überdies das Hinzufügen weiterer Tags.

Wie sich ein Modul verhält - ob es Import-Tags verwendet oder Variablen und Subroutinen enthält, die mit explizit importiert werden müssen -, wird vom Modul selbst definiert und ist (hoffentlich) dokumentiert. Vielleicht versuchen Sie einmal, `perldoc` auf dem Modul auszuführen, um alle vom Autor des Moduls bereitgestellten Online-Dokumentationen herauszufiltern, oder Sie gehen die `readme`-Dateien zu dem Modul durch, um sicherzustellen, dass Sie das Modul korrekt verwenden.

### Pragmas verwenden

Die Zeile `use strict`, mit der globale Variablen auf das aktuelle Skript beschränkt werden, ist ein Beispiel für eine besondere Art von Modul namens Pragma. Ein Pragma ist ein Modul, das darauf Einfluß hat, wie Perl sich zur Kompilier- und zur Laufzeit verhält (im Vergleich zu normalen Modulen, die nur zur Laufzeit Code für Perl bereitstellen). Insbesondere das `strict`-Pragma teilt Perl mit, beim Parsen Ihres Codes genau vorzugehen und verschiedene unsichere Konstrukte abzulehnen.

Wenn Sie sich an Kapitel 1, »Eine Einführung in Perl«, erinnern, wo ich gesagt habe, dass es sich bei Perl nicht um eine kompilierte Sprache wie bei C oder Java handelt, werden Sie die Begriffe Kompilierzeit und Laufzeit vielleicht etwas irritieren. In den genannten Sprachen bedienen Sie sich eines Compilers, um Ihren Quelltext in Bytecode oder eine ausführbare Datei zu überführen. Anschließend rufen Sie die neue Datei auf, um das Programm auszuführen. Bei Perl ist das Skript bereits eine ausführbare Datei. Es gibt keinen Kompilierschritt dazwischen.

In Wahrheit habe ich in Kapitel 1 etwas geschummelt, denn natürlich kompiliert auch Perl ebenso wie C und Java seinen Quelltext. Aber dann wird sofort das Ergebnis ausgeführt. Es gibt keine ausführbare Ergebnisdatei, die irgendwo gespeichert wird.

Das bedeutet aber, dass es Aufgaben gibt, die Perl zur Kompilierzeit (während das Skript kompiliert wird) erledigt, und Aufgaben, die während der Laufzeit (während das Ergebnis ausgeführt wird) bearbeitet werden. Beim Kompilieren überprüft Perl die Syntax und stellt sicher, dass alles, was für die Ausführung des Skripts benötigt wird, auch verfügbar ist. Zur Laufzeit wird das Skript dann ausgeführt, und es werden die Daten des Anwenders verarbeitet. Mit zunehmender Praxis werden Sie verschiedene Operationen kennenlernen, bei denen der Zeitpunkt der Ausführung genauso wichtig ist wie die Tatsache, dass sie überhaupt ausgeführt werden.

Jedoch zurück zu den Pragmas. Wie ich bereits gesagt habe, ist ein Pragma ein kurzer importierter Code, der darauf Einfluß nimmt, wie Perl während der Kompilier- und der Laufzeit arbeitet. Im Gegensatz zu den meisten importierten Codes in Modulen und Bibliotheken, die nur auf das Laufzeitverhalten eines Skripts einwirken, können Pragmas die Gesamtheit Ihres Codes und die Art, wie Perl ihn sieht, ändern.

Perl stellt Ihnen in seiner Standardbibliothek nur wenige Pragmas zur Verfügung (im Gegensatz zu Modulen, von denen es Dutzende gibt). Es ist Usus, Pragmas nur in Kleinbuchstaben zu schreiben, um sie von den Modulen zu unterscheiden. Aktiviert werden Pragmas genauso wie Module mit dem `use`-Operator:

    #!/usr/bin/perl -w
    use strict;
    use diagnostics;

Jedes Pragma kann in Ihrem Skript ganz oben angegeben werden, damit das ganze Skript davon betroffen ist. Es kann aber auch innerhalb eines Blocks verwendet werden, so dass nur das Verhalten dieses Blocks geändert wird. Am Ende des Blocks geht das Skript wieder zu seinem normalen Verhalten über.

Zu den nützlicheren Perl-Pragmas gehören `strict` und `diagnostics`. Eine etwas vollständigere Liste der verfügbaren Pragmas finden Sie in der perlmod-Manpage im Abschnitt »Pragmatic Modules«.

#### strict

Das Pragma `strict`, das Sie bereits kennengelernt haben, beschränkt die Verwendung einiger unsicherer Konstrukte in Ihren Skripts. So hält das `strict`- Pragma Ausschau nach fehlplazierten globalen Variablen, reinen Wörtern (Strings ohne Anführungszeichen, zu denen es in der Sprache keine Definitionen gibt) und symbolischen Referenzen (auf die wir in Kapitel 19 noch näher eingehen). Sie können auch nur ausgewählte dieser unsicheren Konstrukte abfangen, indem Sie die Strings `'vars'`, `'subs'` oder `'refs'` nach der Angabe von `use strict` mit aufnehmen:

    use strict 'vars';

Mit dem Befehl `no strict` (und, wenn notwendig, den optionalen Anhängen `'vars'`, `'subs'` und `'refs'`) können Sie die genaue Kontrolle für bestimmte Blöcke ausschalten. Dieser Befehl erstreckt sich nur bis zum Ende des umschließenden Blocks (Subroutine, Bedingung, Schleife oder freier Block). Danach kehrt Perl zu den vorherigen Einstellungen zurück.

#### diagnostics

Das Pragma `diagnostics` dient dazu, die expliziten Warnungen von Perl einzuschalten. Seine Funktionsweise entspricht in etwa der des `-w`-Schalters. Es kann jedoch dazu verwendet werden, die Diagnose-Meldungen und Warnungen auf spezielle Teile Ihres Skripts (Blöcke) zu beschränken. Sie können `diagnostics` nicht zur Kompilierzeit Ihres Skripts ausschalten (wie das bei `strict` mit Hilfe von `no strict` der Fall ist). Sie können die Laufzeitwarnungen allerdings mit den Direktiven `enable` und `disable` steuern:

    use diagnostics;

    # etwas Code

    disable diagnostics;
    # Code der normalerweise eine Laufzeit-Warnung ausgibt
    enable diagnostics;

    # weiter wie gehabt...

### Das Modul English

Das Modul `English` ist deshalb erwähnenswert, weil es, vergleichbar den Pragmas, eine Möglichkeit bietet, darauf Einfluß zu nehmen, wie Perl Ihr Skript interpretiert. Im Gegensatz zu den Pragmas wirkt es jedoch zur Laufzeit und kann hinsichtlich des Gültigkeitsbereichs nicht auf einen Block beschränkt werden. Das `English`-Modul wird verwendet, um die vordefinierten speziellen Variablennamen etwas weniger kryptisch erscheinen zu lassen. Während die wahren Perl-Junkies fröhlich ihre Skripts mit Variablen wie `$_`, `$"`, `$\` und so weiter übersäen, haben wir einfachen Sterblichen meist schon genug Mühe damit, auch nur die wichtigsten speziellen Variablen auseinanderzuhalten. In genau diesen Fällen ist `use English` eine große Hilfe, da es für die kryptischen Variablennamen verschiedene längere Aliase zur Verfügung stellt.

So ist zum Beispiel die Variable `$,` (ein Dollarzeichen und ein Komma) bekannt als das Trennzeichen für das Ausgabefeld, und es wird in `print`-Anweisungen verwendet, um die einzelnen Elemente voneinander zu trennen. Mit dem Befehl `use English` können Sie sich auf die Variable wie gehabt mit `$,` beziehen, aber genauso gut auch mit den Namen `$OUTPUT_FIELD_SEPARATOR` oder `$OFS`. Alle drei lassen sich gleichermaßen gut verwenden.

Eine Liste der speziellen Variablen von Perl und ihrer Namen (und Aliase) finden Sie in der perlvar-Manpage.

## Ein Beispiel: Das Modul Text::Wrap

Im folgenden möchte ich Ihnen ein kleines Beispiel präsentieren, in dem ein Modul der Standardbibliothek verwendet wird: das Modul `Text::Wrap`. Dieses Modul wird einen sehr langen String in mehrere Zeilen einer gegebenen Länge aufspalten und für jede Zeile ein optionales Einrückungszeichen aufnehmen.

Dieses spezielle Beispiel formatiert eine Eingabedatei auf eine Zeilenlänge von 80 Zeichen und rückt den Text in E-Mail-Manier ein: An den Anfang jeder Zeile wird das Zeichen `>` gestellt. Die betreffende Datei wird dabei in mehrere Abschnitte aufgeteilt, die jeweils durch eine Leerzeile getrennt werden. Wenn also die Eingabedatei wie folgt aussieht (ein einziger langer String; die Zeilenenden in dem untenstehenden Beispiel sind keine eigentlichen Zeilenenden bei der Eingabe):

    The event on which this fiction is founded has been supposed, by Dr. Darwin, and some of the physiological writers of Germany, as not of impossible occurrence. I shall not be supposed as according the remotest degree of serious faith to such an imagination; yet, in assuming it as the basis of a work of fancy, I have not considered myself as merely weaving a series of supernatural terrors. The event on which the interest of the story depends is exempt from the disadvantages of a mere tale of spectres or enchantment. It was recommended by the novelty of the situations which it develops; and, however impossible as a physical fact, affords a point of view to the imaginationfor the delineating of human passions more comprehensive and commanding than any which theordinary relations of existing events can yield.

wird die Ausgabe folgendermaßen aussehen:

    > The event on which this fiction is founded has been supposed, by Dr.
    > Darwin, and some of the physiological writers of Germany, as not of
    > impossible occurrence. I shall not be supposed as according the remotest
    > degree of serious faith to such an imagination; yet, in assuming it as
    > the basis of a work of fancy, I have not considered myself as merely
    > weaving a series of supernatural terrors. The event on which the interest
    > of the story depends is exempt from the disadvantages of a mere tale of
    > spectres or enchantment. It was recommended by the novelty of the
    > situations which it develops; and, however impossible as a physical
    > fact, affords a point of view to the imagination for the delineating of
    > human passions more comprehensive and commanding than any which the
    > ordinary relations of existing events can yield.

In Listing 13.1 finden Sie den Code für das Skript, mit dem Sie diese Aufgabe bewältigen.

Listing 13.1: Das Skript umbrechen.pl

    1:  #!/usr/bin/perl -w
    2:  use strict;
    3:
    4:  use Text::Wrap;                 # importiert das Modul
    5:  my $indent = "> ";              # Einrückungszeichen
    6:
    7:  while (<>) {
    8:      print wrap($indent, $indent, $_);
    9 : }

Wie Sie sehen können, ist der Code nicht besonders umfangreich, und es ist wesentlich einfacher, das Modul zu importieren, als die gleiche Prozedur mit rohem Perl-Code zu schreiben. Die wichtigen Teile des Skripts sind:

- Zeile 4: Hier wird das Modul `Text::Wrap` importiert.
- Zeile 5: Diese Zeile definiert das Einrückungszeichen (hier »`>` », es können jedoch auch beliebige andere Einrückungszeichen sein).
- Zeile 8: Hier wird die `wrap`-Funktion aufgerufen, die den Text letztendlich umbricht. Die `wrap`-Funktion, die in dem Modul `Text::Wrap` definiert ist, übernimmt drei Argumente: das Zeichen, mit dem die erste Zeile eingerückt wird, die Zeichen, mit denen alle folgenden Zeilen eingerückt werden und den umzubrechenden String. In diesem Falle wollen wir alle Zeilen mit dem gleichen Zeichen einrükken, so dass der Aufruf von `wrap` zweimal `$indent` spezifiziert.

Standardmäßig wird mit der Funktion `Text::Wrap` eine Zeile nach 76 Zeichen umbrochen. Dieser Wert läßt sich mit der Variablen `$columns` ändern, auch wenn diese Variable nicht automatisch vom Modul importiert wird. Sie müssen diese Variable explizit importieren oder den vollständigen Paketnamen angeben, wenn Sie davon Gebrauch machen wollen:

    use Text::Wrap qw($columns);   # importiert $columns
    $columns = 50;                 # setzt die Variable

## Module von CPAN (Comprehensive Perl Archive Network) verwenden

Wenn die Module der Standard-Perl-Bibliothek nicht ausreichen - und oft ist dies der Fall -, gibt es immer noch das CPAN. Das Comprehensive Perl Archive Network ist, wie ich bereits erwähnt habe, eine riesige Sammlung von öffentlich verfügbaren Perl- Modulen, die fast alle erdenklichen Bereiche abdecken. Sie benötigen ein Modul für die Handhabung verschlüsselter Daten? CPAN hat es. Sie wollen eine E-Mail senden. In CPAN finden Sie das passende Modul dafür. Sie wollen eine komplette HTML- Datei einlesen und verarbeiten? Kein Problem. Egal, was Sie vorhaben, es ist auf alle Fälle ratsam, erst einmal in CPAN nachzuforschen, ob Ihnen bereits jemand die Arbeit abgenommen hat. Es gibt keinen Grund, das Rad neu zu erfinden, wenn Sie den Code eines anderen verwenden können. Es ist schon von Vorteil, wenn man eine Perl- Gemeinde hat, auf die man sich verlassen kann.

### Ein warnender Hinweis

Auf eines möchte ich Sie allerdings aufmerksam machen: CPAN-Module haben zwei Nachteile. Der erste besteht darin, dass Sie Module erst herunterladen, einrichten und installieren müssen, bevor Sie sie verwenden können. Das bedeutet etwas mehr Arbeit als nur das Einfügen einer `use module`-Zeile in Ihr Skript. Bei einigen Modulen ist eventuell eine Kompilierung erforderlich, was wiederum einen funktionierenden C- Compiler auf Ihrem PC bedingt.

Das zweite Problem der Module im CPAN besteht darin, dass die meisten von ihnen für Unix-Perl entwickelt wurden. Wenn Sie Windows oder MacPerl verwenden, ist das von Ihnen benötigte Modul unter Umständen nicht für Ihre Plattform verfügbar. Diese Situation hat sich zum Glück in letzter Zeit etwas gewandelt, und zunehmend werden die Module plattformübergreifend programmiert. Vor allem Windows-Unterstützung wird immer populärer. Es gibt sogar ein spezielles Tool namens PPM zum Installieren und Verwalten von Windows-spezifischen CPAN-Modulen für die ActiveState-Version von Perl für Windows (PPM wird uns später noch, im Abschnitt »CPAN-Module unter Windows installieren«, beschäftigen). Wenn Sie sich nicht sicher sind, ob ein bestimmtes Modul für Ihre Plattform vorhanden ist, müssen Sie in der Dokumentation zu dem Modul nachschauen - und sich darauf einstellen, es eventuell selbst zu portieren.

### Wie man Module von CPAN herunterlädt

Die CPAN-Module sind auf der CPAN-Website oder einer gespiegelten Site (Mirror) abgelegt. Wenn Sie bei `http://www.perl.com/CPAN/CPAN.html` starten, können Sie von dort aus feststellen, was CPAN enthält, wie man an die Dateien gelangt und wie man herausfindet, ob ein bestimmtes Modul für Ihre Plattform verfügbar ist. Es gibt auch eine Suchmaschine für Module, so dass Sie ziemlich schnell herausfinden können, ob es zu Ihrem Problem ein Modul gibt. Anhang B enthält ebenfalls eine umfangreiche Liste der Module, die zum Zeitpunkt der Drucklegung dieses Buches zur Verfügung standen (da jedoch ständig neue Module hinzukommen, sollten Sie trotzdem noch die Online-Version konsultieren).

Einige Module sind gebündelt, um die Abhängigkeiten zwischen den verschiedenen Modulen zu reduzieren (es gibt nichts Ärgerlicheres, als ein Skript auszuführen, das ein Modul benötigt, und dann nach dem Herunterladen festzustellen, das dieses Modul ein weiteres Modul erfordert, das dann wiederum ein drittes Modul benötigt und so weiter). Modulbündel beginnen in der Regel mit dem Wort `lib` - zum Beispiel die Modulgruppe `libwww`, die eine ganze Reihe von Modulen zur Handhabung von allem, was das World Wide Web betrifft, enthält. Wenn das von Ihnen benötigte Modul als Teil eines Bündels im CPAN erhältlich ist, sind Sie gut beraten, wenn Sie das ganze Bündel herunterladen und nicht nur das einzelne Modul.

Angenommen Sie haben ein Modul gefunden, das Sie verwenden wollen. Grundsätzlich gehen Sie so vor, dass Sie das Modul herunterladen und mit den Tools für Ihre Plattform dekomprimieren oder dearchivieren (normalerweise `gzip` und `tar` für Unix, `WinZip` für Windows und `Stuffit` für Mac). Unter Unix gehört zu vielen Modulen eine `make`-Datei, die dafür Sorge trägt, das alles an der richtigen Stelle installiert wird (mit dem Befehl `make` starten Sie den Prozeß). Wenn Sie mit einem Windows- oder Mac-PC arbeiten und es keine besonderen Anweisungen für die Installation der Dateien auf Ihrer Plattform gibt, genügt es unter Umständen, die `.pm`-Moduldateien einfach an die entsprechenden Stellen in der Perl-Hierarchie zu kopieren. In der perlmodinstall-Manpage der Perl- Version 5.005 finden Sie viele Vorschläge speziell zum Dekomprimieren und Installieren der Module. Das Verfahren kann jedoch für jedes Modul variieren. Deshalb sollten Sie sich eng an die Vorgabe der `README`-Dateien halten, um sicherzustellen, dass alles korrekt installiert wird.

Einige Module enthalten Teile, die in C geschrieben wurden. Dafür kann unter Umständen ein C-Compiler auf Ihrer Maschine erforderlich werden. Haben Sie keinen derartigen Compiler zur Verfügung, können Sie Teile des Moduls unter Umständen auch ohne C-Compiler verwenden. Auch hier gilt es, die Dokumentation zu dem Modul zu Rate zu ziehen.

Wenn Sie unter Unix arbeiten und Module mit kompilierten Teilen installieren, sollten Sie sicherstellen, dass der C-Compiler zum Kompilieren der Module der gleiche ist wie der, mit dem Perl ursprünglich kompiliert wurde. Bei Modulen, die nicht in der gleichen Umgebung kompiliert wurden wie Perl, können nur schwer zu lösende Inkompatibilitäten auftreten.

Nachdem Sie die Dearchivierung, Einrichtung, Kompilierung und Installation abgeschlossen haben, sollte eine Reihe von Dateien an den richtigen Positionen in der Perl-Hierarchie installiert worden sein. Vielleicht wollen Sie die verschiedenen Verzeichnisse in Ihrem `@INC`-Array durchgehen, um sicherzustellen, dass es sie gibt.

### CPAN-Module unter Windows installieren

Der Perl Package Manager, auch PPM genannt, ist ein Zusatzprogramm, das mit der ActiveState-Version von Perl für Windows ausgeliefert wird. Es erleichtert ganz enorm die Installation und Verwaltung von CPAN-Modulen unter Windows. Bei Verwendung von PPM müssen Sie sich keine Gedanken darum machen, ob ein bestimmtes Modul von Windows unterstützt wird, oder langwierig austüfteln, wie es mit Hilfe irgendwelcher mysteriöser Unix-Tools kompiliert oder installiert wird. Mit PPM können Sie von einem Programm aus einzelne, bereits erstellte Module installieren, aktualisieren und entfernen.

> Ein Paket im Sinne des Perl Package Manager ist eine Sammlung von einem oder mehreren Modulen und unterstützenden Dateien. Verwechseln Sie es nicht mit den Paketen für die Perl-Namensbereiche.

Um PPM nutzen zu können, müssen Sie mit dem Internet verbunden sein. Das PPM- Skript erhält seine Pakete von einer Sammlung auf der ActiveState-Website. Gestartet wird PPM einfach durch die Eingabe von `ppm` in eine Befehls-Shell:

    c:\> ppm
    PPM interactive shell (0.9.5) - type 'help' for available commands
    PPM>

Nach der PPM-Eingabeaufforderung haben Sie mehrere Möglichkeiten einschließlich

- `help` - um eine Liste von Optionen auszugeben
- `search` - um anzuzeigen, welche Pakete für eine Installation zur Verfügung stehen
- `query` - um anzuzeigen, welche Pakete Sie bereits installiert haben
- `install` - um ein spezielles Paket zu installieren
- `verify` - um zu überprüfen, dass alle Pakete aktuell sind
- `remove -` um ein spezielles Paket zu entfernen

Mehr über PPM erfahren Sie auf der PPM-Webseite (Teil der ActiveState-Site für die Installation von Perl unter Windows) oder unter `http://www.activestate.com/ activeperl/docs/ppm.html`.

### Module von CPAN nutzen

Nachdem Sie ein CPAN-Modul installiert haben - entweder durch eigenes Herunterladen und Installieren, mit Hilfe von PPM oder durch manuelles Kopieren der Dateien in Ihre Perl-Installation - steht das Modul Ihren Skripts zur Verfügung. Sie können es anschließend mit `use` importieren und sein Leistungsspektrum wie bei jedem anderen Modul nutzen. Anhand der Modul-Dokumentation können Sie sich darüber informieren, ob es ein normales oder objektorientiertes Modul ist, oder feststellen, ob es Import-Tags verwendet. Aber abgesehen davon, dass sie erst einmal installiert werden müssen, unterscheiden sich CPAN-Module in nichts von denen der Standardbibliothek.

## Vertiefung

In diesem Kapitel habe ich etliche Themen angerissen: Pakete, Module, Importieren derselben und die Art und Weise, wie Perl den Code zu verschiedenen Zeiten sieht. Vieles, was in diesem Kapitel angesprochen wurde, ist nur die Spitze des Eisbergs. Allein über Pakete und Module könnte man ganze Bücher füllen, und die paar Absätze, die ich dem objektorientierten Design gewidmet habe, reichen kaum aus, um in das Thema einzusteigen.

Auf einige dieser Themen werde ich weiter hinten in diesem Buch noch näher eingehen. Andere Themen jedoch, einschließlich der Entwicklung eigener Pakete und praktisch alles, was mit der Erstellung von Modulen zusammenhängt, dürfen den erfahreneren Perl-Programmierern vorbehalten bleiben und werden deshalb nicht im Rahmen dieses Buches behandelt. Nachdem Sie die 21 Lektionen dieses Buchs durchgearbeitet haben, können Sie Ihre Kenntnisse über Module und Pakete mit Hilfe der Online-Hilfsdokumentationen und der FAQs erweitern.

Einige Themen mit direktem Bezug zu den bisher in diesem Kapitel behandelten Themen kann ich jedoch noch in diesem Abschnitt behandeln.

### Typeglobs (Typenplatzhalter)

Typeglobs ist eine seltsame Bezeichnung dafür, dass man auf die verschiedenen Typen von Variablen mit einem einzigen Namen Bezug nehmen kann (der Begriff Typeglob stammt von Unix, wo der Bezug auf mehrere Dateien mit `file.*` oder einem ähnlichen Zeichen auch als Datei-Globbing bezeichnet wird). Typeglobbing bezieht sich auf die Einträge einer Symboltabelle eines gegebenen Pakets.

Der Typglob-Ausdruck `*foo` bezeichnet alle Variablen mit dem Namen `foo`: `$foo,` `@foo`, `&foo` und so weiter. Normalerweise unterscheiden sich diese Variablen, mittels Typeglobbing werden Sie jedoch zusammengefaßt.

In früheren Versionen von Perl wurde Typeglobbing dazu verwendet, um Arrays als Referenz an Subroutinen zu übergeben. Sie konnten einen Typeglob verwenden, um eine lokale Variable als Alias für ein globales Array zu verwenden; Änderungen am lokalen Array sollten dann an das globale Array übertragen werden:

    @foo = (1,2,3);
    &dreienentfernen(*foo);

    sub dreienentfernen {
       my *liste = @_;
       foreach my $x @liste {
          if ($x == 3) { undef $x }
       }
       return @liste;
    }

In diesem Beispiel finden sich alle Änderungen an der lokalen Liste, in `@liste` auch in der Liste `@foo`, da `@liste` als Alias für `@foo` eingerichtet wurde.

Statt Typeglobs verwendet man für die Übergabe von Arrays an Subroutinen heute meist die neue Referenzsyntax. Mit Referenzen können Sie nicht nur einzelne Arrays als Referenz an Subroutinen übergeben, sondern auch die Integrität mehrerer Arrays wahren. Verwenden Sie deshalb für die Übergabe von Arrays an Subroutinen Referenzen statt Typeglobs (weitere Informationen zu Referenzen in Kapitel 19).

### Ein weiterer Unterschied zwischen local und my

Der auffälligste Unterschied zwischen Variablen, die mit `my` definiert wurden, und solchen, die mit `local` definiert wurden, sind, wie ich weiter vorn schon bemerkt habe, der lexikalische und der dynamische Gültigkeitsbereich. Ein zweiter Unterschied besteht darin, wie Perl diese Variablen verwaltet:

- `local`-Variablen sind eigentlich versteckte globale Variablen. Wenn Sie eine lokale Variable erzeugen, während eine globale Variable gleichen Namens existiert, sichert Perl den Wert dieser globalen Variablen und reinitialisiert die gleiche Variable (und die gleiche Position in der Symboltabelle) mit dem neuen lokalen Wert. Nach dem Verlassen des lokalen Gültigkeitsbereichs ist der Wert der globalen Variablen wieder gültig.

- `my`-Variablen sind völlig neue Variablen, die nicht in der Symboltabelle gespeichert werden. Sie sind absolut privat zu dem Block oder der Subroutine, in der sie gespeichert sind. Damit sind sie schneller in der Anwendung als die lokalen `local`- Variablen, da kein Durchsuchen der Symboltabelle erforderlich ist.

Keiner der Unterschiede wird einen Einfluß darauf haben, wie Sie `local` oder `my` in Ihren eigenen Skripts verwenden (lokale `local`-Variablen sind für das Typeglobbing relevant, doch das ist nicht mehr Thema dieses Buches). In den meisten Fällen sollten Sie `my` verwenden, wenn Sie eine lokale Variable erzeugen wollen, und es wird keine Probleme geben.

### Ein Beispiel für local im Vergleich zu my

In dem Abschnitt zu den lokalen Variablen, die entweder mit `local` oder mit `my` definiert wurden, hatte ich Ihnen noch ein Beispiel versprochen. Das Skript in Listing 13.2 soll etwas Licht ins Dunkel der Unterscheidung zwischen `local` und `my` bringen (und Sie hoffentlich nicht noch mehr verwirren).

Listing 13.2: Ein Skript zum Gültigkeitsbereich

    1:  #!/usr/bin/perl -w
    2:
    3:  $global = " globale Variable hier verfügbar\n";
    4:
    5:  &subA();
    6:  print "Hauptskript:\n";
    7:  foreach $var ($global, $mylocal, $locallocal) {
    8:      if (defined $var) {
    9:          print $var;
    10:     }
    11: }
    12:
    13: sub subA {
    14:     my $mylocal = " mylocal-Variable hier verfügbar\n";
    15:     local $locallocal = " lokale local-Variable hier verfügbar\n";
    16:     print "SubA:\n";
    17:     foreach $var ($global, $mylocal, $locallocal) {
    18:         if (defined $var) {
    19:             print $var;
    20:         }
    21:     }
    22:     &subB();
    23: }
    24:
    25: sub subB {
    26:     print "SubB: \n";
    27:     foreach $var ($global, $mylocal, $locallocal) {
    28:         if (defined $var) {
    29:             print $var;
    30:         }
    31:     }
    32: }

Dieses Skript verwendet drei Variablen, `$global`, $`mylocal` und `$locallocal`, und deklariert sie ordnungsgemäß. Für jede Subroutine sowie am Ende des Skripts werden die Werte dieser Variablen ausgegeben, soweit sie existieren und einen definierten Wert haben. Versuchen Sie, dem Programmfluß zu folgen und vorherzusagen, was wann ausgedruckt wird.

Und so lautet die Ausgabe:

    SubA:
     globale Variable hier verfügbar
     mylocal-Variable hier verfügbar
     lokale local-Variable hier verfügbar
    SubB:
     globale Variable hier verfügbar
     lokale local-Variable hier verfügbar
    Hauptskript:
     globale Variable hier verfügbar

Hätten Sie das erwartet? Lassen Sie uns das Programm gemeinsam durchgehen. Das Skript beginnt oben und ruft `&SubA()` auf, eine Subroutine, die wiederum `&SubB()` aufruft und einige Variablen ausgibt. In der Subroutine `&SubA()` deklarieren wir in Zeile 14 und 15 `$mylocal` und `$locallocal` mit den beiden Modifizierern `my` und `local`. Beide Variablen plus der Variablen `$global` sind damit innerhalb der Grenzen dieser Subroutine verfügbar, so dass alle drei Werte ausgegeben werden.

In Zeile 22 ruft `&subA()` die Subroutine `&subB()` auf. Hier geben wir nur die Variablen aus, die verfügbar sind. Das wäre zum einen die globale Variable, da globale Variablen allen Teilen des Skripts zur Verfügung stehen. Die Variable `$mylocal` gibt es allerdings nicht mehr, denn der `my`-Modifizierer legt fest, dass die lokale Variable nur in der Subroutine verfügbar ist, in der sie definiert wurde, und nicht in anderen Teilen des Skripts. Die Variable `$locallocal` ist dagegen auch in den Subroutinen verfügbar, deren Definitionen von der Subroutine mit der Variablendefinition umschlossen werden.

Nachdem `&subB()` abgearbeitet ist, kehrt die Ausführung zurück zu `&subA()` und damit zum Hauptteil des Skripts, wo wir ebenfalls versuchen, diese Werte auszugeben. Da hier nur die globale Variable verfügbar ist, wird auch nur deren Wert ausgegeben.

### Paketinitialisierung und -beendigung mit BEGIN und END

Bevor wir fortfahren, möchte ich Ihnen noch einen Aspekt der Anwendung von Paketen vorstellen: die Subroutinen `BEGIN` und `END`, mit denen ein Skript vor seiner Ausführung initialisiert und nach seiner Ausführung beendet wird. Diese Subroutinen werden am häufigsten in komplexen Perl-Bibliotheken und -Modulen und als Konstruktoren und Destruktoren für objektorientierte Klassen verwendet.

Die `BEGIN`-Subroutine wir ausgeführt, sobald das Programm darauf stößt, und zwar während der Kompilierzeit, bevor der Rest des Skripts geparst ist. Sie sollten `BEGIN` für jeden Code verwenden, der zur Kompilierzeit ausgeführt werden soll, zum Beispiel um Symbole für Moduldefinitionen zu importieren, die später in anderen Code exportiert werden, oder um Code mit aufzunehmen, der von dem Modul benötigt wird.

`END` hingegen wird ausgeführt, nachdem die Ausführung des Perl-Skripts abgeschlossen ist. Das gilt sowohl für Skripts, die korrekt ausgeführt wurden, als auch für frühzeitig abgebrochene Skripts, bei denen ein Fehler auftrat (einschließlich `die`). Mit `END` sollten Sie nach der Ausführung Ihres Skripts aufräumen. Sie können mit `END` zum Beispiel den Statuswert ändern, der an die Unix-Shell zurückgegeben wird, nachdem Ihr Skript beendet ist.

Mehr zu `BEGIN` und `END` finden Sie in der perlmod-Manpage.

### Code mit require importieren

Bisher habe ich Ihnen gezeigt, wie Sie mit der `use`-Funktion Code aus Modulen importieren. Kurz gesagt:`Use` importiert zur Kompilierzeit Code und Symbole aus anderen Quellen in das aktuelle Paket. Die Funktion `require` hingegen ermöglicht es, Code von anderen Quellen zur Laufzeit mit aufzunehmen (um genau zu sein, entspricht `use` dem Aufruf von `require` innerhalb einer `BEGIN`-Subroutine und dem Import der Variablen dieser Datei in den aktuellen Namensbereich).

In früheren Versionen von Perl wurde `require` als allgemeiner Import-Mechanismus verwendet. Subroutinen und globale Variablendefinitionen wurden in einer separaten Datei gespeichert, und diese Datei wurde dann mit `require` in das Skript mit aufgenommen:

    require 'foo.pl';

Perl sucht nach der gegebenen Datei, die importiert werden soll, in den in `@INC` gespeicherten Verzeichnissen. Gleichzeitig merkt sich Perl, welche Dateien bereits importiert wurden, so dass bereits geladener Code nicht noch einmal importiert wird. Wenn die aufgenommene Datei jedoch ihr eigenes Paket definiert, dann werden mit `require` die Variablen dieses Pakets nicht in das aktuelle Paket importiert (nicht einmal von `main`), und Sie müssen diese Variablen mit dem kompletten Paketnamen ansprechen. Außerdem gilt es bei der Verwendung von `require` Sorgfalt walten zu lassen, denn `require` wird zur Laufzeit ausgeführt. Das bedeutet, Sie müssen sicherstellen, dass `require` ausgeführt wird, bevor irgend etwas aufgerufen oder verwendet wird, was in dieser importierten Datei definiert ist.

Dieser Mechanismus zum Importieren von Code von einer Datei in eine andere funktioniert auch noch anstandslos in den neueren Versionen von Perl, und Sie können ihn verwenden, um Ihre eigenen einfachen Bibliotheken mit Subroutinendefinitionen aufzubauen. Die neuen Mechanismen der Pakete und Module sind jedoch leistungsfähiger und erlauben eine genauere Kontrolle über das, was und vor allem wann importiert wird. Wenn Sie ernsthaft in die Entwicklung von Bibliotheken einsteigen wollen, sollten Sie sich intensiver mit den Entwicklungspaketen, Modulen und `use` vertraut machen.

Ein weiteres nützliches Einsatzgebiet von `require` ist seine Verwendung zusammen mit der Perl-Versionsnummer. Falls Sie diese Einsatzmöglichkeit nutzen und das Skript mit einer früheren Version von Perl ausführen, wird das Skript sofort mit einer Fehlermeldung abbrechen. Damit können Sie sicherstellen, dass die zur Ausführung verwendete Perl-Version auch über die gleichen Merkmale verfügt, die Sie in Ihrem Skript verwenden - zum Beispiel Merkmale, die es nur in Perl 5 gibt, oder noch fortschrittlichere Merkmale, die nur in 5.005 oder höher existieren:

    require 5.005;

Weitere Informationen zu `require` finden Sie in der perlfunc-Manpage.

## Zusammenfassung

Einige der heute behandelten Themen mögen Ihnen vielleicht etwas abgehoben vorkommen, aber sie werden mit jedem weiteren Kapitel dieses Buches an Bedeutung gewinnen. Die erste Hälfte dieses Kapitels war den Variablen und ihren Gültigkeitsbereichen gewidmet. Ich habe Ihnen die globalen Variablen vorgestellt und gezeigt, was es bedeutet, wenn sie durch die Verwendung von Paketen nicht mehr im eigentlichen Sinne global sind, und wie man sicherstellt, dass globale Variablen durch die Definition von `my` lokal zu einem Skript sind.

Dann sind wir zu den lokalen Variablen übergegangen, und Sie haben mehr über die Verwendung von `my`-Variablen innerhalb von Blöcken und Subroutinen erfahren und über die Definition von lokalen Variablen mit `local`.

In Anbetracht all dieser Möglichkeiten zum Deklarieren und Verwenden der verschiedenen Variablen ist es schwer, die richtige Wahl zu treffen. Perl- Programmierer haben allgemeine Regeln und Praktiken entwickelt, die gewöhnlich als Leitfaden für die Anwendung von Variablen und Gültigkeitsbereichen dienen:

- Deklarieren Sie keine reinen globalen Variablen. Deklarieren Sie alle globalen Variablen mit `my`, und verwenden Sie `use` `strict`, um sicherzustellen, dass alles seine Ordnung hat.
- Deklarieren Sie lokale Variablen vorzugsweise mit `my` und nicht mit `local`, es sei denn, es gibt besondere Gründe dafür. Lokale `local`-Variablen weisen viele der gleichen Probleme hinsichtlich Wiederverwertung und Debuggen auf wie globale Variablen und beeinträchtigen die ansonsten klare Trennung zwischen den Begriffen lokal und global.
- Versuchen Sie, gleichlautende Namen unter lokalen und globalen Variablen zu vermeiden, es sei denn, es gibt besondere Gründe dafür.
- In der zweiten Hälfte des Kapitels bin ich auf die `use`-Funktion eingegangen. Sie haben gelernt, wie Sie `use` einsetzen, um Pragmas einzuschalten - Hinweise an Perl, wie Ihre Skripts zu kompilieren und auszuführen sind - und um Code zu importieren und zu verwenden, der in Modulen der Standardbibliothek oder der CPAN enthalten ist. Zu den wichtigsten Punkten, die Sie heute gelernt haben, gehören die Module. Module werden uns im Rest des Buches immer wieder begegnen.

Die weiteren Funktionen und Befehle, die wir heute besprochen haben, umfassen:

- `package` - um zwischen den verschiedenen Paketen hin- und herzuschalten
- `my` - um eine lokale Variable zu definieren oder eine globale Variable, die nicht Teil eines Pakets ist
- `use strict` - um sicherzustellen, dass Sie nicht irgendwelche wilden globalen Variablen verwenden
- `local` - um auf eine andere Art lokale Variablen zu definieren (`my` ist vorzuziehen)
- `use` - um allgemein ein Pragma oder ein Modul zu importieren

## Fragen und Antworten

Frage:
Worin liegt der Vorteil von globalen Variablen, die mit `my` deklariert wurden, gegenüber normalen globalen Variablen, wenn ich in sich geschlossene Skripts schreibe, die nur sehr einfache Aufgaben ausführen?

Antwort:
Wenn Sie nur kleinere, abgeschlossene Skripts schreiben, müssen Sie nicht unbedingt `use strict` verwenden oder sicherstellen, dass Ihre Variablen mit `my` deklariert wurden. Globale `my`-Variablen werden dann verwendet, wenn davon auszugehen ist, dass Ihr Code, und sei es auch nur zufällig, in den Code eines anderen Skripts inkorporiert wird. Da es häufig vorkommt, dass Code - auch gegen den ursprünglichen Zweck - wiederverwertet wird, ist die Verwendung von `my` und `use strict` bei globalen Variablen nur eine vorsorgliche Absicherung und guter Programmierstil. Erforderlich ist es jedoch nicht immer.

Frage:
Ich verwende die ActiveState-Version von Perl für Win32. Mein Skript weist `use` `strict`-Definitionen auf und beschwert sich aber über die Variable innerhalb der `foreach`-Definition. Deklariere ich die Variable mit `my`, erhalte ich ebenfalls einen Fehler. Was mache ich falsch?

Antwort:
Nichts. In der ActiveState-Version von Perl für Win32 können Sie die `my`- Deklaration nicht innerhalb der `foreach`-Schleife verwenden. Deklarieren Sie die `my`-Variable einfach irgendwo anders, und verwenden Sie sie dann innerhalb der `foreach`-Schleife. Damit sind Sie aus dem Schneider.

Frage:
Die meisten Sprachen verwenden entweder den lexikalischen oder den dynamischen Gültigkeitsbereich, aber nicht beide. Warum schafft Perl da Verwirrung, indem es mehrere Arten von lokalen Gültigkeitsbereichen bietet?

Antwort:
Das hat größtenteils historische Gründe. Frühere Versionen von Perl boten einen dynamischen Gültigkeitsbereich für Variablen mit dem `local`-Operator. Der `my`-Operator kam später hinzu, um einen lexikalischen lokalen Gültigkeitsbereich zu schaffen, der eindeutiger ist. Aus Gründen der Rückwärtskompatibilität mit früheren Skripts gibt es `local` immer noch. Wenn Ihnen die Unterscheidung zuviel Kopfzerbrechen bereitet, verwenden Sie einfach ausschließlich `my`-Variablen, und gehen Sie davon aus, dass sie privat zu allen gegebenen Subroutinen sind. Das dürfte reichen.

Frage:
Ich habe ein älteres Skript von jemand anderem, das mit einer Reihe von `require` `dieseBibliothek.pl`-Zeilen beginnt. Soll ich diese in `use-Befehle` ändern?

Antwort:
Besser nicht. Mit dem `require`-Operator wurde früher Bibliothekscode in Perl- Skripts eingebunden, und es ist wahrscheinlich, dass die Bibliothek, die Sie importieren (`dieseBibliothek.pl` in Ihrem Beispiel), nicht als Modul geschrieben und deshalb auch nicht gut mit `use` anzusprechen ist. Solange Sie nicht vorhaben, das gesamte Skript neu zu schreiben - einschließlich aller Bibliotheken -, sollten Sie ruhig weiterhin `require` verwenden.

Frage:
Ich habe hier ein Modul namens `Mail`, das mir Zugriff auf Subroutinen zum Senden und Empfangen von Mails verschaffen soll: `send_mail()` und `rec_mail()`. Ich habe das Modul mit `use` importiert, erhalte aber Fehlermeldungen, dass die beiden Subroutinen nicht definiert seien.

Antwort:
Das klingt, als wenn das Modul diese zwei Subroutinen nicht explizit importiert. In diesem Falle haben Sie zwei Möglichkeiten: Entweder importieren Sie die Subroutinen selbst, oder Sie rufen die Subroutinen mit ihrem vollen Paketnamen auf:

        use Mail;  # importiert Standardroutinen, falls vorhanden
    use Mail qw(send_mail rec_mail);  # importiert Subroutinen
    send_mail();
    # ODER
    &Mail::send_mail();  # ruft Subroutine mit vollem Paketnamen auf

## Workshop

Der Workshop enthält Quizfragen, die Ihnen helfen, Ihr Wissen zu festigen, und Übungen, die Sie anregen, das eben Gelernte umzusetzen und eigene Erfahrungen zu sammeln. Versuchen Sie, das Quiz und die Übungen zu beantworten und zu verstehen, bevor Sie zur Lektion des nächsten Tages übergehen.

### Quiz

1. Was ist ein Paket? Warum sind Pakete nützlich?
2. Wie rufen Sie eine Variable mit ihrem vollen Paketnamen auf?
3. Können Sie `my` mit globalen Variablen verwenden? Warum sollten Sie das machen?
4. Was bewirkt die Zeile `use strict`? Warum sollten Sie diesen Befehl verwenden?
5. Worin liegen die Unterschiede zwischen Bibliotheken, Modulen, Paketen und Pragmas?
6. Was ist das CPAN? Wo ist es zu finden?
7. Wozu wird das `@INC`-Array benötigt?
8. Wie importieren Sie ein Modul in Ihr Skript? Was bringt Ihnen der Import?
9. Was versteht man unter einem Import-Tag, und wann sollte man es verwenden?
10. Wie rufen Sie eine Subroutine auf, die Sie von einem Modul importiert haben? Wie rufen Sie eine Subroutine von einem objektorientierten Modul auf?

### Übungen

1. Definieren Sie eine Subroutine, die als einziges Argument einen String übernimmt und einen neuen String daraus macht, wobei die Zeichen durch einen global definierten Wert getrennt werden (wie zum Beispiel »:«). Geben Sie den neuen String zurück. Der Haken dabei: Verwenden Sie den gleichen Variablennamen für die lokale Variable, die den neuen String, und die globale Variable, die das Trennzeichen enthält. HINWEIS: Verwenden Sie nicht `use strict` oder globale `my`-Variablen.
2. FEHLERSUCHE: Was ist falsch an diesem Skript?

           use Dies:Das;                 # importiert Module
       while (<>) {
           print dasandere($_);
       }

3. Modifizieren Sie das Skript umbrechen.pl, so dass es Sie auffordert, eine Spaltenbreite einzugeben. Brechen Sie dann den Eingabetext nach dieser Größenangabe um.
4. Betrachten Sie das Modul `Config`, das Teil der Standard-Perl-Bibliothek ist. Dieses Modul wird verwendet, um Konfigurationsinformationen über die aktuelle Perl- Version zu speichern. Bedienen Sie sich der Dokumentation zu `Config` (die Sie über das Programm perldoc, die Shuck-Anwendung in MacPerl oder über die perlmod-Manpage erhalten). Schreiben Sie ein Skript, das die verschiedenen Werte, die in `Config` verfügbar sind, ausgibt. HINWEIS: Das `Config`-Modul importiert nicht automatisch alle Subroutinennamen.

## Antworten

Hier die Antworten auf die Workshop-Fragen aus dem vorigen Abschnitt.

### Antworten zum Quiz

1. Pakete werden verwendet, um Sätze von globalen Variablen in einer einzigen Einheit zu bündeln. Damit können diese Einheiten kombiniert werden, ohne dass es zu Überschneidungen zwischen den Variablen der verschiedenen Einheiten kommt. Pakete sind am nützlichsten für Skripts, die aus mehreren Teilen bestehen, die harmonisch aufeinander abgestimmt werden müssen, oder für Module mit wiederverwendbarem Code.
2. Der vollständige Paketname einer jeden Variablen oder Subroutine besteht aus dem Variablensymbol (`$` für Skalare, `@` für Arrays, `%` für Hashes, `&` für Subroutinen und so weiter), dem Paketnamen, zwei Doppelpunkten und dem Variablennamen. Ein Beispiel: `$Einmodule::einevariable` oder &`Einmodule::einesubroutine()`.
3. Die Deklaration von globalen Variablen mit `my` verhindert, dass sie in dem `main`- Paket deklariert werden. Dadurch wird die Wertesuche und -zuordnung etwas effizienter, und Ihr Skript zeigt ein besseres Verhalten, sollte es je in ein anderes Paket inkorporiert oder mit anderen Skripts kombiniert werden.
4. `use strict` ist eine Perl-spezifische Direktive, die sicherstellt, dass alle Variablen in Ihrem Skript lokal oder einem bestimmten Paket zugeordnet sind. Auf Ihrem derzeitigen Perl-Wissensstand ist es sinnvoll, freie globale Variablen abzufangen und Ihre Skripts hinsichtlich der Variablendeklarationen so abgeschlossen wie möglich zu machen.
5. Bibliotheken sind Sammlungen von Perl-Code, der wiederverwendet werden kann. Bibliotheken können Pakete verwenden, um Variablennamen innerhalb der Bibliothek zu verwalten. Ein Modul ist eine Bibliothek, die ein Paket verwendet und den gleichen Dateinamen trägt wie das Paket. Module umfassen Code, der dafür sorgt, dass das Modul ohne Schwierigkeiten in anderen Skripts wiederverwendet werden kann. Ein Pragma ist eine besondere Art von Modul, das Einfluß auf die Arbeitsweise von Perl zur Kompilier- und Laufzeit nimmt.
6. CPAN steht für Comprehensive Perl Archive Network. Es handelt sich dabei um eine Sammlung von Beiträgen von Perl-Nutzern: Module, Skripts, Dokumentationen und Hilfsprogramme, die jeder, der in Perl programmiert, nutzen kann. CPAN ist auf diversen Sites rund um den Globus verfügbar. Ihre nächstgelegene Site finden Sie ausgehend von `http://www.perl.com/CPAN/`.
7. Das `@INC`-Array definiert die Verzeichnisse, in denen Perl nach den Modulen und dem Code schaut, der in Ihre Skripts mit `use` importiert werden soll.
8. Importieren Sie ein Modul in Ihr Skript durch Verwendung von `use`, gefolgt von dem Namen des Moduls und einer optionalen Liste von Variablen oder Import- Tags. Der Import eines Moduls verschafft Ihnen Zugriff auf die Variablen und Subroutinen, die von dem Modul definiert sind.
9. Ein Import-Tag definiert einen Teilbereich von Variablen und Subroutinen in dem Modul, das Sie in Ihr Skript importieren wollen. Import-Tags werden von dem Modul-Entwickler definiert und sind in den jeweiligen Dokumentationen zu den Modulen nachzulesen.
10. Subroutinen, die von Modulen importiert wurden, können wie reguläre Subroutinen aufgerufen werden. Verwenden Sie dazu den Namen der Subroutine mit Klammern um eventuelle Argumente.
11. In objektorientierten Modulen müssen Sie ein neues Objekt erzeugen, bevor Sie Subroutinen aufrufen können. Mit einem in einer Skalarvariablen gespeicherten Objekt, würden Sie dann eine Subroutine mit der Syntax `$var->sub()` aufrufen, wobei `$var` der Name der Variablen ist, die das Objekt enthält, und sub der Name der Subroutine. Subroutinen, die innerhalb von Objekten definiert sind, werden auch als Methoden bezeichnet.

### Lösungen zu den Übungen

1. Das Geheimnis liegt darin, richtige globale Variablen zu verwenden, die in dem Paket `main` gespeichert sind, und dann im Rumpf der Subroutine über den vollen Paketnamen darauf Bezug zu nehmen. Beachten Sie, dass dies mit globalen Variablen, die mit `my` definiert wurden, nicht funktioniert, da sie zu keinem Paket gehören.

           #!/usr/bin/perl -w

       $x = ":";               # Trennzeichen (global)
       print &auftrennen("defenestration"), "\n";

       sub auftrennen {
           my $string = $_[0];
           my $x = '';                 # neuer String (global);

           $x = join $main::x, (split //,$string);
           return $x;
       }

2. In dem Modulnamen steht nur ein Doppelpunkt. Module mit zwei Namen haben immer zwei Doppelpunkte.
3. Die Änderungen an umbrechen.pl bestehen lediglich darin, die Variable `$columns` zu modifizieren. Diese Variable wird nicht automatisch in Ihr Skript importiert. Das müssen Sie selbst übernehmen.

           #!/usr/bin/perl -w
       use strict;

       use Text::Wrap;                 # importiert Standardmodule
       use Text::Wrap qw($columns);    # importiert auch $columns
       $\ = "";                        # Absatzmodus
       my $indent = "> ";              # Einrückungszeichen

       print 'Geben Sie eine Spaltenbreite an: ';
       chomp($columns = <STDIN>);

       while (<>) {
           print wrap($indent, $indent, $_);
       }

4. Die Subroutine `myconfig()` übernimmt das für Sie. Da diese Subroutine nicht automatisch importiert wird, müssen Sie sie durch Angabe des vollen Paketnamens aufrufen (oder explizit importieren):

           #!/usr/bin/perl -w
       use strict;
       use Config;

       print Config::myconfig();

© Markt&Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH