Perl Language
Pakketten en modules

Syntaxis

• vereisen module :: naam; # Vereisen op naam van @INC
• vereist "pad / naar / file.pm"; # Vereisen per relatief pad van @INC
• gebruik Module :: Naam; # vereisen en standaardimport bij BEGIN
• gebruik Module :: Naam (); # vereisen en geen import bij BEGIN
• gebruik Module :: Naam (@ARGS); # vereisen en importeren met args bij BEGIN
• gebruik Module :: Naam VERSIE; # vereist, versiecontrole en standaardimport bij BEGIN
• gebruik Module :: Naam VERSION (); # vereist, versiecontrole en geen import bij BEGIN
• gebruik Module :: Naam VERSIE (@ARGS); # vereisen, versiecontrole, importeren met args bij BEGIN
• doe "pad / naar / file.pl"; # laad en evalueer het gegeven bestand

De inhoud van een ander bestand uitvoeren

do './config.pl';

Dit leest de inhoud van het config.pl-bestand en voert het uit. (Zie ook: perldoc -f do .)

NB: Vermijd do tenzij golfen of zoiets, want er is geen foutcontrole. Gebruik require of use voor het opnemen van bibliotheekmodules.

Een module laden tijdens runtime

require Exporter;

Dit zorgt ervoor dat de Exporter tijdens runtime wordt geladen als deze nog niet is geïmporteerd. (Zie ook: perldoc -f require .)

NB: De meeste gebruikers moeten use modules in plaats van require hen. In tegenstelling tot use , require niet bellen met de module's import-methode en wordt uitgevoerd tijdens runtime, niet tijdens het compileren.

Deze manier om modules te laden is handig als u niet kunt beslissen welke modules u nodig hebt voor runtime, zoals met een plug-insysteem:

package My::Module;
my @plugins = qw( One Two );
foreach my $plugin (@plugins) {
    my $module = __PACKAGE__ . "::Plugins::$plugin";
    $module =~ s!::!/!g;
    require "$module.pm";
}

Dit zou proberen My::Package::Plugins::One en My::Package::Plugins::Two . @plugins moeten natuurlijk afkomstig zijn van gebruikersinvoer of een configuratiebestand om dit logisch te maken. Let op de substitutieoperator s!::!/!g die elk paar dubbele punten vervangt door een schuine streep. Dit komt omdat je modules kunt laden met behulp van de bekende module naam syntax van use alleen als de naam van de module is een bareword. Als u een tekenreeks of een variabele doorgeeft, moet deze een bestandsnaam bevatten.

Een module gebruiken

use Cwd;

Hiermee wordt de Cwd module tijdens het compileren geïmporteerd en worden de standaardsymbolen geïmporteerd, dat wil zeggen dat sommige variabelen en functies van de module beschikbaar worden gemaakt voor de code die deze gebruikt. (Zie ook: perldoc -f use .)

Over het algemeen zal dit het juiste doen. Soms wilt u echter bepalen welke symbolen worden geïmporteerd. Voeg een lijst met symbolen toe na de modulenaam om te exporteren:

use Cwd 'abs_path';

Als u dit doet, worden alleen de symbolen die u opgeeft geïmporteerd (dat wil zeggen dat de standaardset niet wordt geïmporteerd).

Wanneer u meerdere symbolen importeert, is het idiomatisch om de constructieconstructie qw() te gebruiken:

use Cwd qw(abs_path realpath);

Sommige modules exporteren een subset van hun symbolen, maar kunnen worden verteld dat ze alles moeten exporteren met :all :

use Benchmark ':all';

(Merk op dat niet alle modules de tag :all herkennen of gebruiken).

Een module in een map gebruiken

use lib 'includes';
use MySuperCoolModule;

use lib 'includes'; voegt de relatieve map toe includes/ als een ander zoekpad voor @INC in @INC . MySyperCoolModule.pm dus van uit dat je een modulebestand MySyperCoolModule.pm includes/ , dat bevat:

package MySuperCoolModule;

Als u wilt, kunt u zoveel modules van uw eigen groep in één map groeperen en ze vindbaar maken met één use lib instructie.

Op dit moment vereist het gebruik van de subroutines in de module het voorafgaan van de naam van de subroutine met de pakketnaam:

MySuperCoolModule::SuperCoolSub_1("Super Cool String");

Om de subroutines zonder het voorvoegsel te kunnen gebruiken, moet u de namen van de subroutines exporteren zodat ze worden herkend door het programma dat ze aanroept. Exporteren kan automatisch worden ingesteld, dus:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT = ('SuperCoolSub_1', 'SuperCoolSub_2');

Vervolgens in het bestand dat use is de module, die subroutines zal automatisch beschikbaar zijn:

use MySuperCoolModule;
SuperCoolSub_1("Super Cool String");

Of u kunt de module instellen om voorwaardelijk subroutines te exporteren, dus:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT_OK = ('SuperCoolSub_1', 'SuperCoolSub_2');

In dat geval moet u de gewenste subroutines die worden uitgevoerd in het script dat uitdrukkelijk vraagt use is de module:

use MySuperCoolModule 'SuperCoolSub_1';
SuperCoolSub_1("Super Cool String");

CPAN.pm

CPAN.pm is een Perl-module waarmee modules van CPAN-sites kunnen worden CPAN.pm en geïnstalleerd.

Het ondersteunt interactieve modus aangeroepen met

cpan

of

perl -MCPAN -e shell

Opvragen modules

Bij naam:

cpan> m MooseX::YAML

Door een regex tegen modulenaam:

cpan> m /^XML::/

Opmerking: naar een semafoon of omleiden naar een bestand gebruik mogelijk te maken | of > shell-omleiding (spaties zijn verplicht rond de | en > ), bijvoorbeeld: m /^XML::/ | less .

Door distributie:

cpan> d LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Modules installeren

Bij naam:

cpan> install MooseX::YAML

Door distributie:

cpan> install LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Lijst met alle geïnstalleerde modules

Van opdrachtregel:

cpan -l

Uit een Perl-script:

use ExtUtils::Installed;
my $inst = ExtUtils::Installed->new();
my @modules = $inst->modules();