| ## Standardmodule von Perl
| Allgemeines zu Standardmodulen Module mit allgemeinen Aufgaben Module für Textverarbeitung Module für Berechnungen Module für Dateiverwaltung Module für Ein-/Ausgabe Module für Datum und Zeit Module für Datenbankzugriffe Module für Prozesskommunikation Module für Variablenbindung Module für Modulverwaltung und für objektorientierte Programmierung Module für CGI-Scripts Module für Internetfunktionen Module zum Verwalten von Perl-Erweiterungen Module zum Steuern des Perl-Compilers Systemnahe Module Pragma-Module zum Beeinflussen des Perl-Interpreters

## Allgemeines zu Standardmodulen

Standardmodule sind Module, die zusammen mit dem Perl-Interpreter ausgeliefert werden. Dadurch haben solche Module einen sehr hohen Verbreitungsgrad und sind überall verfügbar, wo der Perl-Interpreter vollständig installiert ist. Bei neuen Versionen des Perl-Interpreters können jedoch auch neue Standardmodule mit ausgeliefert werden. Module, die erst seit der neuesten Interpreterversion mit ausgeliefert werden, stehen bei Installationen älterer Perlversionen also nicht automatisch zur Verfügung.

Einige der ausgelieferten Module haben nicht die heute übliche Dateiendung .pm, sondern noch die Endung .pl. Dies sind ältere Module, die schon vor der Version 5 des Perl-Interpreters existierten.

Bei einer typischen Installation des Perl-Interpreters werden die Standardmodule unterhalb des Installationsverzeichnisses im Verzeichnis lib und dessen Unterverzeichnissen abgelegt.

Die folgenden Tabellen listen Standardmodule nach Bedeutung kategorisiert auf. In der jeweils linken Spalte steht das Modul, wie es z.B. mit use eingebunden werden kann. In der mittleren Spalte steht eine kurze Bedeutung. Weitere Einzelheiten zum jeweiligen Modul erfahren Sie, wenn Sie die jeweilige Moduldokumentationen mit perldoc lesen.

Die Tabellen erheben keinen Anspruch auf Vollständigkeit!

### Beachten Sie:

Die Mehrzahl der Modulnamen beginnt mit einem Großbuchstaben. Es hat sich eingebürgert, Module auf diese Weise zu benennen. Die Unterscheidung von Groß- und Kleinschreibung beim Einbinden ist wichtig!

## Module mit allgemeinen Aufgaben

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Benchmark` | Misst die Ausführungszeit für Perlcodes und testet den Code in Wiederholungsschleifen.
`Carp` | Stellt Funktionen zur Fehlerbehandlung bereit.
`CPAN` | Lädt und installiert Module aus dem CPAN-Verzeichnis bei Bedarf.
`CPAN::Nox` | Ergänzung zu `CPAN`: verhindert, dass vorkompilierte Erweiterungen ausgeführt werden.
`CPAN::FirstTime` | Ergänzung zu `CPAN`: unterstützt bei den Initialisierungseinstellungen zum Benutzen des CPAN-Moduls.
`Config` | Erlaubt den Zugriff auf die einzelnen Konfigurationsdaten von Perl.
`English` | Definiert Klartextnamen für die vordefinierten Variablen von Perl und macht Quellcode dadurch lesbarer.
`Env` | Importiert Umgebungsvariablen mit einzelnen Namen und macht dadurch die Verwendung des vordefinierten Hashes `%ENV` überflüssig.
`Fatal` | Bewirkt, dass Funktionen, die als Rückgabewert `false` liefern, mit der die-Funktion auf `STDERR` schreiben und das laufende Script beenden.
`Getopt::Long` | Ermöglicht die Interpretation von Kommandozeilenoptionen für das Script mit mehreren Zeichen.
`Getopt::Std` | Ermöglicht die Interpretation von Kommandozeilenoptionen für das Script mit einem Zeichen.
`I18N::Collate` | Passt skalare Daten mit 8 Bit Zeichenbreite an das verwendete System an (nur im Zusammenhang mit Perl-Versionen unter 5.003_06 interessant, da seitdem im Perl-Interpreter direkt implementiert).
`POSIX` | Stellt eine Bibliothek an Funktionen für alle möglichen Zwecke bereit. Maßgeblich dabei ist der IEEE-Standard 1003.1. Viele aus C bekannten Funktionen, die dem IEEE-Standard entsprechen, finden sich in diesem Modul wieder, z.B. für Zeichenkettenverarbeitung oder Signal-Handling unter Unix.
`Shell` | Erlaubt es, die Standardausgabe von Shell-Kommandos abzufangen und in einer Variablen zu speichern, z.B. zur Weiterverarbeitung oder zum formatierten Ausgeben, etwa in HTML-Code an den Browser.
`Symbol` | Generiert symbolische Namen und erlaubt dadurch, zur Laufzeit Dateihandles usw. zu erzeugen.
`Sys::Syslog` | Ermöglicht den Zugriff auf Aufrufe des Unix-Programms `syslog(3).`

## Module für Textverarbeitung

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Pod::Html` | Generiert aus dem POD-Format HTML-Code inklusive Querverweisen (POD ist das Klartextformat, in dem die Perl-Dokumentation geschrieben ist, das z.B. auch für die interne Moduldokumentation verwendet wird und das mit perldoc lesbar ist - also das Format mit den "`=`Kommandos").
`Pod::Text` | Generiert aus dem POD-Format reinen Text ohne Steuerbefehle.
`Search::Dict` | Durchsucht ein Wörterbuch nach einem Wort und gibt die Dateiposition oder `-1` zurück, je nachdem, ob das Wort gefunden wurde oder nicht.
`Term::Cap` | Ermöglicht den Zugriff auf termcap (Unix).
`Term::Complete` | Vervollständigt Worteingaben bei Prompt-Aufforderungen automatisch.
`Term::ReadLine` | Stellt eine Schnittstelle für diverse andere Packages aus der ReadLine-Reihe dar.
`Text::Abbrev` | Erzeugt aus einer Liste von Begriffen eine Abkürzungstabelle.
`Text::ParseWords` | Zerlegt einen Text in die einzelnen Wörter und speichert diese in einer Liste. Wörter in Anführungszeichen gelten dabei als ein zusammenhängender Ausdruck.
`Text::Soundex` | Erzeugt für ein Wort den Soundex-Code entsprechend dem Soundex-Algorithmus von Knuth. Dieser Code ist ein Schema für die Erzeugung von computergesprochenem Englisch.
`Text::Tabs` | Kann in einem Text Tabulatoren durch eine feste Anzahl Leerzeichen ersetzen oder umgekehrt mehrere Leerzeichen zu einem Tabulatorzeichen zusammenfassen.
`Text::Wrap` | Bricht Text automatisch um entsprechend einer zu definierenden Vorgabe, bei welcher Zeichenspalte umgebrochen werden soll.

## Module für Berechnungen

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Math::BigFloat` | Erlaubt das Rechnen mit Fließkommazahlen, die größer oder kleiner sind als das, was Perl normalerweise als Fließkommazahl zu interpretieren in der Lage ist.
`Math::BigInt` | Erlaubt das Rechnen mit Ganzzahlen, die größer sind als das, was Perl normalerweise als Ganzzahl zu interpretieren in der Lage ist.
`Math::Complex` | Unterstützt das Rechnen mit komplexen Zahlen, wie sie etwa zum Lösen mancher Gleichungen erforderlich sind.
`Math::Trig` | Stellt die in Perl selber fehlenden trigonometrischen Funktionen für Tangens, Arcus Cosinus, Arcus Sinus sowie Berechnungen mit der Konstanten Pi bereit.

## Module für Dateiverwaltung

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Cwd` | Ermittelt das aktuelle Arbeitsverzeichnis
`DirHandle` | Bietet eine objektorientierte Alternative zu den Funktionen opendir, readdir und closedir an.
`File::Basename` | Zerlegt eine Dateiangabe mit Pfad in den Pfadnamen und den Dateinamen.
`File::CheckTree` | Kann mehrere Dateien oder Verzeichnisse auf Existenz überprüfen.
`File::Compare` | Vergleicht zwei Dateien und überprüft, ob sie inhaltlich identisch sind.
`File::Copy` | Ermöglicht das Kopieren von Dateien und gilt als wichtiges Tool, um Dateien mit Perl betriebssystemunabhängig kopieren zu können.
`File::DosGlob` | Erzeugt von einem Verzeichnis eine Dateiliste und erlaubt dabei die Angabe DOS-typischer Wildcards wie `*.exe`.
`File::Find` | Durchsucht Verzeichnisbäume nach Dateien.
`File::Path` | Legt mehrere Verzeichnisse auf einmal neu an oder löscht mehrere Verzeichnisse, je nach Wunsch mitsamt allen darin enthaltenen Dateien.
`File::Spec` | Stellt Methoden bereit, um mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten. Da diese betriebssystemspezifisch sind, gibt es für diverse wichtige Betriebssysteme entsprechende Untermodule.
`File::Spec::Mac` | Stellt Methoden bereit, um auf dem Betriebssystem Macintosh mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::Spec::OS2` | Stellt Methoden bereit, um auf dem Betriebssystem OS/2 mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::Spec::Unix` | Stellt Methoden bereit, um auf Unix-Derivaten mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::Spec::VMS` | Stellt Methoden bereit, um auf dem Betriebssystem VMS mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::Spec::Win32` | Stellt Methoden bereit, um auf Windows-Betriebssystemen (ab Windows 95) mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::stat` | Ruft einfach die Perl-Funktion stat auf.
`FileCache` | Erlaubt es, mehr Dateien gleichzeitig geöffnet zu halten als das Betriebssystem erlaubt.
`FileHandle` | Ermöglicht das Arbeiten mit objektorientierten Handles für Dateien und stellt alle wichtigen Funktionen zum Lesen und Schreiben von Dateien und zum Positionieren des Dateizeigers bereit.
`FindBin` | Liefert das Verzeichnis, in dem sich das Perl-Script befindet.
`SelectSaver` | Sichert Handles für Dateien und erlaubt es, gesicherte Handles später wiederzuverwenden.

## Module für Ein-/Ausgabe

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`IO` | lädt die untergeordneten `IO`-Module.
`IO::File` | Ermöglicht das Arbeiten mit objektorientierten Ein-/Ausgabe-Handles. Erbt dabei Objekte von `IO::Handle` und `IO::Seekable`.
`IO::Handle` | Basisklasse für objektorientierte Ein-/Ausgabe-Handles, die z.B. von `IO::File` verwendet werden.
`IO::Pipe` | Ermöglicht es, mit Hilfe objektorientierter Methoden Pipes zwischen Prozessen (Umlenkung der Ausgabe eines Prozesses in die Eingabe eines nachfolgenden Prozesses) zu erzeugen.
`IO::Seekable` | Stellt objektorientierte Frontends für die Perl-Funktionen seek und tell bereit.
`IO::Select` | Bietet eine objektorientierte Verwaltung von Ein-/Ausgabe-Handles an und enthält Funktionen zum Erzeugen, Löschen und Überprüfen von Handles.
`IO::Socket` | Bietet eine objektorientierte Verwaltung von Ein-/Ausgabe-Sockets für Prozesskommunikation über ein Netzwerk, bevorzugt TCP/IP, an und enthält Funktionen zum Erzeugen, Löschen und Abfragen der Sockets.

## Module für Datum und Zeit

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Time::Local` | Stellt Umkehrfunktionen für die Perl-Funktionen gmtime und localtime zur Verfügung.
`Time::gmtime` | Überschreibt die Perl-Funktion gmtime.
`Time::localtime` | Überschreibt die Perl-Funktion localtime.

## Module für Datenbankzugriffe

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`AnyDBM_File` | Basismodul für die übrigen Module dieser Abteilung.
`DB_File` | Erlaubt den Zugriff auf Datenbankdateien von Berkeley DB version 1.x.
`GDBM_File` | Erlaubt den Zugriff auf GDBM-Dateien über die `tie`-Funktion, die eine Variable an eine Objektklasse bindet.
`NDBM_File` | Erlaubt den Zugriff auf NDBM-Dateien über die `tie`-Funktion, die eine Variable an eine Objektklasse bindet.
`ODBM_File` | Erlaubt den Zugriff auf ODBM-Dateien über die `tie`-Funktion, die eine Variable an eine Objektklasse bindet.
`SDBM_File` | Erlaubt den Zugriff auf SDBM-Dateien über die `tie`-Funktion, die eine Variable an eine Objektklasse bindet.

## Module für Prozesskommunikation

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`IPC::Msg` | Ermöglicht es, Nachrichtenwarteschlangen (Message Queues) und zugehörigen Nachrichten für Unix-System V zu stellen.
`IPC::Open2` | Öffnet einen Unix-Prozess zum Lesen und Schreiben.
`IPC::Open3` | Öffnet einen Unix-Prozess zum Lesen, Schreiben und für Fehlerbehandlung.
`IPC::Semaphore` | Ermöglicht es, die Semaphore-Funktion von Unix-System V zu nutzen.
`IPC::SysV` | Stellt IPC-Konstanten von Unix-System V bereit.
`Thread` | Ermöglicht das Arbeiten mit Multithreading (Teile eines Scripts werden separat in eigenen "Threads" ausgeführt, während die "normale" Ausführung des Scripts weiterläuft.)
`Thread::Queue` | Stellt eine Warteschlange in Form einer Liste bereit, die Threads erlaubt, Variablen hinzuzufügen oder zu entfernen.
`Thread::Semaphore` | Ermöglicht die Anwendung der Semaphore-Technik zwischen Threads.
`Thread::Signal` | Startet einen speziellen Signal-Handler-Thread, an den für den laufenden Prozess ankommende Signale weitergeleitet werden, so dass ein Script, das durch Multithreading stark beschäftigt ist, Signale in einem Zwischenspeicher halten kann, bis eine Abarbeitung möglich ist.
`Thread::Specific` | Generiert für einen Thread einen eindeutigen Schlüssel.

## Module für Variablenbindung

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Tie::Array` | Bindet eine Liste an eine Objektklasse.
`Tie::Handle` | Bindet ein Handle an eine Objektklasse.
`Tie::Hash` | Bindet einen Hash an eine Objektklasse
`Tie::RefHash` | Ermöglicht Referenzen als Schlüssel für Hashes.
`Tie::Scalar` | Bindet einen Skalar an eine Objektklasse.
`Tie::SubstrHash` | Ermöglicht einen Hash-artigen Zugriff auf eine Liste fester Länge.

## Module für Modulverwaltung und objektorientierte Programmierung

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Class::Struct` | Erzeugt Datenstrukturen nach dem Vorbild von `struct` in C.
`Exporter` | Ermöglicht Modulen, genau festzulegen, welche Variablen und Funktionen in den Namensraum eines es einbindenden Scripts importiert werden.
`UNIVERSAL` | Stellt die Basis-Objektklasse für objektorientiertes Programmieren in Perl dar. Erlaubt das Überprüfen von Referenzen und Methoden bei beliebigen Objekten.

## Module für CGI-Scripts

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`CGI` | Kann Formulardaten parsen und ermöglicht dadurch die bequeme Weiterverarbeitung von Formulardaten. Stellt außerdem verschiedene Mittel bereit, um HTML-Ausgaben an den Browser zu senden.
`CGI::Apache` | Variante des `CGI`-Moduls, die speziell für den Einsatz unter dem Apache Webserver optimiert war. Das Modul ist inzwischen veraltet.
`CGI::Carp` | Ermöglicht es, auftretende Fehler und Laufzeitprobleme auch an die Standardausgabe und damit an den auf Ausgabe wartenden Browser zu senden.
`CGI::Cookie` | Erlaubt das Setzen und Auslesen von Netscape- bzw. HTTP1.1-kompatiblen Cookies auf dem Rechner des Anwenders. Mit Hilfe von Cookies lassen sich Informationen auf dem Anwenderrechner speichern, die beim nächsten Aufruf wieder ausgelesen werden können (Stichwort "mitdenkende Webseiten").
`CGI::Fast` | Schnittstelle zum Fast-CGI-Standard, durch den CGI-Scripts deutlich schneller werden, weil sie als Prozesse dauerhaft im Arbeitsspeicher des Serverrechners gehalten werden.
`CGI::Push` | Schnittstelle zum Server-Push, also dem Senden von Inhalten an den Browser ohne dessen explizite Anfrage. Webseiten können auf diese Weise in bestimmten Zeitintervallen automatisch neu gesendet werden, was bei schnell wechselnden Inhalten sinnvoll ist.
`CGI::Switch` | Probiert selbstständig, ein neues CGI-Objekt anzulegen, und zwar wenn möglich mit `CGI::Apache`, ansonsten mit dem normalen `CGI`-Modul. Das Modul ist inzwischen veraltet.

## Module für Internetfunktionen

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Net::Ping` | Überprüft die Erreichbarkeit eines Hostrechners im Internet mit der dafür üblichen Ping-Funktion.
`Net::hostent` | Ersetzt die Perl-Funktionen gethostbyaddr und gethostbyname durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei netdb.h ähnelt.
`Net::netent` | Ersetzt die Perl-Funktionen getnetent und getnetbyname durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei netdb.h ähnelt.
`Net::protoent` | Ersetzt die Perl-Funktionen getprotoent und getprotobyname durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei netdb.h ähnelt.
`Net::servent` | Ersetzt die Perl-Funktionen getservent und getservbyname durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei netdb.h ähnelt.
`Socket` | Stellt eine Übersetzung der C-Header-Datei socket.h dar und kann Hostnamen, Protnummern usw. ermitteln.
`Sys::Hostname` | Ermittelt den Hostnamen des Rechners, auf dem das Script läuft.
`User::grent` | Ersetzt die Perl-Funktionen getgrent, getgrgid und getgrnam durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei grp.h ähnelt.
`User::pwent` | Ersetzt die Perl-Funktionen getpwent, getpwuid und getpwnam durch ein Objekt. Das Objekt stellt eine Datenstruktur für den Zugriff auf die Konfigurationsdaten zur Verfügung, die der von C aus dessen Headerdatei pwd.h ähnelt.

## Module zum Verwalten von Perl-Erweiterungen

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`AutoLoader` | Lädt Unterprogramme nur wenn erforderlich. Dazu ist die Verwendung von `__END__` erforderlich.
`AutoSplit` | Splittet eine Scriptdatei in mehrere Einzeldateien auf und ermöglicht auf diese Weise, dass das Modul `AutoLoader` Unterprogramme nur bei Aufruf lädt.
`Devel::SelfStubber` | Regelt Aufrufe von Objektmethoden in einer objektorientierten Hierarchie, die sich über mehrere Module erstreckt.
`DynaLoader` | Lädt dynamisch Routinen aus den C-Bibliotheken in das laufende Perl-Script.
`ExtUtils::Command` | Ersetzt Unix-Kommandos in Makefiles, beispielsweise für eine Win32-Portierung.
`ExtUtils::Embed` | Erlaubt das Einbinden von Aufrufen des Perl-Interpreters in C/C++ Programmen.
`ExtUtils::Install` | Installiert Dateien von einem Installationsverzeichnis ins Zielverzeichnis.
`ExtUtils::Installed` | Findet heraus, welche Module bereits installiert sind. Sinnvoll beispielsweise, um bei Bedarf nicht installierte Module dynamisch nachzuinstallieren.
`ExtUtils::Liblist` | Liefert eine Liste zu verwendender Erweiterungsbibliotheken.
`ExtUtils::MM_OS2` | Wird von `ExtUtils::MakeMaker` verwendet, um Einträge in der Datei Makefile.pl nach den Regeln von OS/2 zu erzeugen.
`ExtUtils::MM_Unix` | Wird von `ExtUtils::MakeMaker` verwendet, um Einträge in der Datei Makefile.pl nach den Regeln von Unix zu erzeugen.
`ExtUtils::MM_VMS` | Wird von `ExtUtils::MakeMaker` verwendet, um Einträge in der Datei Makefile.pl nach den Regeln von VMS zu erzeugen.
`ExtUtils::MM_Win32` | Wird von `ExtUtils::MakeMaker` verwendet, um Einträge in der Datei Makefile.pl nach den Regeln von Windows (ab Windows 95) zu erzeugen.
`ExtUtils::MakeMaker` | Erzeugt ein Makefile namens Makefile.pl, das die Installation von Dateien erlaubt.
`ExtUtils::Manifest` | Stellt Funktionen bereit, um eine Manifest-Datei zu erzeugen und zu überprüfen. In die Manifest-Datei werden alle Dateien eines Verzeichnisbaums unterhalb des aktuellen Verzeichnisses in eine Datei geschrieben. Auf diese Weise lässt sich der Originalzustand eines Verzeichnisbaums sichern, bevor z.B. eine Installationsroutine daraus Dateien kopiert, löscht usw.
`ExtUtils::Miniperl` | Schreibt den C-Code für die Datei perlmain.c, aus der sich der Perl-Interpreter neu linken lässt. Dabei lassen sich Module angeben, die mit gelinkt werden sollen. Auf diese Weise können also Module zu eingebauten Features einer eigenen Variante des Perl-Interpreters werden!
`ExtUtils::Mkbootstrap` | Erzeugt eine so genannte Bootstrap-Datei, die vom Modul `DynaLoader` verwendet wird.
`ExtUtils::Mksymlists` | Erzeugt Hilfsdateien, die bei manchen Betriebssystemen benötigt werden, um Bibliotheken zu linken.
`ExtUtils::Packlist` | Liest und schreibt .packlist-Dateien, die Informationen über zu installierende Pfade, Dateien usw. enthalten.
`ExtUtils::testlib` | Stellt Funktionen bereit, um eine Erweiterungsbibliothek zu testen, bevor sie installiert wird.
`SelfLoader` | Bewirkt, dass Unterprogramme, die in einem Script nach `__DATA__` notiert sind, bei Bedarf compiliert und ausgeführt werden.

## Module zum Steuern des Perl-Compilers

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`B` | Stellt die Basisklassen des Perl-Compilers zur Verfügung. Mit Hilfe des Perl-Compilers lässt sich der Code eines Perl-Scripts in C-Code übersetzen, der dann mit einem C-Compiler zu einer für das Betriebssystem ausführbaren Datei kompiliert und gelinkt werden kann. Das `B`-Modul stellt einem Perl-Script die Funktionalität des Perl-Compilers zur Verfügung. Das Perl-Script kann auf diese Weise den Perl-Compiler steuern.
`B::Asmdata` | Erzeugt automatisch generierte Datenstrukturen für Bytecode.
`B::Assembler` | Assembliert Bytecode.
`B::Bblock` | Durchläuft die Grundblöcke eines Scripts.
`B::Bytecode` | Schnittstelle zum perl-internen Bytecode eines Scripts.
`B::C` | Schnittstelle zum C-Backend des Perl-Compilers.
`B::CC` | Optimierte Schnittstelle zum C-Backend des Perl-Compilers.
`B::Debug` | Durchläuft den Code des Perl-Scripts und zeigt Debug-Informationen an.
`B::Deparse` | Disassembliert den Perl-Bytecode.
`B::Disassembler` | Stellt den Perl-Code eines Perl-Scripts aus Byte-Code wieder her.
`B::Lint` | Benutzt beim Kompilieren die Warnstufe, die bei Perl durch den Aufruf des Perl-Interpreters mit der Option `-w` erreicht wird.
`B::Showlex` | Zeigt die Namen von lexikalischen Variablen in Dateien und Funktionen an.
`B::Stackobj` | Hilfsmodul für `B::CC`.
`B::Terse` | Parst ein Perl-Script und zeigt dabei nur wenige Informationen an.
`B::Xref` | Erzeugt eine Liste aller Kreuzreferenzen und Abhängigkeiten in einem Perl-Script.

## Systemnahe Module

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Errno` | Importiert die Konstanten aus der Systemdatei errno.h für die Fehlerbehandlung.
`Fcntl` | Stellt eine Übersetzung der C-Headerdatei Fcntl.h dar und importiert daraus alle Definitionen. Diese Definitionen unterstützen beim Öffnen von Dateien.
`Opcode` | Beeinflusst die Perl-interne Kompilation eines Scripts, bevor es ausgeführt wird. Wird in Zusammenhang mit dem Modul `Safe` verwendet.
`Safe` | Erzeugt geschützte Bereiche mit eigenen Namensräumen, um Perl-Code darin auszuführen.
`Test` | Stellt Test-Typen und Fehlerreaktionen zum Austesten von Perl-Scripts bereit.
`Test::Harness` | Führt standardisierte Tests durch und gibt die Ergebnisse aus.

## Pragma-Module zum Beeinflussen des Perl-Interpreters

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`attrs` | Setzt und ermittelt Attribute eines Unterprogramms. Dieses Pragma ist veraltet.
`autouse` | Parst Perl-Code aus eingebundenen Modulen erst dann, wenn Funktionen des Moduls aufgerufen werden. Ein Perl-Script kann dadurch schneller starten, verliert die gewonnene Zeit aber gegebenenfalls während der Ausführung wieder.
`base` | Definiert Basisklassen für die aktuelle Klasse.
`blib` | Durchsucht nicht installierte Module. Gedacht für die Verwendung im Zusammenhang mit der Option `-M` beim Aufruf des Perl-Compilers.
`constant` | Deklariert unveränderliche Konstanten, ähnlich, wie es in C mit `#define` möglich ist.
`diagnostics` | Gibt bei Fehlermeldungen, die der Perl-Compiler ausgibt, zugleich deren Erläuterungen mit aus. Dazu werden die Beschreibungen aus perldiag verwendet.
`fields` | Stellt sicher, dass der vordefinierte Hash `%FIELDS` zur Kompilierzeit versorgt ist.
`integer` | Bewirkt, dass der Perl-Interpreter bei Rechenoperationen nur mit Ganzzahlen rechnet. Eine Operation wie `10/3` ergibt dann `3` ohne Nachkommastellen.
`lib` | Ermöglicht das Erweitern der vordefinierten Liste @INC, bevor das Script ausgeführt wird. Auf diese Weise lassen sich Pfade zu eigenen Modulen in den Suchpfad `@INC` mit aufnehmen, die vom Script benötigt werden, sich aber nicht in den vordefinierten Suchpfaden befinden.
`locale` | Schaltet die Verwendung von lokalen Einstellungen, wie sie in `POSIX` definiert sind, ein oder aus. Solche lokalen Einstellungen betreffen z.B. zu verwendende Zeichensatzkonventionen bei Zeichenkettenvergleichen.
`ops` | Schränkt die Ausführung unsicherer Operationen in einem Perl-Script ein, sofern der Perl-Interpreter zum Ausführen des Scripts mit der Option `-M` aufgerufen wird.
`overload` | Ermöglicht es, Operatoren in Perl-Scripts mit eigenen Funktionen zu verknüpfen. So ist es beispielsweise möglich, eigene Funktionen für Operatoren wie "Division" oder "größer als" zu schreiben und die Funktionalität der entsprechenden Operatoren wie `/` (Division) oder `>` (größer als) an die selbst geschriebenen Funktionen zu knüpfen.
`re` | Beeinflusst die Interpretation regulärer Ausdrücke für spezielle Zwecke wie das Behandeln von Variablen innerhalb des regulären Ausdrucks.
`sigtrap` | Ermöglicht einem Perl-Script, auf Signale zu reagieren, die es von anderen Prozessen erhält.
`strict` | Verhindert, dass unsauberer Code ausgeführt wird. Toleranzen, die der Perl-Interpreter ansonsten erlaubt, werden dadurch ausgeschaltet.
`subs` | Ermöglicht das Vorabdeklarieren der Namen aller verwendeten Subroutinen. Im weiteren Code des Scripts können die Namen dann sofort ohne Klammern verwendet werden, also z.B. `Speichern` statt `Speichern()`.
`vars` | Ermöglicht das Vorabdeklarieren der Namen von globalen Variablen.

| CPAN-Module
| Einführung in das Arbeiten mit Modulen

© 2001 selfhtml@teamone.de