Module

Packages
Module
Exportieren von Namen
Standardmodule

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";

[Seitenanfang]

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". Wie schon bereits beim Einbinden von Perl-Code beschrieben, muß der Rückgabewert beim Importieren von Code aus einem Modul wahr sein, daher die Zeile "1;" am Ende.

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 strict;
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.

[Seitenanfang]

Exportieren von Namen

Damit beim Einbinden eines Moduls nicht bei jedem Aufruf einer Funktion 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' );

Genauer gesagt wird damit das aktuelle Modul wie eine von Exporter abgeleitete Klasse im Sinne objektorientierter Programmierung betrachtet, worauf hier aber nicht weiter eingegangen werden soll.

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 strict;
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 strict;
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 strict;
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.

[Seitenanfang]

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

use strict;

foreach my $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.

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).

[Seitenanfang]

Autor: Eike Grote

Version: 2.07 (27.10.2019)

(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.