perlmodlib – Online in der Cloud

Führen Sie perlmodlib im kostenlosen Hosting-Anbieter OnWorks über Ubuntu Online, Fedora Online, den Windows-Online-Emulator oder den MAC OS-Online-Emulator aus

Dies ist der Befehl perlmodlib, der beim kostenlosen Hosting-Anbieter OnWorks mit einer unserer zahlreichen kostenlosen Online-Workstations wie Ubuntu Online, Fedora Online, dem Windows-Online-Emulator oder dem MAC OS-Online-Emulator ausgeführt werden kann

Unter Ubuntu ausführen Lauf in Fedora In Windows Sim ausführen In MACOS Sim ausführen

PROGRAMM:

NAME/FUNKTION

perlmodlib - neue Perl-Module erstellen und vorhandene finden

PERL MODULE BIBLIOTHEK

Viele Module sind in der Perl-Distribution enthalten. Diese werden im Folgenden beschrieben, und zwar alle
enden in .pm. Möglicherweise entdecken Sie kompilierte Bibliotheksdateien (normalerweise mit der Endung .so) oder klein
Teile der Module, die automatisch geladen werden sollen (Endung .al); Diese wurden automatisch von generiert
den Installationsvorgang. Möglicherweise finden Sie auch Dateien im Bibliotheksverzeichnis, die enden
In entweder .pl or .ph. Hierbei handelt es sich um alte Bibliotheken, die von alten Programmen bereitgestellt werden, die sie verwenden
läuft immer noch. Der .pl Dateien werden schließlich alle in Standardmodule konvertiert, und die
.ph Dateien erstellt von h2ph werden wahrscheinlich als Erweiterungsmodule von hergestellt werden h2xs. (Etwas .ph
Werte sind möglicherweise bereits über die Module POSIX, Errno oder Fcntl verfügbar.) Die 2 Uhr
Die Datei in der Distribution kann bei der Konvertierung hilfreich sein, es ist jedoch nur ein mechanischer Vorgang
und daher alles andere als kugelsicher.

Pragmatisch Module
Sie funktionieren in gewisser Weise wie Compiler-Direktiven (Pragmata), da sie tendenziell Auswirkungen auf die haben
Kompilierung Ihres Programms und funktioniert daher normalerweise nur dann gut, wenn sie innerhalb eines verwendet wird
„verwenden“ oder „nein“. Die meisten davon haben einen lexikalischen Gültigkeitsbereich, sodass ein innerer BLOCK dies widerlegen kann
sie, indem sie sagen:

keine ganze Zahl;
keine strengen „Referenzen“;
keine Warnungen;

was bis zum Ende dieses BLOCKS dauert.

Einige Pragmas haben einen lexikalischen Gültigkeitsbereich – normalerweise diejenigen, die sich auf die Hinweisvariable $^H auswirken.
Andere wirken sich stattdessen auf das aktuelle Paket aus, z. B. „Use Vars“ und „Use Subs“, die Ihnen dies ermöglichen
um Variablen oder Unterprogramme innerhalb einer bestimmten Variable vorab zu deklarieren Datei anstatt nur a
Block. Solche Erklärungen gelten für die gesamte Akte, für die sie erklärt wurden.
Sie können sie nicht mit „no vars“ oder „no subs“ widerrufen.

Die folgenden Pragmas sind definiert (und verfügen über eine eigene Dokumentation).

arybase Indizierungsbasis über $[ festlegen

Attribute Unterprogramm- oder Variablenattribute abrufen/setzen

autodie Ersetzt Funktionen durch solche, die mit lexikalischem Gültigkeitsbereich erfolgreich sind oder sterben

Autodie::Ausnahme
Ausnahmen von Autodying-Funktionen.

autodie::ausnahme::system
Ausnahmen vom Selbstfärben System().

Autodie::Hinweise
Geben Sie Hinweise zu Benutzerunterroutinen für Autodie

autodie::überspringen
Überspringen Sie ein Paket, wenn Sie Autodie-Ausnahmen auslösen

autouse Verschieben Sie das Laden von Modulen, bis eine Funktion verwendet wird

base Stellt zur Kompilierungszeit eine ISA-Beziehung mit Basisklassen her

bigint Transparente BigInteger-Unterstützung für Perl

bignum Transparente BigNumber-Unterstützung für Perl

bigrat Transparente BigNumber/BigRational-Unterstützung für Perl

blib Verwenden Sie die deinstallierte Version eines Pakets von MakeMaker

Bytes Erzwingt eine Byte-Semantik anstelle einer Zeichen-Semantik

charnames Zugriff auf Unicode-Zeichennamen und benannte Zeichenfolgen; auch definieren
Charakternamen

Konstante Deklarieren Sie Konstanten

deprecate Perl-Pragma zum Verwerfen der Kernversion eines Moduls

Diagnosen Erstellen ausführlicher Warndiagnosen

Kodierung Ermöglicht Ihnen, Ihr Skript in Nicht-ASCII und Nicht-UTF-8 zu schreiben

Kodierung::Warnungen
Warnung vor impliziten Codierungskonvertierungen

experimentell
Experimentelle Funktionen leicht gemacht

Feature Neue Funktionen aktivieren

Felder Klassenfelder zur Kompilierungszeit

filetest Steuert die Filetest-Berechtigungsoperatoren

Wenn ein Perl-Modul „verwendet“ wird, wenn eine Bedingung erfüllt ist (kann ein Modul auch „nein“ sein)

Ganzzahl Verwenden Sie Ganzzahlarithmetik anstelle von Gleitkommazahlen

weniger Fordern Sie weniger von etwas an

lib Manipulieren Sie @INC zur Kompilierungszeit

Gebietsschema Verwenden oder vermeiden Sie POSIX-Gebietsschemas für integrierte Operationen

Reihenfolge der mro-Methodenauflösung

ok Alternative zu Test::More::use_ok

open Standard-PerlIO-Ebenen für Eingabe und Ausgabe festlegen

ops Beschränken Sie unsichere Vorgänge beim Kompilieren

Überladung Paket zum Überladen von Perl-Operationen

Überlastung Kontrollieren Sie die Überlastung lexikalisch

parent Stellen Sie zur Kompilierungszeit eine ISA-Beziehung mit Basisklassen her

bezüglich Verhalten regulärer Ausdrücke ändern

sigtrap Ermöglicht eine einfache Signalverarbeitung

Sortiersteuerung Sortieren() Verhalten

strict Beschränkt unsichere Konstrukte

subs Unternamen vorab deklarieren

Threads Perl-Interpreter-basierte Threads

Threads::geteilt
Perl-Erweiterung zum Teilen von Datenstrukturen zwischen Threads

utf8 Aktivieren/deaktivieren Sie UTF-8 (oder UTF-EBCDIC) im Quellcode

vars Globale Variablennamen vorab deklarieren

version Perl-Erweiterung für Versionsobjekte

vmsish Steuert VMS-spezifische Sprachfunktionen

Warnungen::registrieren
Importfunktion für Warnungen

Standard Module
Von standardmäßigen, gebündelten Modulen wird erwartet, dass sie sich in Bezug auf Respekt auf eine genau definierte Weise verhalten
zur Namespace-Verschmutzung führen, da sie das Exporter-Modul verwenden. Siehe ihre eigene Dokumentation
.

Es ist möglich, dass nicht alle unten aufgeführten Module auf Ihrem System installiert sind. Zum Beispiel,
Das GDBM_File-Modul wird nicht installiert, wenn Sie nicht über die GDBM-Bibliothek verfügen.

AnyDBM_File Bietet ein Framework für mehrere DBMs

App::Cpan Einfache Interaktion mit CPAN über die Befehlszeile

App::Prove Implementiert den Befehl „prove“.

App::Beweisen::Zustand
Statusspeicher für den Befehl „beweisen“.

App::Beweisen::Zustand::Ergebnis
Ergebnisse einzelner Testsuiten.

App::Beweisen::Zustand::Ergebnis::Test
Individuelle Testergebnisse.

Archiv::Tar
Modul zur Manipulation von TAR-Archiven

Archiv::Tar::Datei
Eine Unterklasse für im Speicher extrahierte Dateien aus Archive::Tar

Attribut::Handler
Einfachere Definition von Attributhandlern

AutoLoader Unterprogramme nur bei Bedarf laden

AutoSplit Teilen Sie ein Paket zum automatischen Laden

B Das Perl-Compiler-Backend

B::Concise Walk Perl-Syntaxbaum, der prägnante Informationen über Operationen ausgibt

B::Debug Walk Perl-Syntaxbaum, der Debug-Informationen zu Operationen ausgibt

B::Deparse das Perl-Compiler-Backend, um Perl-Code zu erzeugen

B::Op_privat
OP op_private-Flag-Definitionen

B::Showlex Zeigt lexikalische Variablen an, die in Funktionen oder Dateien verwendet werden

B::Terse Walk Perl-Syntaxbaum, der knappe Informationen über Operationen ausgibt

B::Xref Erstellt Querverweisberichte für Perl-Programme

Benchmark Benchmark-Laufzeiten von Perl-Code

"IO::Socket::IP"
Familienneutraler IP-Socket, der sowohl IPv4 als auch IPv6 unterstützt

„Socket“ Netzwerkkonstanten und Unterstützungsfunktionen

CORE-Namespace für die Kernroutinen von Perl

CPAN Abfragen, Herunterladen und Erstellen von Perl-Modulen von CPAN-Sites

CPAN::API::HOWTO
Ein Rezeptbuch für die Programmierung mit CPAN.pm

CPAN::Debug Internes Debugging für CPAN.pm

CPAN::Distroprefs
Distroprefs lesen und abgleichen

CPAN::Erstes Mal
Dienstprogramm für die Initialisierung der CPAN::Config-Datei

CPAN::HandleConfig
Interne Konfigurationsverwaltung für CPAN.pm

CPAN::Kwalify
Schnittstelle zwischen CPAN.pm und Kwalify.pm

CPAN::Meta Die Verteilungsmetadaten für eine CPAN-Verteilung

CPAN::Meta::Konverter
Konvertieren Sie CPAN-Verteilungsmetadatenstrukturen

CPAN::Meta::Funktion
Eine optionale Funktion, die von einer CPAN-Distribution bereitgestellt wird

CPAN::Meta::Historie
Verlauf der Änderungen der CPAN-Metaspezifikation

CPAN::Meta::Verlauf::Meta_1_0
Metadatenspezifikation der Version 1.0 für META.yml

CPAN::Meta::Verlauf::Meta_1_1
Metadatenspezifikation der Version 1.1 für META.yml

CPAN::Meta::Verlauf::Meta_1_2
Metadatenspezifikation der Version 1.2 für META.yml

CPAN::Meta::Verlauf::Meta_1_3
Metadatenspezifikation der Version 1.3 für META.yml

CPAN::Meta::Verlauf::Meta_1_4
Metadatenspezifikation der Version 1.4 für META.yml

CPAN::Meta::Zusammenführen
CPAN-Metafragmente zusammenführen

CPAN::Meta::Voraussetzungen
Eine Reihe von Verteilungsvoraussetzungen nach Phase und Typ

CPAN::Meta::Anforderungen
Eine Reihe von Versionsanforderungen für eine CPAN-Verteilung

CPAN::Meta::Spec
Spezifikation für CPAN-Verteilungsmetadaten

CPAN::Meta::Validator
Validieren Sie die Metadatenstrukturen der CPAN-Verteilung

CPAN::Meta::YAML
Lesen und schreiben Sie eine Teilmenge von YAML für CPAN-Metadateien

CPAN::Nox Wrapper um CPAN.pm ohne Verwendung eines XS-Moduls

CPAN::Plugin
Basisklasse für CPAN-Shell-Erweiterungen

CPAN::Plugin::Specfile
Proof-of-Concept-Implementierung eines trivialen CPAN::Plugins

CPAN::Queue Interne Warteschlangenunterstützung für CPAN.pm

CPAN::Tarzip
Interne Verwaltung von TAR-Archiven für CPAN.pm

CPAN::Version
Hilfsfunktionen zum Vergleichen von CPAN-Versionen

Carp Alternative warnt und stirbt für Module

Klasse::Struktur
Deklarieren Sie strukturähnliche Datentypen als Perl-Klassen

Komprimieren::Raw::Bzip2
Low-Level-Schnittstelle zur bzip2-Komprimierungsbibliothek

Komprimieren::Raw::Zlib
Low-Level-Schnittstelle zur zlib-Komprimierungsbibliothek

Komprimieren::Zlib
Schnittstelle zur zlib-Komprimierungsbibliothek

Config Zugriff auf Perl-Konfigurationsinformationen

Konfig::Perl::V
Strukturierter Datenabruf der Perl-V-Ausgabe

Cwd Pfadnamen des aktuellen Arbeitsverzeichnisses abrufen

DB-Programmschnittstelle zur Perl-Debugging-API

DBM_Filter DBM-Schlüssel/Werte filtern

DBM_Filter::komprimieren
Filtern Sie nach DBM_Filter

DBM_Filter::kodieren
Filtern Sie nach DBM_Filter

DBM_Filter::int32
Filtern Sie nach DBM_Filter

DBM_Filter::null
Filtern Sie nach DBM_Filter

DBM_Filter::utf8
Filtern Sie nach DBM_Filter

DB_File Perl5-Zugriff auf Berkeley DB Version 1.x

Daten::Kipper
Stringifizierte Perl-Datenstrukturen, die sowohl zum Drucken als auch zum Auswerten geeignet sind.

Entwickeln::PPPort
Perl/Umweltverschmutzung/Portabilität

Devel::Peek Ein Daten-Debugging-Tool für den XS-Programmierer

Entwickeln::SelfStubber
Generieren Sie Stubs für ein SelfLoading-Modul

Digest-Module, die Nachrichten-Digests berechnen

Digest::MD5 Perl-Schnittstelle zum MD5-Algorithmus

Digest::SHA Perl-Erweiterung für SHA-1/224/256/384/512

Verdauen::base
Digest-Basisklasse

Übersicht::Datei
Berechnen Sie Zusammenfassungen von Dateien

DirHandle Stellt Objektmethoden für Verzeichnis-Handles bereit

Dumpvalue Stellt einen Bildschirmdump von Perl-Daten bereit.

DynaLoader Lädt C-Bibliotheken dynamisch in Perl-Code

Kodieren Sie Zeichenkodierungen in Perl

Codieren::Alias
Aliasdefinitionen für Kodierungen

Codieren::Byte
Einzelbyte-Kodierungen

Codieren::CJKKonstanten
Intern verwendet von Encode::??::ISO_2022_*

Encode::CN Chinesische Kodierungen mit Sitz in China

Codieren::CN::HZ
Wird intern von Encode::CN verwendet

Codieren::Konfig
Intern von Encode verwendet

Codieren::EBCDIC
EBCDIC-Kodierungen

Kodieren::Kodierer
Objektorientierter Encoder

Kodieren::Kodierung
Basisklasse der Codierungsimplementierung

Kodieren::GSM0338
ESTI GSM 03.38 Kodierung

Codieren::Rate mal
Errät die Kodierung anhand der Daten

Encode::JP Japanische Kodierungen

Kodieren::JP::H2Z
Intern verwendet von Encode::JP::2022_JP*

Kodieren::JP::JIS7
Wird intern von Encode::JP verwendet

Encode::KR Koreanische Kodierungen

Kodieren::KR::2022_KR
Wird intern von Encode::KR verwendet

Codieren::MIME::Header
MIME-Header-Codierung „B“ und „Q“.

Encode::MIME::Name
Intern von Encode verwendet

Codieren::PerlIO
Ein ausführliches Dokument zu Encode und PerlIO

Codieren::Unterstützt
Von Encode unterstützte Kodierungen

Codieren::Symbol
Symbolkodierungen

Encode::TW Chinesische Kodierungen mit Sitz in Taiwan

Codieren::Unicode
Verschiedene Unicode-Transformationsformate

Codieren::Unicode::UTF7
UTF-7-Codierung

Englisch Verwenden Sie nette englische (oder awk) Namen für hässliche Interpunktionsvariablen

Env Perl-Modul, das Umgebungsvariablen als Skalare oder Arrays importiert

Errno System-Errno-Konstanten

Exporter Implementiert die Standardimportmethode für Module

Exporteur::Schwer
Mut des Exporteurs

ExtUtils::CBuilder
Kompilieren und verknüpfen Sie C-Code für Perl-Module

ExtUtils::CBuilder::Platform::Windows
Builder-Klasse für Windows-Plattformen

ExtUtils::Befehl
Dienstprogramme zum Ersetzen allgemeiner UNIX-Befehle in Makefiles usw.

ExtUtils::Befehl::MM
Befehle für die MMs zur Verwendung in Makefiles

ExtUtils::Konstante
Generieren Sie XS-Code zum Importieren von C-Header-Konstanten

ExtUtils::Konstante::Basis
Basisklasse für ExtUtils::Constant-Objekte

ExtUtils::Constant::Utils
Hilfsfunktionen für ExtUtils::Constant

ExtUtils::Konstante::XS
Generieren Sie C-Code für die Konstanten der XS-Module.

ExtUtils::Einbetten
Dienstprogramme zum Einbetten von Perl in C/C++-Anwendungen

ExtUtils::Installieren
Installieren Sie Dateien von hier nach dort

ExtUtils::Installiert
Bestandsverwaltung der installierten Module

ExtUtils::Liblist
Bestimmen Sie die zu verwendenden Bibliotheken und deren Verwendung

ExtUtils::MM
Vom Betriebssystem angepasste ExtUtils::MakeMaker-Unterklasse

ExtUtils::MM_AIX
AIX-spezifische Unterklasse von ExtUtils::MM_Unix

ExtUtils::MM_Any
Plattformunabhängige MM-Methoden

ExtUtils::MM_BeOS
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_Cygwin
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_DOS
DOS-spezifische Unterklasse von ExtUtils::MM_Unix

ExtUtils::MM_Darwin
Besondere Verhaltensweisen für OS X

ExtUtils::MM_MacOS
Einmal erstellte Makefiles für MacOS Classic

ExtUtils::MM_NW5
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_OS2
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_QNX
QNX-spezifische Unterklasse von ExtUtils::MM_Unix

ExtUtils::MM_UWIN
U/WIN-spezifische Unterklasse von ExtUtils::MM_Unix

ExtUtils::MM_Unix
Von ExtUtils::MakeMaker verwendete Methoden

ExtUtils::MM_VMS
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_VOS
VOS-spezifische Unterklasse von ExtUtils::MM_Unix

ExtUtils::MM_Win32
Methoden zum Überschreiben des UN*X-Verhaltens in ExtUtils::MakeMaker

ExtUtils::MM_Win95
Methode zum Anpassen von MakeMaker für Win9X

ExtUtils::MY
ExtUtils::MakeMaker-Unterklasse zur Anpassung

ExtUtils::MakeMaker
Erstellen Sie ein Modul-Makefile

ExtUtils::MakeMaker::Config
Wrapper um Config.pm

ExtUtils::MakeMaker::FAQ
Häufig gestellte Fragen zu MakeMaker

ExtUtils::MakeMaker::Locale
Gebündeltes Encode::Locale

ExtUtils::MakeMaker::Tutorial
Ein Modul mit MakeMaker schreiben

ExtUtils::Manifest
Dienstprogramme zum Schreiben und Überprüfen einer MANIFEST-Datei

ExtUtils::Miniperl
Schreiben Sie den C-Code für perlmain.c

ExtUtils::Mkbootstrap
Erstellen Sie eine Bootstrap-Datei zur Verwendung durch DynaLoader

ExtUtils::Mksymlists
Schreiben Sie Linker-Optionsdateien für dynamische Erweiterungen

ExtUtils::Packliste
.packlist-Dateien verwalten

ExtUtils::ParseXS
Konvertiert Perl-XS-Code in C-Code

ExtUtils::ParseXS::Konstanten
Initialisierungswerte für einige Globals

ExtUtils::ParseXS::Eval
Bereinigen Sie das Paket, um den Code darin auszuwerten

ExtUtils::ParseXS::Utilities
Mit ExtUtils::ParseXS verwendete Unterroutinen

ExtUtils::Typemaps
Lesen/Schreiben/Ändern von Perl/XS-Typemap-Dateien

ExtUtils::Typemaps::Cmd
Schnellbefehle zum Umgang mit Typemaps

ExtUtils::Typemaps::InputMap
Eintrag im INPUT-Abschnitt einer Typemap

ExtUtils::Typemaps::OutputMap
Eintrag im OUTPUT-Abschnitt einer Typemap

ExtUtils::Typemaps::Type
Eintrag im TYPEMAP-Abschnitt einer Typemap

ExtUtils::XSSymSet
Halten Sie Symbolnamensätze für den VMS-Linker schmackhaft

ExtUtils::testlib
Fügen Sie blib/*-Verzeichnisse zu @INC hinzu

Schwerwiegend Ersetzen Sie Funktionen durch Äquivalente, die erfolgreich sind oder scheitern

Fcntl Laden Sie die C-Definitionen von Fcntl.h

Datei::Basisname
Analysieren Sie Dateipfade in Verzeichnis, Dateiname und Suffix.

Datei::Vergleichen
Vergleichen Sie Dateien oder Dateihandles

File::Copy Dateien oder Dateihandles kopieren

Datei :: DosGlob
DOS mag Globbing und noch mehr

File::Fetch Ein generischer Mechanismus zum Abrufen von Dateien

File::Fin Durchläuft einen Verzeichnisbaum.

File::Glob Perl-Erweiterung für die BSD-Glob-Routine

Datei::GlobMapper
Erweitern Sie File Glob, um Eingabe- und Ausgabedateien zuzulassen

File::Path Verzeichnisbäume erstellen oder entfernen

File::Spec Führen Sie portabel Operationen an Dateinamen durch

Datei::Spec::Cygwin
Methoden für Cygwin-Dateispezifikationen

Datei::Spec::Epoc
Methoden für Epoc-Dateispezifikationen

Datei::Spec::Funktionen
Führen Sie Operationen an Dateinamen portabel durch

Datei::Spezifikation::Mac
File::Spec für Mac OS (Classic)

Datei::Spezifikation::OS2
Methoden für OS/2-Dateispezifikationen

Datei::Spec::Unix
File::Spec für Unix, Basis für andere File::Spec-Module

Datei::Spezifikation::VMS
Methoden für VMS-Dateispezifikationen

Datei::Spec::Win32
Methoden für Win32-Dateispezifikationen

File::Temp Gibt den Namen und das Handle einer temporären Datei sicher zurück

File::stat By-Name-Schnittstelle zum integrierten Perl stat () Funktionen

FileCache Halten Sie mehr Dateien geöffnet, als das System zulässt

FileHandle Objektmethoden für Dateihandles bereitstellen

Filtern::Einfach
Vereinfachte Quellenfilterung

Filtern::Util::Anrufen
Perl Source Filter Utility-Modul

FindBin Suchen Sie das Verzeichnis des ursprünglichen Perl-Skripts

GDBM_File Perl5-Zugriff auf die GDBM-Bibliothek.

Getopt::Lange
Erweiterte Verarbeitung von Befehlszeilenoptionen

Getopt::Std Verarbeitet Einzelzeichen-Switches mit Switch-Clustering

HTTP::Tiny Ein kleiner, einfacher, korrekter HTTP/1.1-Client

Hash::Util Eine Auswahl allgemein nützlicher Hash-Subroutinen

Hash::Util::FieldHash
Unterstützung für Inside-Out-Kurse

I18N::Sortieren
Vergleichen Sie 8-Bit-Skalardaten entsprechend dem aktuellen Gebietsschema

I18N::LangTags
Funktionen zum Umgang mit Sprach-Tags im RFC3066-Stil

I18N::LangTags::Erkennen
Ermitteln Sie die Sprachpräferenzen des Benutzers

I18N::LangTags::Liste
Tags und Namen für menschliche Sprachen

I18N::Langinfo
Gebietsschemainformationen abfragen

IO Verschiedene IO-Module laden

IO::Komprimieren::Basis
Basisklasse für IO::Compress-Module

IO::Komprimieren::Bzip2
Schreiben Sie bzip2-Dateien/Puffer

IO::Komprimieren::Entleeren
Schreiben Sie RFC 1950-Dateien/Puffer

IO::Komprimieren::FAQ
Häufig gestellte Fragen zu IO::Compress

IO::Komprimieren::Gzip
Schreiben Sie RFC 1952-Dateien/Puffer

IO::Compress::RawDeflate
Schreiben Sie RFC 1951-Dateien/Puffer

IO::Komprimieren::Zip
Schreiben Sie ZIP-Dateien/Puffer

IO::Dir Stellt Objektmethoden für Verzeichnis-Handles bereit

IO::File Objektmethoden für Dateihandles bereitstellen

IO::Handle Stellt Objektmethoden für I/O-Handles bereit

IO::Pipe Objektmethoden für Pipes bereitstellen

IO::Poll-Objektschnittstelle zum Systemabfrageaufruf

IO::Suchbar
Bereitstellung suchbasierter Methoden für E/A-Objekte

IO::Select OO-Schnittstelle zum ausgewählten Systemaufruf

IO::Socket Objektschnittstelle zur Socket-Kommunikation

IO::Buchse::INET
Objektschnittstelle für AF_INET-Domänensockets

IO::Buchse::UNIX
Objektschnittstelle für AF_UNIX-Domänensockets

IO::Dekomprimieren::AnyInflate
Dekomprimieren Sie die zlib-basierte Datei/den Puffer (zip, gzip).

IO::Uncompress::AnyUncompress
Dekomprimieren Sie die Datei/den Puffer gzip, zip, bzip2 oder lzop

IO::Dekomprimieren::Base
Basisklasse für IO::Uncompress-Module

IO::Dekomprimieren::Bunzip2
Bzip2-Dateien/Puffer lesen

IO::Dekomprimieren::Gunzip
RFC 1952-Dateien/Puffer lesen

IO::Entpacken::Aufblasen
RFC 1950-Dateien/Puffer lesen

IO::Uncompress::RawInflate
RFC 1951-Dateien/Puffer lesen

IO::Dekomprimieren::Entpacken
ZIP-Dateien/Puffer lesen

IO::Zlib Schnittstelle im IO::-Stil für Compress::Zlib

IPC::Cmd Systembefehle finden und ausführen leicht gemacht

IPC::Msg SysV Msg IPC-Objektklasse

IPC::Open2 Öffnen Sie einen Prozess zum Lesen und Schreiben mit open2()

IPC::Open3 Öffnen Sie einen Prozess zum Lesen, Schreiben und zur Fehlerbehandlung mit open3()

IPC::Semaphor
SysV Semaphore IPC-Objektklasse

IPC::SharedMem
SysV Shared Memory IPC-Objektklasse

IPC::SysV System V IPC-Konstanten und Systemaufrufe

JSON::PP JSON::XS-kompatibles reines Perl-Modul.

JSON::PP::Boolesch
Dummy-Modul, das JSON::PP::Boolean bereitstellt

List::Util Eine Auswahl allgemeiner Utility-Listen-Unterroutinen

Liste::Util::XS
Geben Sie an, ob List::Util mit einem C-Compiler kompiliert wurde

Gebietsschema::Codes
Eine Verteilung von Modulen zur Verarbeitung von Gebietsschemacodes

Gebietsschema::Codes::API
Eine Beschreibung der aufrufbaren Funktion in jedem Modul

Gebietsschema::Codes::Änderungen
Detaillierte Änderungen an Locale::Codes

Gebietsschema::Codes::Konstanten
Konstanten für Gebietsschemacodes

Gebietsschema::Codes::Land
Standardcodes zur Länderidentifikation

Gebietsschema::Codes::Währung
Standardcodes zur Währungsidentifizierung

Gebietsschema::Codes::LangExt
Standardcodes zur Identifizierung von Spracherweiterungen

Gebietsschema::Codes::LangFam
Standardcodes zur Identifizierung von Spracherweiterungen

Gebietsschema::Codes::LangFam_Retired
Zurückgezogene Langfam-Codes für das Modul Locale::Codes::LangFam

Gebietsschema::Codes::LangVar
Standardcodes zur Identifizierung von Sprachvarianten

Gebietsschema::Codes::Sprache
Standardcodes zur Sprachidentifizierung

Gebietsschema::Codes::Skript
Standardcodes zur Skriptidentifizierung

Gebietsschema::Land
Standardcodes zur Länderidentifikation

Gebietsschema::Währung
Standardcodes zur Währungsidentifizierung

Gebietsschema::Sprache
Standardcodes zur Sprachidentifizierung

Gebietsschema::Maketext
Framework für die Lokalisierung

Gebietsschema::Maketext::Kochbuch
Rezepte für die Verwendung von Locale::Maketext

Gebietsschema::Maketext::Guts
Veraltetes Modul zum Laden von Locale::Maketext utf8-Code

Gebietsschema::Maketext::GutsLoader
Veraltetes Modul zum Laden von Locale::Maketext utf8-Code

Gebietsschema::Maketext::Simple
Einfache Schnittstelle zu Locale::Maketext::Lexicon

Gebietsschema::Maketext::TPJ13
Artikel über Softwarelokalisierung

Gebietsschema::Skript
Standardcodes zur Skriptidentifizierung

MIME::Base64
Kodierung und Dekodierung von Base64-Strings

MIME::QuotedPrint
Kodierung und Dekodierung von in Anführungszeichen druckbaren Zeichenfolgen

Mathe::BigFloat
Fließkomma-Mathematikpaket beliebiger Größe

Math :: BigInt
Mathematikpaket für Ganzzahl/Fließkomma beliebiger Größe

Mathe::BigInt::Calc
Reines Perl-Modul zur Unterstützung von Math::BigInt

Math::BigInt::CalcEmu
Emulieren Sie Low-Level-Mathematik mit BigInt-Code

Mathe::BigInt::FastCalc
Math::BigInt::Calc mit etwas XS für mehr Geschwindigkeit

Mathe::BigRat
Beliebige große rationale Zahlen

Mathematik::Komplex
Komplexe Zahlen und zugehörige mathematische Funktionen

Math::Trig Trigonometrische Funktionen

Memoize Machen Sie Funktionen schneller, indem Sie Raum gegen Zeit tauschen

Merken::AnyDBM_File
Kleben Sie, um EXISTS für AnyDBM_File zur speicherbaren Verwendung bereitzustellen

Merken::Ablaufen
Plug-in-Modul zum automatischen Ablauf gespeicherter Werte

Merken::ExpireFile
Testen Sie die Ablaufsemantik von Memoize

Merken::ExpireTest
Testen Sie die Ablaufsemantik von Memoize

Merken::NDBM_File
Kleben Sie, um EXISTS für NDBM_File für die speicherbare Verwendung bereitzustellen

Merken::SDBM_File
Kleben Sie, um EXISTS für SDBM_File für die speicherbare Verwendung bereitzustellen

Merken::Speicherbar
Speichern Sie gespeicherte Daten in der speicherbaren Datenbank

Modul::CoreList
Welche Module wurden mit Perl-Versionen geliefert?

Modul::CoreList::Utils
Welche Dienstprogramme im Lieferumfang der Perl-Versionen enthalten sind

Modul::Laden
Zur Laufzeit sind sowohl Module als auch Dateien erforderlich

Modul::Laden::Bedingt
Modulinformationen nachschlagen/zur Laufzeit laden

Modul::Geladen
Markieren Sie Module als geladen oder entladen

Modul::Metadaten
Sammeln Sie Paket- und POD-Informationen aus Perl-Moduldateien

NDBM_File Begrenzter Zugriff auf NDBM-Dateien

NEXT Stellen Sie eine Pseudoklasse NEXT (et al.) bereit, die Methoden-Redispatch ermöglicht

Net::Cmd Netzwerkbefehlsklasse (wie von FTP, SMTP usw. verwendet)

Net::Config Lokale Konfigurationsdaten für libnet

Net::Domain Versuch, den Internetnamen und die Domäne des aktuellen Hosts auszuwerten

Net::FTP FTP-Client-Klasse

Net::FTP::dataconn
FTP-Client-Datenverbindungsklasse

Net::NNTP NNTP-Client-Klasse

Net::Netrc OO-Schnittstelle zur Netrc-Datei des Benutzers

Net::POP3 Post Office Protocol 3 Client-Klasse (RFC1939)

Net::Ping Überprüfen Sie einen Remote-Host auf Erreichbarkeit

Net::SMTP Simple Mail Transfer Protocol-Client

Net::Time Zeit- und Tages-Netzwerk-Client-Schnittstelle

Netz::hostent
By-Name-Schnittstelle zu Perls integrierten gethost*()-Funktionen

Net::libnetFAQ
Häufig gestellte Fragen zu Libnet

Net::netent By-Name-Schnittstelle zu Perls integrierten getnet*()-Funktionen

Netz::protoent
By-Name-Schnittstelle zu Perls integrierten getproto*()-Funktionen

Netz::diener
By-Name-Schnittstelle zu Perls integrierten getserv*()-Funktionen

O Generische Schnittstelle zu Perl-Compiler-Backends

ODBM_File Begrenzter Zugriff auf ODBM-Dateien

Opcode Deaktivieren Sie benannte Opcodes beim Kompilieren von Perl-Code

POSIX Perl-Schnittstelle zu IEEE Std 1003.1

Parameter::Check
Ein generischer Mechanismus zum Parsen/Überprüfen von Eingaben.

Parse::CPAN::Meta
Analysieren Sie die CPAN-Metadatendateien META.yml und META.json

Perl::OSType
Ordnen Sie Perl-Betriebssystemnamen generischen Typen zu

PerlIO On-Demand-Loader für PerlIO-Ebenen und Root des PerlIO::*-Namensraums

PerlIO::Kodierung
Kodierungsschicht

PerlIO::mmap
Speicherzugeordnete E/A

PerlIO::skalar
In-Memory-IO, Skalar-IO

PerlIO::via Hilfsklasse für in Perl implementierte PerlIO-Schichten

PerlIO::via::QuotedPrint
PerlIO-Schicht für in Anführungszeichen druckbare Zeichenfolgen

Pod::Flucht
Zum Auflösen von Pod E<...>-Sequenzen

Pod::Find POD-Dokumente in Verzeichnisbäumen suchen

Pod::Funktionen
Gruppieren Sie die Funktionen von Perl a la perlfunc.pod

Pod::Html Modul zum Konvertieren von Pod-Dateien in HTML

Pod::InputObjects
Objekte, die POD-Eingabeabsätze, Befehle usw. darstellen.

Pod::Man Konvertiert POD-Daten in formatierte *roff-Eingaben

Pod::ParseLink
Analysieren Sie einen L<>-Formatierungscode im POD-Text

Pod::ParseUtils
Helfer für die POD-Analyse und -Konvertierung

Pod::Parser Basisklasse zum Erstellen von POD-Filtern und -Übersetzern

Pod::Perldoc
Suchen Sie nach der Perl-Dokumentation im Pod-Format.

Pod::Perldoc::BaseTo
Basis für Pod::Perldoc-Formatierer

Pod::Perldoc::GetOptsOO
Angepasster Optionsparser für Pod::Perldoc

Pod::Perldoc::ToANSI
Render Pod mit ANSI-Farb-Escapes

Pod::Perldoc::ToChecker
Lassen Sie Perldoc den Pod auf Fehler überprüfen

Pod::Perldoc::ToMan
Lassen Sie Perldoc Pod als Manpages rendern

Pod::Perldoc::ToNroff
Lassen Sie Perldoc Pod in nroff konvertieren

Pod::Perldoc::ToPod
Lassen Sie Perldoc Pod als ... Pod rendern!

Pod::Perldoc::ToRtf
Lassen Sie Perldoc Pod als RTF rendern

Pod::Perldoc::ToTerm
Render Pod mit Terminal-Escapes

Pod::Perldoc::ToText
Lassen Sie Perldoc Pod als Klartext rendern

Pod::Perldoc::ToTk
Lassen Sie Perldoc Tk::Pod verwenden, um Pod zu rendern

Pod::Perldoc::ToXml
Lassen Sie Perldoc Pod als XML rendern

Pod::PlainText
Konvertieren Sie POD-Daten in formatierten ASCII-Text

Pod::Select Ausgewählte Abschnitte von POD aus der Eingabe extrahieren

Pod::Einfaches Framework zum Parsen von Pod

Pod::Simple::Checker
Überprüfen Sie die Pod-Syntax eines Dokuments

Pod::Einfach::Debuggen
Versetzen Sie Pod::Simple in den Trace-/Debug-Modus

Pod::Simple::DumpAsText
Pod-Parsing-Ereignisse als Text ausgeben

Pod::Simple::DumpAsXML
Pod in XML umwandeln

Pod::Einfach::HTML
Konvertieren Sie Pod in HTML

Pod::Simple::HTMLBatch
Konvertieren Sie mehrere Pod-Dateien in mehrere HTML-Dateien

Pod::Simple::LinkSection
Stellt „Abschnitt“-Attribute von L-Codes dar

Pod::Einfach::Methode
Verwandeln Sie Pod::Simple-Ereignisse in Methodenaufrufe

Pod::Simple::PullParser
Eine Pull-Parser-Schnittstelle zum Parsen von Pod

Pod::Simple::PullParserEndToken
End-Tokens von Pod::Simple::PullParser

Pod::Simple::PullParserStartToken
Start-Tokens von Pod::Simple::PullParser

Pod::Simple::PullParserTextToken
Text-Tokens von Pod::Simple::PullParser

Pod::Simple::PullParserToken
Tokens von Pod::Simple::PullParser

Pod::Einfach::RTF
Pod als RTF formatieren

Pod::Einfach::Suche
Suchen Sie POD-Dokumente in Verzeichnisbäumen

Pod::Simple::SimpleTree
Parse Pod in einen einfachen Parse-Baum

Pod::Einfach::Unterklassenbildung
Schreiben Sie einen Formatierer als Pod::Simple-Unterklasse

Pod::Einfach::Text
Pod als Klartext formatieren

Pod::Simple::TextContent
Holen Sie sich den Textinhalt von Pod

Pod::Simple::XHTML
Formatieren Sie den Pod als validierendes XHTML

Pod::Simple::XMLOutStream
Pod in XML umwandeln

Pod::Text Konvertieren Sie POD-Daten in formatierten ASCII-Text

Pod::Text::Farbe
Konvertieren Sie POD-Daten in formatierten farbigen ASCII-Text

Pod::Text::Termcap
Konvertieren Sie POD-Daten mit Format-Escapes in ASCII-Text

Pod::Usage Gibt eine Nutzungsmeldung aus der eingebetteten Pod-Dokumentation aus

SDBM_File Begrenzter Zugriff auf SDBM-Dateien

Sicheres Kompilieren und Ausführen von Code in eingeschränkten Bereichen

Scalar :: Util
Eine Auswahl allgemein nützlicher skalarer Unterprogramme

Suche::Dikt
Suchen – Suchen Sie nach dem Schlüssel in der Wörterbuchdatei

SelectSaver Ausgewähltes Datei-Handle speichern und wiederherstellen

SelfLoader Load funktioniert nur bei Bedarf

Speicherbare Persistenz für Perl-Datenstrukturen

Sub::Util Eine Auswahl von Hilfsunterprogrammen für Subs und CODE-Referenzen

Symbol Manipulieren Sie Perl-Symbole und ihre Namen

Sys::Hostname
Probieren Sie alle erdenklichen Möglichkeiten aus, um den Hostnamen zu erhalten

Sys::Syslog Perl-Schnittstelle zum UNIX syslog(3) Anrufe

Sys::Syslog::Win32
Win32-Unterstützung für Sys::Syslog

TAP::Base Basisklasse, die allgemeine Funktionalität für TAP::Parser bereitstellt

TAP::Formatter::Base
Basisklasse für Harness-Ausgabedelegaten

TAP::Formatierer::Farbe
Führen Sie Perl-Testskripte mit Farbe aus

TAP::Formatter::Konsole
Nutzen Sie den Ausgabedelegaten für die Standardkonsolenausgabe

TAP::Formatter::Console::ParallelSession
Nutzen Sie den Ausgabedelegierten für die parallele Konsolenausgabe

TAP::Formatter::Console::Session
Nutzen Sie den Ausgabedelegaten für die Standardkonsolenausgabe

TAP::Formatierer::Datei
Nutzen Sie den Ausgabedelegaten für die Dateiausgabe

TAP::Formatter::Datei::Sitzung
Nutzen Sie den Ausgabedelegaten für die Dateiausgabe

TAP::Formatter::Sitzung
Abstrakte Basisklasse für den Harness-Ausgabedelegaten

TIPP::Geschirr
Führen Sie Testskripte mit Statistiken aus

TAP::Harness::Env
Gegebenenfalls werden Umgebungsvariablen im Zusammenhang mit dem Kabelbaum analysiert

TAP::Object Basisklasse, die allen „TAP::*“-Modulen gemeinsame Funktionalität bereitstellt

TAP::Parser TAP-Ausgabe analysieren

TAP::Parser::Aggregator
Aggregierte TAP::Parser-Ergebnisse

TAP::Parser::Grammatik
Eine Grammatik für das Test Anything Protocol.

TAP::Parser::Iterator
Basisklasse für TAP-Quelleniteratoren

TAP::Parser::Iterator::Array
Iterator für Array-basierte TAP-Quellen

TAP::Parser::Iterator::Prozess
Iterator für prozessbasierte TAP-Quellen

TAP::Parser::Iterator::Stream
Iterator für Filehandle-basierte TAP-Quellen

TAP::Parser::IteratorFactory
Ermittelt, welche SourceHandler-Objekte für eine bestimmte Quelle verwendet werden sollen

TAP::Parser::Multiplexer
Multiplexen Sie mehrere TAP::Parser

TAP::Parser::Ergebnis
Basisklasse für TAP::Parser-Ausgabeobjekte

TAP::Parser::Ergebnis::Bailout
Bailout-Ergebnis-Token.

TAP::Parser::Ergebnis::Kommentar
Kommentarergebnis-Token.

TAP::Parser::Ergebnis::Plan
Planergebnis-Token.

TAP::Parser::Ergebnis::Pragma
TAP-Pragma-Token.

TAP::Parser::Ergebnis::Test
Testergebnis-Token.

TAP::Parser::Ergebnis::Unbekannt
Unbekanntes Ergebnistoken.

TAP::Parser::Ergebnis::Version
TAP-Syntaxversionstoken.

TAP::Parser::Ergebnis::YAML
YAML-Ergebnistoken.

TAP::Parser::ResultFactory
Factory zum Erstellen von TAP::Parser-Ausgabeobjekten

TAP::Parser::Scheduler
Planen Sie Tests während paralleler Tests

TAP::Parser::Scheduler::Job
Ein einziger Testjob.

TAP::Parser::Scheduler::Spinner
Ein No-Op-Job.

TAP::Parser::Quelle
Eine TAP-Quelle und Metadaten dazu

TAP::Parser::SourceHandler
Basisklasse für verschiedene TAP-Quellenhandler

TAP::Parser::SourceHandler::Ausführbare
Streamen Sie die Ausgabe einer ausführbaren TAP-Quelle

TAP::Parser::SourceHandler::File
Streamen Sie TAP aus einer Textdatei.

TAP::Parser::SourceHandler::Handle
Streamen Sie TAP von einem IO::Handle oder einem GLOB.

TAP::Parser::SourceHandler::Perl
Streamen Sie TAP aus einer ausführbaren Perl-Datei

TAP::Parser::SourceHandler::RawTAP
Stream-Ausgabe von Raw-TAP in einer Skalar-/Array-Referenz.

TAP::Parser::YAMLish::Reader
Lesen Sie YAMLish-Daten vom Iterator

TAP::Parser::YAMLish::Writer
Schreiben Sie YAMLish-Daten

Begriff::ANSIColor
Farbbildschirmausgabe mit ANSI-Escape-Sequenzen

Term::Cap Perl-Termcap-Schnittstelle

Begriff::Vollständig
Perl-Wortvervollständigungsmodul

Begriff::ReadLine
Perl-Schnittstelle zu verschiedenen „readline“-Paketen.

Test Bietet ein einfaches Framework zum Schreiben von Testskripten

Test::Baumeister
Backend zum Erstellen von Testbibliotheken

Test::Builder::IO::Scalar
Eine Kopie von IO::Scalar für Test::Builder

Test::Builder::Module
Basisklasse für Testmodule

Test::Builder::Tester
Testen Sie Testsuiten, die mit erstellt wurden

Test::Builder::Tester::Color
Aktivieren Sie die Farbe in Test::Builder::Tester

Test::Geschirr
Führen Sie Perl-Standardtestskripte mit Statistiken aus

Test::Harness::Beyond
Jenseits von Test machen

Test::More Noch ein weiteres Framework zum Schreiben von Testskripten

Testen::Einfach
Grundlegende Dienstprogramme zum Schreiben von Tests.

Test::Tester
Vereinfachen Sie das Testen von Testmodulen, die mit Test::Builder erstellt wurden

Test::Tester::Capture
Helfen Sie beim Testen von Testmodulen, die mit Test::Builder erstellt wurden

Test::Tester::CaptureRunner
Helfen Sie beim Testen von Testmodulen, die mit Test::Builder erstellt wurden

Test::Tutorial
Ein Tutorial zum Schreiben wirklich grundlegender Tests

Test::use::ok
Alternative zu Test::More::use_ok

Text::Abkürzung
Abkürzung – Erstellen Sie eine Abkürzungstabelle aus einer Liste

Text::Ausgeglichen
Extrahieren Sie durch Trennzeichen getrennte Textsequenzen aus Zeichenfolgen.

Text::ParseWords
Analysieren Sie Text in ein Array von Tokens oder ein Array von Arrays

Text::Tabs Erweitern und entfalten Sie Tabs wie unter Unix erweitern(1) und nicht erweitern(1)

Text::Wrap Zeilenumbruch zur Bildung einfacher Absätze

Thread Threads in Perl manipulieren (nur für alten Code)

Thread::Warteschlange
Thread-sichere Warteschlangen

Thread::Semaphor
Threadsichere Semaphore

Tie::Array Basisklasse für gebundene Arrays

Tie::File Zugriff auf die Zeilen einer Festplattendatei über ein Perl-Array

Tie::Handle Basisklassendefinitionen für gebundene Handles

Tie::Hash Basisklassendefinitionen für gebundene Hashes

Tie::Hash::NamedCapture
Benannte Regexp-Erfassungspuffer

Krawatte::Merken
Fügen Sie bei Bedarf Daten zum Hash hinzu

Krawatte::RefHash
Verwenden Sie Referenzen als Hash-Schlüssel

Tie::Scalar Basisklassendefinitionen für gebundene Skalare

Tie::StdHandle
Basisklassendefinitionen für gebundene Handles

Tie::SubstrHash
Hashing mit fester Tabellengröße und fester Schlüssellänge

Zeit::HiRes Hochauflösender Alarm, Ruhezustand, Tageszeit, Intervall-Timer

Time::Local Berechnen Sie die Zeit effizient aus Ortszeit und GMT-Zeit

Time::Piece Objektorientierte Zeitobjekte

Zeit::Sekunden
Eine einfache API zum Konvertieren von Sekunden in andere Datumswerte

Zeit::gmtime
By-Name-Schnittstelle zu Perls integrierter Schnittstelle gmtime() Funktion

Zeit::Ortszeit
By-Name-Schnittstelle zu Perls integrierter Schnittstelle Ortszeit() Funktion

Time::tm Internes Objekt, das von Time::gmtime und Time::localtime verwendet wird

UNIVERSAL-Basisklasse für ALLE Klassen (gesegnete Referenzen)

Unicode::Sortieren
Unicode-Sortierungsalgorithmus

Unicode::Collate::CJK::Big5
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::CJK::GB2312
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::CJK::JISX0208
Gewichtung JIS KANJI für Unicode::Collate

Unicode::Collate::CJK::Koreanisch
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::CJK::Pinyin
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::CJK::Stroke
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::CJK::Zhuyin
Gewichtung einheitlicher CJK-Ideogramme

Unicode::Collate::Locale
Linguistische Anpassung für DUCET über Unicode::Collate

Unicode::Normalisieren
Unicode-Normalisierungsformulare

Unicode::UCD
Unicode-Zeichendatenbank

User::grent By-Name-Schnittstelle zu Perls integrierten getgr*()-Funktionen

User::pwent By-Name-Schnittstelle zu Perls integrierten getpw*()-Funktionen

VMS::DCLsym Perl-Erweiterung zum Bearbeiten von DCL-Symbolen

VMS::Filespec
Konvertieren Sie zwischen der VMS- und der Unix-Dateispezifikationssyntax

VMS::Stdio Standard-I/O-Funktionen über VMS-Erweiterungen

Win32-Schnittstellen zu einigen Win32-API-Funktionen

Win32API::Datei
Low-Level-Zugriff auf Win32-System-API-Aufrufe für Dateien/Verzeichnisse.

Win32CORE Win32 CORE-Funktions-Stubs

XS::APItest Testen Sie die Perl-C-API

XS::Typemap-Modul zum Testen der mit Perl verteilten XS-Typemaps

XSLoader Lädt C-Bibliotheken dynamisch in Perl-Code

autodie::Scope::Guard
Wrapper-Klasse zum Aufrufen von Subs am Ende des Gültigkeitsbereichs

autodie::Scope::GuardStack
Hook-Stack zum Verwalten von Bereichen über %^H

autodie::ScopeUtil
Dienstprogramme zum Verwalten von %^H-Bereichen

Version::Einbauten
Perl-Erweiterung für Versionsobjekte

Um herauszufinden, alle Module, die auf Ihrem System installiert sind, einschließlich solcher ohne Dokumentation oder
Außerhalb der Standardversion verwenden Sie einfach den folgenden Befehl (unter der Standardversion von win32
Shell sollten doppelte Anführungszeichen anstelle von einfachen Anführungszeichen verwendet werden).

% perl -MFile::Find=find -MFile::Spec::Functions -Tlwe \
'find { want => sub { print canonpath $_ if /\.pm\z/ },
no_chdir => 1 }, @INC'

(Das -T soll verhindern, dass „.“ in @INC aufgeführt wird.) Sie sollten alle ihre eigenen haben
Dokumentation installiert und über Ihr System zugänglich Mann(1) Befehl. Wenn du nicht hast
a gefunden Als Programm können Sie Perl verwenden find2perl stattdessen ein Programm, das Perl-Code generiert
Als Ausgabe können Sie Perl ausführen. Wenn Sie eine haben Mann Programm, aber es findet Ihr nicht
Module müssen Sie Ihren Manpath reparieren. Weitere Informationen finden Sie unter Perl. Wenn Sie kein System haben
Mann Befehl, Sie könnten es versuchen perldoc

Beachten Sie auch, dass Sie mit dem Befehl „perldoc perllocal“ eine (möglicherweise unvollständige) Liste erhalten
die Module, die auf Ihrem System weiter installiert wurden. (Die Datei perllocal.pod ist
durch den standardmäßigen MakeMaker-Installationsprozess aktualisiert.)

Erweiterung Module
Erweiterungsmodule werden in C (oder einer Mischung aus Perl und C) geschrieben. Sie sind normalerweise dynamisch
Sie werden bei Bedarf in Perl geladen, können aber auch statisch eingebunden werden.
Zu den unterstützten Erweiterungsmodulen gehören Socket, Fcntl und POSIX.

Viele beliebte C-Erweiterungsmodule werden aus diesem Grund nicht (zumindest nicht vollständig) im Paket geliefert
ihre Größe, Volatilität oder einfach der Mangel an Zeit für angemessene Tests und Konfiguration
auf der Vielzahl von Plattformen, auf denen Perl im Betatest getestet wurde. Sie werden dazu ermutigt
Suchen Sie nach ihnen auf CPAN (unten beschrieben) oder verwenden Sie Websuchmaschinen wie Alta Vista oder
Google.

CPAN

Module: Schaffung, Benutzen, und Missbrauch

(Der folgende Abschnitt ist direkt der Moduldatei von Tim Bunce entlehnt, verfügbar unter
Ihre nächstgelegene CPAN-Site.)

Perl implementiert eine Klasse mithilfe eines Pakets, aber das Vorhandensein eines Pakets bedeutet nicht, dass dies der Fall ist
Präsenz einer Klasse. Ein Paket ist nur ein Namespace. Eine Klasse ist ein Paket, das bereitstellt
Unterprogramme, die als Methoden verwendet werden können. Eine Methode ist nur eine Unterroutine, die as erwartet
sein erstes Argument, entweder der Name eines Pakets (für „statische“ Methoden) oder ein Verweis darauf
etwas (für „virtuelle“ Methoden).

Ein Modul ist eine Datei, die (konventionell) eine Klasse mit demselben Namen (ohne .pm) bereitstellt.
plus eine Importmethode in dieser Klasse, die aufgerufen werden kann, um exportierte Symbole abzurufen. Das
Das Modul implementiert möglicherweise einige seiner Methoden durch das Laden dynamischer C- oder C++-Objekte, aber das
sollte für den Benutzer des Moduls völlig transparent sein. Ebenso könnte das Modul eingestellt werden
Erstellen Sie eine AUTOLOAD-Funktion, um bei Bedarf Unterprogrammdefinitionen einzuschlürfen, aber das ist auch so
transparent. Nur der .pm Die Datei muss vorhanden sein. Siehe perlsub, perlobj und
AutoLoader für Details zum AUTOLOAD-Mechanismus.

Leitlinien für Modul von Vorabkalkulationen
· Gibt es bereits ähnliche Module in irgendeiner Form?

Wenn ja, versuchen Sie bitte, die vorhandenen Module entweder vollständig oder durch Vererbung wiederzuverwenden
nützliche Funktionen in eine neue Klasse. Wenn dies nicht praktikabel ist, versuchen Sie, zusammenzukommen
die Modulautoren, an der Erweiterung oder Verbesserung der Funktionalität des vorhandenen Moduls zu arbeiten
Module. Ein perfektes Beispiel ist die Fülle an Paketen in Perl4, mit denen man umgehen kann
Befehlszeilenoptionen.

Wenn Sie ein Modul schreiben, um einen bereits vorhandenen Satz von Modulen zu erweitern, wenden Sie sich bitte an uns
Abstimmung mit dem Autor des Pakets. Es hilft, wenn Sie der gleichen Benennung folgen
Schema und Modulinteraktionsschema als ursprünglicher Autor.

· Versuchen Sie, das neue Modul so zu gestalten, dass es einfach zu erweitern und wiederzuverwenden ist.

Versuchen Sie, „Warnungen zu verwenden“. (oder „Warnungen verwenden qw(...);“). Denken Sie daran, dass Sie „nein“ hinzufügen können
warnings qw(...);“ auf einzelne Codeblöcke, die weniger Warnungen benötigen.

Verwenden Sie gesegnete Referenzen. Verwenden Sie die Form von bless mit zwei Argumenten, um in die Klasse zu segnen
Name, der als erster Parameter des Konstruktors angegeben wird, z. B.:

Unter neu {
meine $klasse = Verschiebung;
return bless {}, $ class;
}

oder sogar dies, wenn Sie möchten, dass es entweder als statische oder virtuelle Methode verwendet wird.

Unter neu {
mein $self = shift;
meine $class = ref($self) || $selbst;
return bless {}, $ class;
}

Übergeben Sie Arrays als Referenzen, damit später weitere Parameter hinzugefügt werden können (es ist auch schneller).
Konvertieren Sie Funktionen gegebenenfalls in Methoden. Teilen Sie große Methoden in kleinere auf
flexiblere. Erben Sie ggf. Methoden von anderen Modulen.

Vermeiden Sie Klassennamentests wie: „die „Ungültig“, es sei denn ref $ref eq ‚FOO‘“. Im Allgemeinen du
kann den Teil „eq ‚FOO‘“ ohne Schaden löschen. Lassen Sie die Objekte betreuen
sich! Vermeiden Sie im Allgemeinen so weit wie möglich fest verankerte Klassennamen.

Vermeiden Sie „$r->Class::func()“, wo die Verwendung von „@ISA=qw(... Class ...)“ und „$r->func()“ dies tun würde
Arbeit.

Verwenden Sie Autosplit, damit wenig genutzte oder neu hinzugefügte Funktionen die Programme nicht belasten
die sie nicht benutzen. Fügen Sie dem Modul nach __END__ Testfunktionen hinzu, entweder mit
AutoSplit oder indem Sie sagen:

eval join('', ) || sterben $@, es sei denn, caller();

Besteht Ihr Modul den Test „Leere Unterklasse“? Wenn Sie sagen: „@SUBCLASS::ISA =
qw(YOURCLASS);“ Ihre Anwendungen sollten in der Lage sein, SUBCLASS genau auf die gleiche Weise zu verwenden
So wie YOURCLASS. Funktioniert Ihre Anwendung beispielsweise noch, wenn Sie Folgendes ändern: „$obj
= YOURCLASS->new();" into: "$obj = SUBCLASS->new();" ?

Vermeiden Sie es, Statusinformationen in Ihren Paketen aufzubewahren. Es macht es schwierig für
mehrere andere Pakete, die Sie nutzen können. Zustandsinformationen in Objekten aufbewahren.

Verwenden Sie immer -w.

Versuchen Sie, „streng“ zu verwenden; (oder „verwende striktes qw(...);“). Denken Sie daran, dass Sie „no strict“ hinzufügen können
qw(...);“ auf einzelne Codeblöcke, die weniger Strenge erfordern.

Verwenden Sie immer -w.

Befolgen Sie die Richtlinien in Perlstyle.

Verwenden Sie immer -w.

· Einige einfache Stilrichtlinien

Das mit Perl gelieferte Perlstyle-Handbuch enthält viele hilfreiche Punkte.

Der Codierungsstil ist eine Frage des persönlichen Geschmacks. Viele Menschen entwickeln ihren Stil weiter
mehrere Jahre lang lernen sie, was ihnen hilft, guten Code zu schreiben und zu pflegen. Hier ist eine
Reihe verschiedener Vorschläge, die von erfahrenen Entwicklern offenbar häufig verwendet werden:

Verwenden Sie Unterstriche, um Wörter zu trennen. Im Allgemeinen ist es einfacher zu lesen
$var_names_like_this statt $VarNamesLikeThis, insbesondere für Nicht-Muttersprachler von
Englisch. Es ist auch eine einfache Regel, die konsistent mit VAR_NAMES_LIKE_THIS funktioniert.

Eine Ausnahme von dieser Regel bilden Paket-/Modulnamen. Perl behält sich informell die Kleinschreibung vor
Modulnamen für „Pragma“-Module wie Integer und Strict. Andere Module normalerweise
Beginnen Sie mit einem Großbuchstaben und verwenden Sie gemischte Groß- und Kleinschreibung ohne Unterstriche (muss kurz sein).
und tragbar).

Es kann hilfreich sein, die Groß-/Kleinschreibung zu verwenden, um den Umfang oder die Art eines Dokuments anzugeben
Variable. Zum Beispiel:

Nur $ALL_CAPS_HERE-Konstanten (Vorsicht vor Konflikten mit Perl-Variablen)
$Some_Caps_Here paketweit global/statisch
$no_caps_here Funktionsumfang my() oder local() Variablen

Funktions- und Methodennamen scheinen am besten in Kleinbuchstaben geschrieben zu sein. z.B,
„$obj->as_string()“.

Sie können einen führenden Unterstrich verwenden, um anzugeben, dass eine Variable oder Funktion nicht vorhanden sein soll
wird außerhalb des Pakets verwendet, das es definiert hat.

· Wählen Sie aus, was exportiert werden soll.

Exportieren Sie KEINE Methodennamen!

Exportieren Sie standardmäßig NICHTS anderes ohne triftigen Grund!

Exporte verschmutzen den Namensraum des Modulbenutzers. Wenn Sie exportieren müssen, versuchen Sie es mit der Verwendung
Verwenden Sie @EXPORT_OK gegenüber @EXPORT und vermeiden Sie kurze oder gebräuchliche Namen, um das Risiko zu verringern
von Namenskonflikten.

Im Allgemeinen ist alles, was nicht exportiert wurde, immer noch von außerhalb des Moduls mit dem zugänglich
ModuleName::item_name (oder „$blessed_ref->method“) Syntax. Konventionell können Sie a verwenden
Führender Unterstrich bei Namen, um informell anzuzeigen, dass sie „intern“ sind und nicht
zur öffentlichen Nutzung.

(Es ist tatsächlich möglich, private Funktionen zu erhalten, indem man sagt: „my $subref = sub { ...“
}; &$subref;". Aber es gibt keine Möglichkeit, das direkt als Methode aufzurufen, weil a
(Methode muss einen Namen in der Symboltabelle haben.)

Als allgemeine Regel gilt: Wenn das Modul versucht, objektorientiert zu sein, exportiert es nichts.
Wenn es sich nur um eine Sammlung von Funktionen handelt, ist @EXPORT_OK alles andere als @EXPORT mit
Vorsicht.

· Wählen Sie einen Namen für das Modul.

Dieser Name sollte so aussagekräftig, genau und vollständig wie möglich sein. Vermeiden Sie irgendwelche
Gefahr der Unklarheit. Versuchen Sie immer, zwei oder mehr ganze Wörter zu verwenden. Im Allgemeinen der Name
sollte widerspiegeln, was das Besondere an dem ist, was das Modul tut, und nicht daran, wie es es tut.
Bitte verwenden Sie verschachtelte Modulnamen, um ein Modul informell zu gruppieren oder zu kategorisieren. Dort
sollte ein sehr guter Grund dafür sein, dass ein Modul keinen verschachtelten Namen hat. Modulnamen
sollte mit einem Großbuchstaben beginnen.

Mit 57 Modulen, die alle „Sort“ heißen, wird es niemandem das Leben leicht machen (obwohl es 23 sind).
namens Sort::Quick ist nur unwesentlich besser :-). Stellen Sie sich vor, jemand versucht zu installieren
Ihr Modul neben vielen anderen. Wenn Sie Zweifel haben, fragen Sie nach Vorschlägen
comp.lang.perl.misc.

Wenn Sie eine Reihe verwandter Module/Klassen entwickeln, empfiehlt es sich, diese zu verwenden
verschachtelte Klassen mit einem gemeinsamen Präfix, da dadurch Namespace-Konflikte vermieden werden. Zum Beispiel:
Xyz::Control, Xyz::View, Xyz::Model usw. Verwenden Sie die Module in dieser Liste als Benennung
-Guide.

Wenn Sie einem Satz ein neues Modul hinzufügen, befolgen Sie die Benennungsstandards des ursprünglichen Autors
Module und die Schnittstelle zu Methoden in diesen Modulen.

Wenn Sie Module für den privaten internen oder projektspezifischen Gebrauch entwickeln, wird dies niemals der Fall sein
der Öffentlichkeit zugänglich gemacht werden, sollten Sie sicherstellen, dass ihre Namen nicht miteinander in Konflikt geraten
jedes zukünftige öffentliche Modul. Sie können dies entweder tun, indem Sie das reservierte Local::* verwenden.
Kategorie oder indem Sie einen Kategorienamen verwenden, der einen Unterstrich wie Foo_Corp::* enthält.

Um portierbar zu sein, sollte jede Komponente eines Modulnamens auf 11 Zeichen beschränkt sein. Wenn
Es könnte unter MS-DOS verwendet werden. Versuchen Sie dann sicherzustellen, dass jedes in den ersten 8 eindeutig ist
Figuren. Verschachtelte Module erleichtern dies.

· Haben Sie es richtig verstanden?

Woher wissen Sie, dass Sie die richtigen Entscheidungen getroffen haben? Haben Sie sich für eine Schnittstelle entschieden?
Design, das später Probleme verursachen wird? Haben Sie den passendsten Namen ausgewählt? Tun
Hast du irgendwelche Fragen?

Der beste Weg, es genau zu wissen und viele hilfreiche Vorschläge zu erhalten, besteht darin, jemanden zu fragen
Wer weiß. Comp.lang.perl.misc wird von fast allen Entwicklern gelesen
Module und es ist der beste Ort, um danach zu fragen.

Sie müssen lediglich eine kurze Zusammenfassung des Moduls, seines Zwecks und seiner Schnittstellen veröffentlichen.
Ein paar Zeilen zu jeder der Hauptmethoden reichen wahrscheinlich aus. (Wenn du das Ganze postest
Modul könnte es von vielbeschäftigten Leuten ignoriert werden – im Allgemeinen von genau den Leuten, die Sie lesen möchten
es!)

Machen Sie sich keine Gedanken über die Veröffentlichung, wenn Sie nicht sagen können, wann das Modul fertig sein wird – sagen Sie es einfach
in der Nachricht. Es könnte sich lohnen, andere einzuladen, Ihnen zu helfen, vielleicht können sie es
Vervollständige es für dich!

· README und andere zusätzliche Dateien.

Es ist allgemein bekannt, dass Softwareentwickler die von ihnen verwendete Software in der Regel vollständig dokumentieren
schreiben. Wenn jedoch die Welt Ihre Software dringend benötigt und keine vorhanden ist
Wenn Sie genug Zeit haben, um die vollständige Dokumentation zu schreiben, stellen Sie bitte zumindest eine README-Datei bereit
enthält:

· Eine Beschreibung des Moduls/Pakets/der Erweiterung usw.

· Ein Urheberrechtshinweis – siehe unten.

· Voraussetzungen – was Sie sonst noch benötigen könnten.

· Wie man es erstellt – mögliche Änderungen an Makefile.PL usw.

· Wie man es installiert.

· Aktuelle Änderungen in dieser Version, insbesondere Inkompatibilitäten

· Änderungen/Erweiterungen, die Sie in der Zukunft planen.

Wenn die README-Datei zu groß zu werden scheint, möchten Sie möglicherweise einige davon aufteilen
Abschnitte in separate Dateien: INSTALL, Kopieren, ToDo usw.

· Hinzufügen eines Urheberrechtshinweises.

Wie Sie Ihre Arbeit lizenzieren, ist eine persönliche Entscheidung. Der allgemeine Mechanismus
besteht darin, Ihr Urheberrecht geltend zu machen und dann eine Erklärung darüber abzugeben, wie andere dies tun dürfen
Ihre Arbeit kopieren/verwenden/ändern.

Perl wird beispielsweise mit zwei Arten von Lizenzen ausgeliefert: der GNU GPL und der
Künstlerische Lizenz (siehe die Dateien README, Copying und Artistic oder perlgpl und
perlartistisch). Larry hat gute Gründe, NICHT nur die GNU GPL zu verwenden.

Meine persönliche Empfehlung aus Respekt vor Larry, Perl und der Perl-Community
im Großen und Ganzen bedeutet etwas einfach so zu sagen:

Copyright (c) 1995 Ihr Name. Alle Rechte vorbehalten.
Dieses Programm ist freie Software; Sie können es weiterverbreiten und/oder
Ändern Sie es unter den gleichen Bedingungen wie Perl selbst.

Diese Anweisung sollte zumindest in der README-Datei erscheinen. Vielleicht möchten Sie es auch
Fügen Sie es in eine Kopierdatei und Ihre Quelldateien ein. Denken Sie daran, den anderen einzubeziehen
Wörter zusätzlich zum Urheberrecht.

· Geben Sie dem Modul eine Versions-/Ausgabe-/Releasenummer.

Um vollständig mit den Exporter- und MakeMaker-Modulen kompatibel zu sein, sollten Sie diese speichern
die Versionsnummer Ihres Moduls in einer nicht zu meinem Paket gehörenden Variablen namens $VERSION. Das
sollte eine positive Gleitkommazahl mit mindestens zwei Ziffern nach dem sein
dezimal (d. h. Hundertstel, z. B. „$VERSION = „0.01““). Verwenden Sie keinen „1.3.2“-Stil
Ausführung. Weitere Informationen finden Sie unter Exporter.

Es kann hilfreich sein, eine Funktion oder Methode zum Abrufen der Nummer hinzuzufügen. Benutzen Sie die
Nummer in Ankündigungen und Archivdateinamen bei der Veröffentlichung des Moduls
(Modulname-1.02.tar.Z). Weitere Informationen finden Sie unter perldoc ExtUtils::MakeMaker.pm.

· So veröffentlichen und verteilen Sie ein Modul.

Es ist eine gute Idee, eine Ankündigung über die Verfügbarkeit Ihres Moduls (oder des Moduls) zu veröffentlichen
Modul selbst, falls klein) in die Usenet-Newsgroup comp.lang.perl.announce einbinden. Das
wird zumindest eine sehr breite, einmalige Verbreitung gewährleisten.

Wenn möglich, registrieren Sie das Modul beim CPAN. Sie sollten Einzelheiten dazu angeben
Geben Sie den Standort in Ihrer Ankündigung an.

Einige Hinweise zu FTP-Archiven: Bitte verwenden Sie einen langen, beschreibenden Dateinamen
enthält die Versionsnummer. Bei den meisten eingehenden Verzeichnissen ist dies nicht der Fall
lesbar/auflistbar, d. h. Sie können Ihre Datei nach dem Hochladen nicht mehr sehen.
Denken Sie daran, Ihre E-Mail-Benachrichtigung so bald wie möglich zu senden
Beim Hochladen wird Ihre Datei sonst möglicherweise automatisch gelöscht. Warten Sie, bis die Datei fertig ist
verarbeitet werden und/oder überprüfen Sie, ob die Datei verarbeitet wurde, bevor Sie dies ankündigen

FTP-Archive für Perl-Module:

Folgen Sie den Anweisungen und Links auf:

http://www.cpan.org/modules/00modlist.long.html
http://www.cpan.org/modules/04pause.html

oder auf eine dieser Seiten hochladen:

https://pause.kbx.de/pause/
http://pause.perl.org/

und benachrichtigen[E-Mail geschützt] >.

Über die WWW-Schnittstelle können Sie den Upload-Server bitten, Ihre Module zu spiegeln
von Ihrer FTP- oder WWW-Site in Ihr eigenes Verzeichnis auf CPAN!

Bitte denken Sie daran, mir einen aktualisierten Eintrag für die Modulliste zu senden!

· Seien Sie vorsichtig, wenn Sie ein freigegebenes Modul ändern.

Bemühen Sie sich stets, mit früheren veröffentlichten Versionen kompatibel zu bleiben. Ansonsten versuchen Sie es
einen Mechanismus hinzuzufügen, um zum alten Verhalten zurückzukehren, wenn sich Menschen darauf verlassen. Dokumentieren
inkompatible Änderungen.

Leitlinien für weiterverarbeitende Industrie Perl 4 Bibliothek Scripts in Module
· Es besteht keine Verpflichtung, etwas umzuwandeln.

Wenn es nicht kaputt ist, reparieren Sie es nicht! Perl 4-Bibliotheksskripte sollten weiterhin funktionieren
keine Probleme. Möglicherweise müssen Sie einige kleinere Änderungen vornehmen (z. B. das Escapezeichen für Nicht-Array-@s in
Zeichenfolgen in doppelten Anführungszeichen), es besteht jedoch keine Notwendigkeit, eine .pl-Datei in ein Modul für zu konvertieren
nur das.

· Bedenken Sie die Auswirkungen.

Alle Perl-Anwendungen, die das Skript verwenden, müssen (leicht) geändert werden.
wenn das Skript in ein Modul umgewandelt wird. Lohnt es sich, es sei denn, Sie planen es?
andere Änderungen gleichzeitig?

· Nutzen Sie die Gelegenheit.

Wenn Sie das Skript in ein Modul konvertieren möchten, können Sie die Gelegenheit dazu nutzen
die Schnittstelle neu gestalten. Die oben genannten Richtlinien für die Modulerstellung umfassen viele davon
Themen, die Sie berücksichtigen sollten.

· Das Dienstprogramm pl2pm erleichtert Ihnen den Einstieg.

Dieses Dienstprogramm liest *.pl-Dateien (als Parameter angegeben) und schreibt entsprechende *.pm
Dateien. Die pl2pm-Dienstprogramme führen Folgendes aus:

· Fügt die Standard-Modul-Prologzeilen hinzu

· Konvertiert Paketspezifizierer von ' in ::

· Konvertiert die(...) in croak(...)

· Mehrere weitere kleinere Änderungen

Da es sich um einen mechanischen Prozess handelt, ist pl2pm nicht kugelsicher. Der konvertierte Code wird benötigt
sorgfältige Prüfung, insbesondere etwaiger Packungsangaben. Löschen Sie nicht die ursprüngliche .pl-Datei
Datei, bis die neue .pm funktioniert!

Leitlinien für Wiederverwendung Anwendungsbereiche Code
· Vollständige Anwendungen gehören selten in die Perl-Modulbibliothek.

· Viele Anwendungen enthalten Perl-Code, der wiederverwendet werden könnte.

Helfen Sie mit, die Welt zu retten! Teilen Sie Ihren Code in einer Form, die eine einfache Wiederverwendung ermöglicht.

· Teilen Sie den wiederverwendbaren Code in eine oder mehrere separate Moduldateien auf.

· Nutzen Sie die Gelegenheit, die Schnittstellen zu überdenken und neu zu gestalten.

· In manchen Fällen kann die „Anwendung“ dann auf ein kleines Maß reduziert werden

Codefragment, das auf den wiederverwendbaren Modulen aufbaut. In diesen Fällen ist die Anwendung
könnte aufgerufen werden als:

% perl -e 'use Module::Name; method(@ARGV)' ...
or
% perl -mModule::Name ... (in perl5.002 oder höher)

HINWEIS

Perl erzwingt keine privaten und öffentlichen Teile seiner Module, wie Sie es vielleicht gewohnt sind
in anderen Sprachen wie C++, Ada oder Modula-17. Perl hat keine Vorliebe dafür
erzwungene Privatsphäre. Es wäre Ihnen lieber, wenn Sie sich von seinem Wohnzimmer fernhalten würden, weil Sie
wurden nicht eingeladen, nicht weil es eine Schrotflinte hat.

Das Modul und sein Benutzer haben einen Vertrag, der zum Teil Common Law und zum Teil Common Law ist
"geschrieben". Teil des Common-Law-Vertrags ist, dass ein Modul keinen Namespace verschmutzt
es wurde nicht darum gebeten. Der schriftliche Vertrag für das Modul (AKA-Dokumentation) kann erfolgen
sonstige Rückstellungen. Aber wenn Sie „RedefineTheWorld“ verwenden, wissen Sie, dass Sie es sind
Sie definieren die Welt neu und sind bereit, die Konsequenzen zu tragen.

Verwenden Sie perlmodlib online über die Dienste von onworks.net