# Standardmodule von Perl

Allgemeines zu Standardmodulen
Module mit allgemeinen Aufgaben
Module für Textverarbeitung
Module für Sprachen und Zeichenkodierungen
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 für POD-Dokumente
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 Perl-Versionen 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 Moduldokumentation mit perldoc lesen.

Die Tabellen erheben keinen Anspruch auf Vollständigkeit! Module, die nur intern von anderen Modulen verwendet werden oder noch keinen Zweck haben, wurden absichtlich ausgelassen. Eine vollständige Liste der Perl-Standardmodule erhalten Sie, wenn Sie mit `perldoc` das Dokument `perlmodlib` aufrufen.

### 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
--- | ---
`Attribute::Handlers` | Ermöglicht das Definieren von Handlern für die Parameter von Subroutinen.
`Benchmark` | Misst die Ausführungszeit für Perl-Codes 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::FirstTime` | Ergänzung zu `CPAN`: unterstützt bei den Initialisierungseinstellungen zum Benutzen des CPAN-Moduls.
`CPAN::Nox` | Ergänzung zu `CPAN`: verhindert, dass vorkompilierte Erweiterungen ausgeführt werden.
`Config` | Erlaubt den Zugriff auf die einzelnen Konfigurationsdaten von Perl.
`Data::Dumper` | Stellt die interne Struktur von Variablen dar.
`DB` | Ermöglicht den Zugriff auf die Debug-API von Perl.
`Devel::DProf` | Misst die Ausführungszeit eines Perl-Scripts und der einzelnen enthaltenen Subroutinen.
`Devel::PPPort` | Stellt einige Features der Perl-API aus neuen Versionen des Perl-Interpreters für ältere Perl-Versionen bereit.
`Digest` | Stellt die Routinen der Module der `Digest`-Familie bereit.
`Digest::MD5` | Erlaubt es, MD5-Prüfsummen zu berechnen.
`Dumpvalue` | Stellt Perl-Daten dar. Beispielsweise lässt sich mit diesem Modul der komplette Inhalt eines Namensraums darstellen.
`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.
`Filter::Simple` | Einfache Variante von `Filter::Util::Call`.
`Filter::Util::Call` | Erlaubt das Definieren sog. "Source-Filter", einer Art Mini-Interpreter, der den Quellcode des Scripts zur Laufzeit verändern kann, bevor er vom Interpreter verarbeitet wird. Auf diese Weise lassen sich beispielsweise eigene Sprach-Konstrukte realisieren (wie beim Standardmodul `Switch`, das auf `Filter::Util::Call` basiert).
`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.
`Hash::Util` | Enthält verschiedene Funktionen zum Arbeiten mit Hashes.
`List::Util` | Enthält verschiedene Funktionen zum Arbeiten mit Listen.
`Memoize` | Versucht, Subroutinen zu beschleunigen, indem es die Rückgabewerte speichert.
`Memoize::Expire` | Plugin für das `Memoize`-Modul, das dafür sorgt, dass die gespeicherten Rückgabewerte irgendwann ungültig werden und neu ausgelesen werden müssen.
`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 bekannte Funktionen, die dem IEEE-Standard entsprechen, finden sich in diesem Modul wieder, z.B. für Zeichenkettenverarbeitung oder Signal-Handling unter Unix.
`Scalar::Util` | Enthält verschiedene Funktionen zum Arbeiten mit Skalaren.
`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.
`Storable` | Erlaubt es, Perl-Datenstrukturen auf der Festplatte zu speichern und später wieder zu laden.
`Switch` | Erlaubt es, die aus anderen Programmiersprachen bekannten `switch`-Anweisungen in Perl zu benutzen.
`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`.
`Unicode::Collate` | Klasse zum Arbeiten mit Unicode-Strings.
`Unicode::Normalize` | Funktionen, um Unicode zu normalisieren.
`Unicode::UCD` | Schnittstelle zur Unicode-Zeichendatenbank.

## Module für Textverarbeitung

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`MIME::Base64` | Ermöglicht das Umwandeln von Zeichenketten in das Base64-Format und umgekehrt.
`MIME::QuotedPrint` | Ermöglicht das Umwandeln von Zeichenketten in das Quoted-Printable-Format und umgekehrt.
`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::ANSIColor` | Erlaubt es, Bildschirmausgaben einzufärben.
`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::Balanced` | Extrahiert Text aus einer Zeichenkette, der von bestimmten Zeichenketten eingeschlossen ist.
`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 Tabulator-Zeichen zusammenfassen.
`Text::Wrap` | Bricht Text automatisch um entsprechend einer zu definierenden Vorgabe, bei welcher Zeichenspalte umbrochen werden soll.

## Module für Sprachen und Zeichenkodierungen

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Encode` | Allgemeine API für die Module der `Encode`-Familie.
`Encode::Alias` | Erlaubt das Definieren von Aliasnamen für Kodierungen.
`Encode::Byte` | Erlaubt das Arbeiten mit Kodierungen, die nur 1 Byte für ein Zeichen verwenden (zum Beispiel die ISO-8859-Kodierungen).
`Encode::CN` | Erlaubt es, mit chinesischen Zeichenkodierungen zu arbeiten.
`Encode::EBCDIC` | Erlaubt es, mit EBCDIC-Zeichenkodierungen zu arbeiten.
`Encode::Encoder` | Objektorientiertes Tool zum Arbeiten mit Zeichenkodierungen.
`Encode::Encoding` | Basisklasse für Zeichenkodierungen.
`Encode::Guess` | Versucht, den Codierungstyp von Daten festzustellen.
`Encode::JP` | Erlaubt es, mit japanischen Zeichenkodierungen zu arbeiten.
`Encode::KR` | Erlaubt es, mit koreanischen Zeichenkodierungen zu arbeiten.
`Encode::MIME::Header` | Erlaubt das Verarbeiten von MIME-kodierten Mailheader-Angaben (derzeit wird nur UTF-8 unterstützt).
`Encode::Symbol` | Erlaubt es, mit Codierungen von verschiedenen Symbolen zu arbeiten.
`Encode::TW` | Erlaubt es, mit taiwanesischen Zeichenkodierungen zu arbeiten.
`Encode::Unicode` | Erlaubt das Arbeiten mit Zeichenkodierungen nach dem Unicode-Standard.
`Encode::Unicode::UTF7` | Erlaubt das Arbeiten mit Zeichenkodierungen nach UTF-7.
`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).
`I18N::Langinfo` | Gibt Informationen über die Spracheinstellungen des Systems zurück.
`I18N::LangTags` | Enthält Funktionen, um mit Sprachkürzeln nach RFC 3066 zu arbeiten (z.B. `de`, `en` und `fr`).
`I18N::LangTags::List` | Versucht, Sprachkürzel in einen Sprachnamen umzuwandeln.
`Locale::Constants` | Definiert verschiedene Konstanten, die beim Arbeiten mit den Modulen `Locale::Country`, `Locale::Currency`, `Locale::Language` und `Locale::Script` genutzt werden können.
`Locale::Country` | Enthält Ländernamen und -codes nach ISO 3166.
`Locale::Currency` | Enthält Währungsnamen und -codes nach ISO 4217.
`Locale::Language` | Enthält Sprachnamen und -codes nach ISO 639.
`Locale::Maketext` | Framework um Software mehrsprachig anzubieten.
`Locale::Script` | Enthält Schriftnamen und -codes nach ISO 15924.

## 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. Beispiel
`Math::BigInt` | Erlaubt das Rechnen mit Ganzzahlen, die größer sind als das, was Perl normalerweise als Ganzzahl zu interpretieren in der Lage ist. Beispiel
`Math::BigRat` | Erlaubt das Rechnen mit Zahlen, die größer sind als das, was Perl normalerweise als Zahl 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::Cygwin` | Stellt Methoden bereit, um unter Cygwin mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`File::Spec::Epoc` | Stellt Methoden bereit, um auf dem Betriebssystem Epoc mit syntaktisch korrekten Dateinamen und Pfaden zu arbeiten.
`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 und erlaubt es, objektorientiert auf die Daten zuzugreifen.
`File::Temp` | Stellt Funktionen bereit, um auf sichere Weise mit temporären Dateien mit eindeutigen Namen zu arbeiten.
`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::Dir` | Ermöglicht das objektorientierte Arbeiten mit Verzeichnishandles.
`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::Poll` | Ermöglicht es, mit Hilfe objektorientierter Methoden mit dem `poll`-Systembefehl zu arbeiten.
`IO::Seekable` | Stellt objektorientierte Front-Ends 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.
`PerlIO` | Erlaubt Ein-/Ausgabe-Operationen mit kodierten Daten. Sie können dann mit den Daten arbeiten, als wären sie nicht kodiert.
`PerlIO::encoding` | Erlaubt das transparente Arbeiten mit Dateien, deren Inhalt mit einem Verfahren wie UTF-8 kodiert wurde. Sie können dann mit den Daten arbeiten, als wären sie nicht kodiert.
`PerlIO::scalar` | Erlaubt es, mit einem Skalar so zu arbeiten, als ob er eine Datei wäre.
`PerlIO::via` | Ein Hilfsmodul zum Arbeiten mit Filtern für die Ein-/Ausgabe von Dateien mit kodiertem Inhalt.
`PerlIO::via::QuotedPrint` | Erlaubt das transparente Arbeiten mit Dateien, deren Inhalt im Quoted-Printable-Format vorliegt. Sie können dann mit den Daten arbeiten, als wären sie nicht kodiert.

## Module für Datum und Zeit

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Time::HiRes` | Ersetzt interne Funktionen wie time und sleep und gibt ihnen die Möglichkeit, mit Millisekunden umzugehen.
`Time::Local` | Stellt Umkehrfunktionen für die Perl-Funktionen gmtime und localtime zur Verfügung.
`Time::gmtime` | Überschreibt die Perl-Funktion gmtime und ermöglicht einen objektorientierten Zugriff auf die Daten.
`Time::localtime` | Überschreibt die Perl-Funktion localtime und ermöglicht einen objektorientierten Zugriff auf die Daten.

## 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örige 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, sodass 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::File` | Ermöglicht es, die Zeilen einer Datei über einen Array anzusprechen.
`Tie::Handle` | Bindet ein Handle an eine Objektklasse.
`Tie::Hash` | Bindet einen Hash an eine Objektklasse
`Tie::Memoize` | Fügt die Daten zu einem Hash hinzu, wenn Sie benötigt werden.
`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::ISA` | Stellt die Werte der @ISA-Listen sämtlicher eingebundener Basisklassen bereit.
`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 einbindenden Scripts importiert werden.
`NEXT` | Stellt eine Pseudoklasse namens `NEXT` bereit, mit der Sie beim Aufruf von Methoden von Klassen Methoden gleichen Namens aus den Basisklassen mit aufrufen können.
`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 Web-Seiten").
`CGI::Fast` | Schnittstelle zum Fast-CGI-Standard, durch den CGI-Scripts deutlich schneller werden, weil sie als Prozesse dauerhaft im Arbeitsspeicher des Server-Rechners gehalten werden.
`CGI::Push` | Schnittstelle zum Server-Push, also dem Senden von Inhalten an den Browser ohne dessen explizite Anfrage. Web-Seiten 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::Cmd` | Basisklasse zur Kommunikation mit befehlsbasierten Internet-Protokollen (wie FTP und SMTP).
`Net::Domain` | Ermittelt den Host- und Domainnamen des aktuellen Rechners.
`Net::FTP` | Klasse zur Kommunikation mit FTP-Servern.
`Net::Netrc` | Objektorientierter Zugriff auf die .netrc-Datei des aktuellen Benutzers.
`Net::NNTP` | Klasse zur Kommunikation mit NNTP-Servern (News).
`Net::Ping` | Überprüft die Erreichbarkeit eines Host-Rechners im Internet mit der dafür üblichen Ping-Funktion.
`Net::POP3` | Klasse zur Kommunikation mit POP3-Servern.
`Net::SMTP` | Klasse zur Kommunikation mit SMTP-Servern.
`Net::Time` | Funktionen zum Zugriff auf Zeit-Server.
`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, Portnummern 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::Peek` | Ermöglicht das Prüfen von Daten, die von einem XS-Programm an ein Perl-Script gesendet wurden.
`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::Constant` | Erzeugt XS-Code, um Konstanten aus C-Header-Dateien zu laden.
`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::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 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 kompiliert und ausgeführt werden.
`XS::APItest` | Prüft, ob die C-API von Perl korrekt funktioniert.
`XS::Typemap` | Prüft die XS-Typemaps von Perl.
`XSLoader` | Lädt dynamisch Routinen aus den C-Bibliotheken in das laufende Perl-Script (ähnlich wie `DynaLoader`, jedoch weniger komplex).

## Module für POD-Dokumente

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`Pod::Checker` | Prüft die Syntax von POD-Dokumenten (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::Find` | Durchsucht einen Verzeichnisbaum nach POD-Dokumenten.
`Pod::Functions` | Erzeugt eine formatierte Liste von Perl-Standardfunktionen, ähnlich dem POD-Dokument `perlfunc`.
`Pod::Html` | Generiert aus dem POD-Format HTML-Code inklusive Querverweisen.
`Pod::InputObjects` | Stellt Objekte bereit, die beispielsweise die Absätze und Anweisungen in einem POD-Dokument darstellen.
`Pod::LaTeX` | Konvertiert POD-Dokumente ins LaTeX-Format.
`Pod::Man` | Konvertiert POD-Dokumente in ein Format, das vom `man`-Befehl von UNIX dargestellt werden kann.
`Pod::ParseLink` | Parst Links in einem POD-Dokument.
`Pod::Parser` | Basisklasse zum Parsen des POD-Formats.
`Pod::ParseUtils` | Enthält verschiedene Klassen zum Parsen von POD-Dokumenten.
`Pod::Plainer` | Wandelt POD-Texte in einem neuen Format in das ältere um.
`Pod::PlainText` | Generiert aus dem POD-Format reinen formatierten Text ohne Steuerbefehle.
`Pod::Select` | Liest eine bestimmte Stelle aus einem POD-Dokument aus.
`Pod::Text` | Generiert aus dem POD-Format reinen Text ohne Steuerbefehle.
`Pod::Usage` | Erzeugt aus POD-Dokumenten Hinweise zur Nutzung von Perl-Scripts an der Kommandozeile.

## 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 Byte-Code.
`B::Assembler` | Assembliert Byte-Code.
`B::Bblock` | Durchläuft die Grundblöcke eines Scripts.
`B::Bytecode` | Schnittstelle zum perl-internen Byte-Code eines Scripts.
`B::C` | Schnittstelle zum C-Backend des Perl-Compilers.
`B::CC` | Optimierte Schnittstelle zum C-Backend des Perl-Compilers.
`B::Concise` | Zeigt die Struktur des OP-Code eines Perl-Scripts.
`B::Debug` | Durchläuft den Code des Perl-Scripts und zeigt Debug-Informationen an.
`B::Deparse` | Disassembliert den Perl-Byte-Code.
`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::Stash` | Gibt an, welche Stashes geladen sind.
`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.
`O` | Schnittstelle zum Backend des Perl-Compilers, die es erlaubt, die Standardausgabe abzufangen und in einer Variable zu speichern.

## 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 Sie 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::Builder` | Erlaubt es, eigene Bibliotheken für Tests zu schreiben, die zusammenarbeiten können.
`Test::Harness` | Führt standardisierte Tests durch und gibt die Ergebnisse aus.
`Test::More` | Erweiterung von `Test::Simple`.
`Test::Simple` | Ermöglicht das einfache Durchführen von Tests.
`Win32` | Ermöglicht den Zugriff auf einige interne Funktionen von Windows-Systemen.

## Pragma-Module zum Beeinflussen des Perl-Interpreters

Modul (Syntax für Einbindung) | Aufgabe
--- | ---
`attrs` | Setzt und ermittelt Attribute eines Unterprogrammes. Dieses Pragma ist veraltet, stattdessen soll `attributes` verwendet werden.
`attributes` | Setzt und ermittelt Attribute von Unterprogrammen und Variablen.
`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.
`bigint` | Erlaubt das Rechnen mit Ganzzahlen, die größer sind als das, was Perl normalerweise als Ganzzahl zu interpretieren in der Lage ist. Im Gegensatz zu `Math::BigInt` werden hierbei die Operatoren mit dieser Funktion ausgestattet.
`bignum` | Stattet die Operatoren mit der Fähigkeit aus, mit Zahlen zu rechnen, die größer oder kleiner sind als das, was Perl normalerweise als Zahl zu interpretieren in der Lage ist.
`bigrat` | Stattet die Operatoren mit der Fähigkeit aus, mit Zahlen zu rechnen, die größer oder kleiner sind als das, was Perl normalerweise als Zahl zu interpretieren in der Lage ist.
`blib` | Durchsucht nicht installierte Module. Gedacht für die Verwendung im Zusammenhang mit der Option `-M` beim Aufruf des Perl-Compilers.
`bytes` | Behandelt Daten nicht als UTF-8, sondern arbeitet sie byteweise ab.
`constant` | Deklariert unveränderliche Konstanten, ähnlich, wie es in C mit `#define` möglich ist.
`charnames` | Erlaubt es, Zeichen aus anderen Zeichenvorräten mit Hilfe Ihrer Namen zu erzeugen.
`diagnostics` | Gibt bei Fehlermeldungen, die der Perl-Compiler ausgibt, zugleich deren Erläuterungen mit aus. Dazu werden die Beschreibungen aus perldiag verwendet.
`encoding` | Ermöglicht das Schreiben von Perl-Quellcode in anderen Kodierungen als der ASCII- oder UTF-8-Kodierung.
`fields` | Stellt sicher, dass der vordefinierte Hash `%FIELDS` zur Kompilierzeit versorgt ist.
`filetest` | Verändert das Verhalten einiger Dateitestoperatoren und ermöglicht so, die Berechtigungen von Dateien genauer zu ermitteln (beispielsweise falls sog. Access Control Lists verwendet werden).
`if` | Erlaubt es, ein Perl-Modul nur unter bestimmten Bedingungen zu laden.
`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. die zu verwendende Zeichenkodierung bei Zeichenkettenvergleichen.
`open` | Beeinflusst das Verhalten des Perl-Interpreters bei IO-Operation (Lesen und Schreiben von Daten).
`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.
`sort` | Beeinflusst das Verhalten der sort-Funktion.
`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()`.
`threads` | Erlaubt es, Interpreter-basierte Threads in Perl zu nutzen.
`threads::shared` | Erlaubt es, Datenstrukturen zwischen zwei Threads auszutauschen.
`utf8` | Ermöglicht das Verwenden von UTF-8-Sonderzeichen im Quellcode.
`vars` | Ermöglicht das Vorabdeklarieren der Namen von globalen Variablen. Dieses Modul ist mittlerweile veraltet, stattdessen sollen Deklarationen mit der Funktion `our` verwendet werden.
`vmsish` | Ermöglicht es, Features zu nutzen, die nur unter dem Betriebssystem VMS verfügbar sind.
`warnings` | Mit diesem Modul lassen sich die Warnmeldungen des Perl-Interpreters kontrollieren.

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

© 2007 Impressum