Perl Language
Paket och moduler

Syntax

• kräver modul :: namn; # Kräv med namn från @INC
• kräva "sökväg / till / fil.pm"; # Kräv efter relativ väg från @INC
• använd modul :: namn; # kräver och standardimport vid BEGIN
• använd modul :: Namn (); # kräver och ingen import på BEGIN
• använd modul :: namn (@ARGS); # kräva och importera med args på BEGIN
• använd modul :: Namn VERSION; # kräva, versionskontroll och standardimport vid BEGIN
• använd modul :: Namn VERSION (); # kräva, versionskontroll och ingen import vid BEGIN
• använd modul :: Namn VERSION (@ARGS); # kräva, versionskontroll, import med args på BEGIN
• gör "sökväg / till / fil.pl"; # ladda och utvärdera den givna filen

Utför innehållet i en annan fil

do './config.pl';

Detta läser in innehållet i filen config.pl och kör den. (Se även: perldoc -f do .)

OBS: Undvik att do inte golf eller något eftersom det inte finns några felkontroller. För att inkludera biblioteksmoduler, require eller use .

Laddar en modul vid körning

require Exporter;

Detta säkerställer att Exporter modulen laddas vid körning om den inte redan har importerats. (Se även: perldoc -f require .)

OBS: De flesta användare bör use moduler snarare än att require dem. Till skillnad från use require inte call modulens importmetod och körs under körning, inte under kompilering.

Det här sättet att ladda moduler är användbart om du inte kan bestämma vilka moduler du behöver före körning, till exempel med ett plugin-system:

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

Detta skulle försöka ladda My::Package::Plugins::One and My::Package::Plugins::Two . @plugins borde naturligtvis komma från någon användarinmatning eller en konfigurationsfil för att detta ska vara meningsfullt. Observera substitutionsoperatören s!::!/!g som ersätter varje kolonpar med en snedstreck. Detta beror på att du bara kan ladda moduler med den bekanta modulens syntax från use om modulnamnet är ett barord. Om du passerar en sträng eller en variabel måste den innehålla ett filnamn.

Med hjälp av en modul

use Cwd;

Detta kommer att importera Cwd modulen vid sammanställningstiden och importera dess standardsymboler, dvs göra några av modulens variabler och funktioner tillgängliga för koden som använder den. (Se även: perldoc -f use .)

I allmänhet kommer detta att göra rätt sak. Ibland vill du dock styra vilka symboler som importeras. Lägg till en lista med symboler efter modulnamnet som ska exporteras:

use Cwd 'abs_path';

Om du gör detta importeras endast de symboler du anger (dvs. standarduppsättningen importeras inte).

När du importerar flera symboler är det idiomatiskt att använda listan för att bygga qw() :

use Cwd qw(abs_path realpath);

Vissa moduler exporterar en delmängd av sina symboler, men kan få höra att exportera allt med :all :

use Benchmark ':all';

(Observera att inte alla moduler känner igen eller använder taggen :all ).

Använda en modul i en katalog

use lib 'includes';
use MySuperCoolModule;

use lib 'includes'; lägger till den relativa katalogen includes/ som en annan @INC i @INC . Så antar att du har en MySyperCoolModule.pm inuti includes/ , som innehåller:

package MySuperCoolModule;

Om du vill kan du gruppera så många egna moduler i en enda katalog och göra dem tillgängliga med en- use lib sats.

Vid denna punkt kräver du att du använder subroutinerna i modulen prefixing av subroutine-namnet med paketnamnet:

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

För att kunna använda subroutines utan prefixet måste du exportera subroutine-namnen så att de känns igen av programmet som kallar dem. Export kan ställas in för att vara automatisk, alltså:

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

Sedan i filen som use s-modulen kommer dessa underprogram automatiskt att vara tillgängliga:

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

Eller så kan du ställa in modulen för att villkorligt exportera subroutiner, således:

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

I vilket fall måste du uttryckligen begära att de önskade subroutinerna ska exporteras i skriptet som use s-modulen:

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

CPAN.pm

CPAN.pm är en Perl-modul som gör det möjligt att fråga och installera moduler från CPAN-webbplatser.

Det stöder interaktivt läge som åberopas med

cpan

eller

perl -MCPAN -e shell

Frågor om moduler

Vid namn:

cpan> m MooseX::YAML

Genom en regex mot modulnamn:

cpan> m /^XML::/

Obs: för att aktivera en personsökare eller omdirigera till en filanvändning | eller > shell omdirigering (mellanslag är obligatoriska runt | och > ), t.ex.: m /^XML::/ | less .

Efter distribution:

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

Installera moduler

Vid namn:

cpan> install MooseX::YAML

Efter distribution:

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

Lista alla installerade moduler

Från kommandoraden:

cpan -l

Från ett Perl-skript:

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