# Perl - Module

### Packages

In einem Unterprogramm können mit Hilfe von `local` oder `my` lokale Variablen definiert werden, die dann nur einen entsprechend eingeschränkten Gültigkeitsbereich besitzen. Etwas ähnliches gilt auch für Variablen, die außerhalb von Subroutinen (im "Hauptprogramm") verwendet werden: Sie sind eigentlich nicht wirklich globale Variablen, sondern gelten nur innerhalb eines sogenannten Packages. Wird kein solches Package deklariert, nimmt Perl das Standardpackage "main" an.

Tritt bei der Programmausführung eine `package`-Anweisung auf, so gilt ab dort der Namensraum des entsprechenden Packages mit eigenen Variablen. Das heißt, jede Variable ist an ein bestimmtes Package gebunden. Wichtige Ausnahmen hiervon sind Variablen, die mit `my` deklariert werden, sowie spezielle Variablen wie `$_` oder `@ARGV`.

    #!/usr/local/bin/perl -w

    $v = 123;
    print $v."\n";          # (1)

    ### Ab hier gilt ein neuer Namensraum.
    package p;
    print $v."\n";          # (2)
    print $main::v."\n";    # (3)
    print $::v."\n";        # (4)
    $w = 456;
    print $w."\n";          # (5)
    print $p::w."\n";       # (6)

    ### Hier kehren wir wieder zu "main" zurück.
    package main;
    print $v."\n";          # (7)
    print $w."\n";          # (8)
    print $p::w."\n";       # (9)

Anmerkungen hierzu:

(1) | Gibt wie gewohnt den Inhalt von `$v` aus ("123").
(2) | Dies führt zu einer Fehlermeldung, da `$v` in "main" angelegt wurde, und daher im Package "p" nicht bekannt ist.
(3) | So kann über den Package-Namen auch in "p" auf `$v` zugegriffen werden.
(4) | Für main-Variablen kann der explizite Package-Name auch weggelassen werden.
(5) | Gibt den Inhalt der Variablen `$w` aus (zum Package "p" gehörend !).
(6) | Wie (5), nur mit Package-Namen
(7) | Da hier wieder der Namensraum von "main" gilt, gibt es diesmal keine Fehlermeldung (vgl. (2)).
(8) | Da `$w` in "p" angelegt wurde, darf sie nicht ohne weiteres in "main" verwendet werden, d.h., hier erfolgt eine Fehlermeldung.
(9) | So kann in "main" auf Variablen eines anderen Packages zugegriffen werden.

Die Zeilen (3), (4), (6) und (9) zeigen, wie man eine (skalare) Variable vollständig beschreibt:

> `$<Package-Name>::<Variablenname>`

Man beachte, daß das Dollarzeichen dabei ganz vorne steht (und nicht etwa unmittelbar vor dem Variablennamen).

Wie schon weiter oben erwähnt, sind `my`-Variablen nicht an ein Package gebunden, daher wird bei folgendem Beispiel keine Fehlermeldung ausgegeben:

    #!/usr/local/bin/perl -w

    my $v = 123;
    print $v."\n";

    package p;
    print $v."\n";

### Module

In Perl wird ein Package, das in einer eigenen Datei abgelegt wird, und üblicherweise von anderen Programmen mittels `use` eingebunden wird, als Modul bezeichnet. Dabei ist der Dateiname gleich dem Package-Namen, ergänzt um die Endung "`.pm`".

Ein Modul in der Datei `hallo.pm` könnte beispielweise so aussehen:

    package hallo;

    sub sag_hallo {
        print "Hallo, Welt!\n";
    }

    1;

Es kann dann in einem Perl-Programm so verwendet werden:

    #!/usr/local/bin/perl -w

    use hallo;

    &hallo::sag_hallo();

    Hallo, Welt!

Da die Subroutine `sag_hallo` in einem eigenen Package definiert wird (nämlich "hallo"), muß beim Aufruf des Unterprogramms auch der Package-Name mit angegeben werden.

### Exportieren von Namen

Damit beim Einbinden eines Moduls nicht bei jedem Funktionsaufruf der Package-Name mit angegeben werden muß, kann man Namen (skalare Variablen, Arrays, Subroutinen,...) aus einem Modul heraus exportieren. Jene Variablen werden dann beim Aufruf von `use` ins Hauptprogramm importiert, d.h., sie können dann dort so verwendet werden, als wären sie im Hauptprogramm deklariert worden.

Dazu gibt es ein Modul namens "Exporter", das diese Aufgabe übernimmt. Es definiert zum einen einige Arrays, die dem Exportieren von Namen dienen. Die beiden wichtigsten sind `@EXPORT` und `@EXPORT_OK`. Außerdem wird die bei der Beschreibung von `use` erwähnte Routine `import` definiert. Da sich die Routine `import` nicht im Modul selbst befindet (sondern in "Exporter"), muß man den Perl-Interpreter durch das `@ISA`-Array darauf hinweisen:

> `@ISA = ( 'Exporter' );`

Alle Namen in `@EXPORT` werden automatisch in das aufrufende Programm exportiert, während diejenigen Namen, die in `@EXPORT_OK` stehen, nur auf Verlangen exportiert werden. Namen, die sich nicht in einem der beiden genannten Arrays befinden, können nur zusammen mit dem Package-Namen verwendet werden.

Beispiel eines Moduls in der Datei `modul.pm`:

    package modul;

    use Exporter;
    @ISA = ('Exporter');

    @EXPORT = ( 'routine_1' );
    @EXPORT_OK = ( 'routine_2' );

    sub routine_1 { print "Routine Nr.1\n" }
    sub routine_2 { print "Routine Nr.2\n" }
    sub routine_3 { print "Routine Nr.3\n" }

    1;

So werden nur die Namen aus `@EXPORT` importiert, alle anderen benötigen den Package-Namen:

    #!/usr/local/bin/perl -w

    use modul;

    routine_1();
    &modul::routine_2();
    &modul::routine_3();

Hier werden die Namen aus `@EXPORT_OK` explizit importiert:

    #!/usr/local/bin/perl -w

    use modul 'routine_2';

    &modul::routine_1();
    routine_2();
    &modul::routine_3();

So importiert man beide exportierten Funktionen, `routine_3` kann allerdings nicht importiert werden:

    #!/usr/local/bin/perl -w

    use modul 'routine_1','routine_2';

    routine_1();
    routine_2();
    &modul::routine_3();

Weitere Informationen enthält die Manual Page von "Exporter", die beispielsweise durch "`perldoc Exporter`" ausgegeben wird.

### Standardmodule

Bei der Perl-Distribution wird schon eine Reihe von Modulen mitgeliefert, wie beispielsweise das oben erwähnte Modul "Exporter". Um herauszufinden, welche Module wo installiert sind, betrachte man das Array `@INC`, das eine Liste von Pfaden enthält, in denen Perl bei Bedarf nach Modulen sucht.

    #!/usr/local/bin/perl -w

    foreach $pfad ( @INC ) {
        print "$pfad\n";
    }

Die Dokumentation eines Moduls erhält man (zumindest bei einem gut geschriebenen Modul) durch den Aufruf von "`perldoc`" mit dem Namen der Moduldatei als Argument oder (unter MacOS) durch Öffnen der Moduldatei mit Hilfe des Programms "`Shuck`".

Es lohnt sich auf jeden Fall, einen Blick in die Bibliothek der Standardmodule zu werfen, da sie viele Funktionen bereitstellen, die oft benötigt werden, wie das Lesen von Kommandozeilenoptionen, das Arbeiten mit Dateibäumen, das Kopieren von Dateien und vieles mehr.

Eine große Sammlung weiterer Module für die verschiedensten Aufgaben findet sich im Comprehensive Perl Archive Network (CPAN).

Autor: Eike Grote | Letzte Änderung: 03.11.2004