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,
my und Subroutinen,
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.
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.
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.
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:
main.
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.
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.
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 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 undlocal-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.
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.
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 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:
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.
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.
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
carpundcroakauch insofern den Funktionenwarnunddie, als sie zur Ausgabe von Fehlermeldungen verwendet werden (und im Falle vondieundcroakdanach die Ausführung abbrechen). DieCarp-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 voncarpenthält, wirdcarpdas 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). AufCarpgehe 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:
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.
->-
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.
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:
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
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.
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«.
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.
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 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.
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:
Text::Wrap importiert.
> », es können jedoch
auch beliebige andere Einrückungszeichen sein).
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
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.
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.
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.
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.
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.
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 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).
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.
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.
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.
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.
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.
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:
my, und verwenden Sie use strict, um sicherzustellen, dass alles
seine Ordnung hat.
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.
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
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
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.
my mit globalen Variablen verwenden? Warum sollten Sie das
machen?
use strict? Warum sollten Sie diesen Befehl verwenden?
@INC-Array benötigt?
use strict oder globale
my-Variablen.
use Dies:Das; # importiert Module
while (<>) {
print dasandere($_);
}
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.
Hier die Antworten auf die Workshop-Fragen aus dem vorigen Abschnitt.
$ 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().
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.
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.
http://www.perl.com/CPAN/.
@INC-Array definiert die Verzeichnisse, in denen Perl nach den Modulen und
dem Code schaut, der in Ihre Skripts mit use importiert werden soll.
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.
$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.
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;
}
$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, $_);
}
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();