perlmod - Online sa Cloud

PROGRAMA:

NAME

perlmod - Mga module ng Perl (mga pakete at mga talahanayan ng simbolo)

DESCRIPTION

Is ito ang dokumento ikaw ay pagkatapos?
Mayroong iba pang mga dokumento na maaaring naglalaman ng impormasyon na iyong hinahanap:

Itong doc
Perl's packages, namespaces, at ilang impormasyon sa mga klase.

perlnewmod
Tutorial sa paggawa ng bagong module.

perlmodstyle
Pinakamahuhusay na kagawian para sa paggawa ng bagong module.

Pakete
Nagbibigay ang Perl ng mekanismo para sa mga alternatibong namespace para protektahan ang mga pakete mula sa pagtapak
mga variable ng bawat isa. Sa katunayan, wala talagang ganoong bagay bilang isang global variable sa
Perl. Idineklara ng package statement ang compilation unit bilang nasa ibinigay
namespace. Ang saklaw ng deklarasyon ng package ay mula sa mismong deklarasyon hanggang
ang dulo ng kalakip na bloke, "eval", o file, alinman ang mauna (kaparehong saklaw ng
ang aking() at lokal() mga operator). Malalagay dito ang mga hindi kwalipikadong dynamic na identifier
namespace, maliban sa ilang mga identifier na kung hindi kwalipikado, default sa pangunahing
package sa halip na ang kasalukuyang isa tulad ng inilarawan sa ibaba. Nakakaapekto lang ang isang package statement
mga dynamic na variable--kabilang ang mga nagamit mo lokal() sa--ngunit hindi mga variable na leksikal
nilikha gamit ang aking(). Kadalasan ito ang magiging unang deklarasyon sa isang file na kasama ng
"do", "require", o "use" operators. Maaari kang lumipat sa isang pakete sa higit sa isa
lugar; naiimpluwensyahan lamang nito kung aling talahanayan ng simbolo ang ginagamit ng compiler para sa natitirang bahagi ng
bloke na iyon. Maaari kang sumangguni sa mga variable at filehandle sa ibang mga pakete sa pamamagitan ng paglalagay ng prefix sa
identifier na may pangalan ng package at double colon: $Package::Variable. Kung ang pakete
ang pangalan ay null, ang "pangunahing" pakete ay ipinapalagay. Ibig sabihin, ang $::sail ay katumbas ng
$main:: layag.

Ang lumang package delimiter ay isang solong quote, ngunit double colon na ngayon ang mas gusto
delimiter, sa isang bahagi dahil ito ay mas nababasa ng mga tao, at sa isang bahagi dahil ito ay higit pa
nababasa sa emacs mga macro. Pinaparamdam din nito sa mga programmer ng C++ na alam nila kung ano ang nangyayari
on--kumpara sa paggamit ng nag-iisang quote bilang separator, na nandoon para gawing Ada
parang alam ng mga programmer kung ano ang nangyayari. Dahil ang makalumang syntax ay
sinusuportahan pa rin para sa pabalik na compatibility, kung susubukan mong gumamit ng string tulad ng "This is
$owner's house", maa-access mo ang $owner::s; iyon ay, ang $s variable sa package
"may-ari", na malamang na hindi ang ibig mong sabihin. Gumamit ng mga braces upang i-disambiguate, tulad ng sa "Ito ay
bahay ni ${owner}".

Maaaring naglalaman ang mga package ng mga separator ng package, tulad ng sa $OUTER::INNER::var. Ito
walang ipinahihiwatig tungkol sa pagkakasunud-sunod ng mga paghahanap ng pangalan, gayunpaman. Walang mga kamag-anak na pakete:
lahat ng mga simbolo ay alinman sa lokal sa kasalukuyang pakete, o dapat na ganap na kwalipikado mula sa
ibaba ang pangalan ng panlabas na pakete. Halimbawa, wala kahit saan sa loob ng package na "OUTER" iyon
Ang $INNER::var ay tumutukoy sa $OUTER::INNER::var. Ang "INNER" ay tumutukoy sa isang ganap na hiwalay na global
Pakete.

Tanging mga identifier na nagsisimula sa mga titik (o underscore) ang nakaimbak sa simbolo ng package
mesa. Ang lahat ng iba pang mga simbolo ay pinananatili sa package na "pangunahing", kasama ang lahat ng mga variable ng bantas,
tulad ng $_. Bilang karagdagan, kapag hindi kwalipikado, ang mga identifier na STDIN, STDOUT, STDERR, ARGV,
Ang ARGVOUT, ENV, INC, at SIG ay pinipilit na maging "pangunahing" package, kahit na ginamit para sa iba pang
mga layunin kaysa sa kanilang mga built-in. Kung mayroon kang package na tinatawag na "m", "s", o "y", kung gayon
hindi mo magagamit ang kwalipikadong anyo ng isang identifier dahil sa halip ito ang bibigyang-kahulugan
bilang isang pattern match, isang substitution, o isang transliteration.

Ang mga variable na nagsisimula sa underscore ay dating pinipilit sa package main, ngunit napagpasyahan namin ito
ay mas kapaki-pakinabang para sa mga manunulat ng pakete upang magamit ang nangungunang underscore upang ipahiwatig
mga pribadong variable at pangalan ng pamamaraan. Gayunpaman, ang mga variable at function na pinangalanan sa isang solong
Ang "_", tulad ng $_ at "sub _", ay pinipilit pa rin sa package na "main". Tingnan din ang "Ang
Syntax ng Variable Names" sa perlvar.

"eval"ed strings ay pinagsama-sama sa package kung saan ang eval() ay pinagsama-sama.
(Gayunpaman, ang mga takdang-aralin sa $SIG{}, ay ipinapalagay na ang tinukoy na tagapangasiwa ng signal ay nasa "pangunahing"
pakete. Kwalipikado ang pangalan ng tagahawak ng signal kung nais mong magkaroon ng tagapangasiwa ng signal sa a
package.) Para sa isang halimbawa, suriin perldb.pl sa Perl library. Ito sa una ay lumipat
sa package na "DB" para hindi makagambala ang debugger sa mga variable sa program
sinusubukan mong i-debug. Sa iba't ibang mga punto, gayunpaman, ito ay pansamantalang lumilipat pabalik sa
"pangunahing" package upang suriin ang iba't ibang mga expression sa konteksto ng "pangunahing" package (o
saan ka man nanggaling). Tingnan ang perldebug.

Ang espesyal na simbolo na "__PACKAGE__" ay naglalaman ng kasalukuyang pakete, ngunit hindi (madaling) magamit
upang bumuo ng mga variable na pangalan.

Tingnan ang perlsub para sa iba pang isyung saklaw na nauugnay sa aking() at lokal(), at perlref tungkol sa
pagsasara.

Icon Mga Table
Ang talahanayan ng simbolo para sa isang pakete ay nagkataon na nakaimbak sa hash ng pangalang iyon na may dalawa
idinagdag ang mga tutuldok. Ang pangalan ng talahanayan ng pangunahing simbolo ay %main::, o %:: para sa maikli.
Gayundin ang talahanayan ng simbolo para sa nested package na binanggit kanina ay pinangalanan
%OUTER::INNER::.

Ang halaga sa bawat entry ng hash ay ang iyong tinutukoy kapag ginamit mo ang *name
notasyon ng typeglob.

local *main::foo = *main::bar;

Maaari mong gamitin ito upang i-print ang lahat ng mga variable sa isang pakete, halimbawa. Ang pamantayan
ngunit antiquated dumpvar.pl library at ang CPAN module Devel::Symdump gamitin ito.

Ang mga resulta ng paglikha ng mga bagong entry sa talahanayan ng simbolo nang direkta o pagbabago ng anumang mga entry na iyon
ay hindi pa typeglobs ay hindi natukoy at napapailalim sa pagbabago sa pagitan ng mga release ng perl.

Ang pagtatalaga sa isang typeglob ay nagsasagawa ng isang pagpapatakbo ng aliasing, ibig sabihin,

*titi = *richard;

nagiging sanhi ng mga variable, subroutine, format, at file at directory handle na naa-access sa pamamagitan ng
identifier "richard" din na ma-access sa pamamagitan ng identifier na "dick". Kung gusto mo
alias lamang ng isang partikular na variable o subroutine, magtalaga ng reference sa halip:

*titi = \$richard;

Na ginagawang parehong variable sina $richard at $dick, ngunit iniiwan sina @richard at @dick bilang
hiwalay na mga array. Nakakalito, eh?

Mayroong isang banayad na pagkakaiba sa pagitan ng mga sumusunod na pahayag:

*foo = *bar;
*foo = \$bar;

Ginagawa ng "*foo = *bar" na magkasingkahulugan ang mga typeglob habang ginagawa ng "*foo = \$bar" ang
Ang mga bahagi ng SCALAR ng dalawang magkaibang typeglob ay tumutukoy sa parehong halaga ng scalar. Ibig sabihin nito
ang sumusunod na code:

$bar = 1;
*foo = \$bar; # Gawing alias ang $foo para sa $bar

{
lokal na $bar = 2; # Paghigpitan ang mga pagbabago upang harangan
i-print ang $foo; # Mga Print '1'!
}

Magpi-print ng '1', dahil ang $foo ay mayroong reference sa orihinal $bar. Yung dati
pinalamanan ng "local()" at ibabalik kapag natapos na ang block. kasi
Ang mga variable ay ina-access sa pamamagitan ng typeglob, maaari mong gamitin ang "*foo = *bar" upang lumikha ng isang alias
na maaaring ma-localize. (Ngunit magkaroon ng kamalayan na nangangahulugan ito na hindi ka maaaring magkaroon ng hiwalay na @foo at
@bar, atbp.)

Ang nagpapahalaga sa lahat ng ito ay ang Exporter module ay gumagamit ng glob aliasing bilang ang
mekanismo ng pag-import/pag-export. Kung maaari mong maayos na i-localize ang isang variable na naging
na-export mula sa isang module ay depende sa kung paano ito na-export:

@EXPORT = qw($FOO); # Karaniwang anyo, hindi ma-localize
@EXPORT = qw(*FOO); # Maaaring i-localize

Maaari mong ayusin ang unang kaso sa pamamagitan ng paggamit ng ganap na kwalipikadong pangalan ($Package::FOO) kung saan
kailangan mo ng lokal na halaga, o sa pamamagitan ng pag-override nito sa pamamagitan ng pagsasabi ng "*FOO = *Package::FOO" sa iyong
script.

Ang mekanismong "*x = \$y" ay maaaring gamitin upang ipasa at ibalik ang mga murang sanggunian sa o mula
subroutines kung ayaw mong kopyahin ang buong bagay. Gumagana lamang ito kapag nagtalaga sa
mga dynamic na variable, hindi lexical.

%some_hash = (); # can't be my()
*some_hash = fn( \%another_hash );
sub fn {
lokal *hashsym = shift;
# ngayon ay gumagamit ng %hashsym nang normal, at ikaw
# ay makakaapekto sa %another_hash ng tumatawag
aking %nhash = (); # gawin mo ang gusto mo
ibalik ang \%nhash;
}

Sa pagbabalik, mao-overwrite ng reference ang hash slot sa talahanayan ng simbolo na tinukoy ng
*some_hash typeglob. Ito ay isang medyo nakakalito na paraan ng pagpasa sa mga sanggunian nang mura
kapag ayaw mong tandaan na tahasang i-dereference ang mga variable.

Ang isa pang paggamit ng mga talahanayan ng simbolo ay para sa paggawa ng "pare-pareho" na mga scalar.

*PI = \3.14159265358979;

Ngayon ay hindi mo na mababago ang $PI, na marahil ay isang magandang bagay sa lahat. Hindi ito pareho
bilang isang pare-parehong subroutine, na napapailalim sa pag-optimize sa oras ng pag-compile. Isang pare-pareho
ang subroutine ay isang prototype na walang mga argumento at para magbalik ng pare-parehong expression.
Tingnan ang perlsub para sa mga detalye sa mga ito. Ang "use constant" pragma ay isang maginhawang shorthand para sa
ang mga ito

Maaari mong sabihin ang *foo{PACKAGE} at *foo{NAME} para malaman kung anong pangalan at package ang *foo na simbolo
galing sa table entry. Ito ay maaaring maging kapaki-pakinabang sa isang subroutine na pumasa sa mga typeglob bilang
mga argumento:

subidentify_typeglob {
aking $glob = shift;
print 'You gave me', *{$glob}{PACKAGE},
'::', *{$glob}{NAME}, "\n";
}
identify_typeglob *foo;
identify_typeglob *bar::baz;

Ito ay nagpi-print

Binigyan mo ako ng main::foo
Binigyan mo ako ng bar::baz

Ang *foo{THING} notation ay maaari ding gamitin upang makakuha ng mga reference sa mga indibidwal na elemento
ng *foo. Tingnan ang perlref.

Ang mga subroutine na kahulugan (at mga deklarasyon, para sa bagay na iyon) ay hindi kinakailangan
nakatayo sa pakete kung saan ang mesa ng simbolo ay inookupahan nila. Maaari mong tukuyin ang isang subroutine
sa labas ng package nito sa pamamagitan ng tahasang pagkwalipika sa pangalan ng subroutine:

pangunahing pakete;
sub Some_package::foo { ... } # &foo na tinukoy sa Some_package

Ito ay isang shorthand lamang para sa isang typeglob na pagtatalaga sa oras ng pag-compile:

BEGIN { *Some_package::foo = sub { ... } }

at ito ay hindi katulad ng pagsulat:

{
pakete Some_package;
sub foo {... }
}

Sa unang dalawang bersyon, ang katawan ng subroutine ay leksikal sa pangunahing pakete,
hindi sa Some_package. Kaya isang bagay tulad nito:

pangunahing pakete;

$Some_package::name = "fred";
$main::name = "barney";

sub Some_package::foo {
print "sa ", __PACKAGE__, ": \$pangalan ay '$pangalan'\n";
}

Some_package::foo();

mga kopya:

sa pangunahing: $name ay 'barney'

sa halip na:

sa Some_package: $name ay 'fred'

Mayroon din itong mga implikasyon para sa paggamit ng SUPER:: qualifier (tingnan ang perlobj).

MAGSIMULA, UNITCHECK, Suriin, INIT at END
Limang espesyal na pinangalanang mga bloke ng code ay isinasagawa sa simula at sa dulo ng isang pagtakbo
Perl na programa. Ito ang mga bloke na "BEGIN", "UNITCHECK", "CHECK", "INIT", at "END".

Ang mga bloke ng code na ito ay maaaring lagyan ng prefix na "sub" upang maipakita ang hitsura ng isang subroutine
(bagaman hindi ito itinuturing na magandang istilo). Dapat tandaan ng isa na ang mga bloke ng code na ito
hindi talaga umiiral bilang pinangalanang mga subroutine (sa kabila ng kanilang hitsura). Ang bagay na nagbibigay
ito ang layo ay ang katotohanan na maaari kang magkaroon mas marami pang kaysa isa ng mga bloke ng code na ito sa isang programa,
at makukuha nila lahat naisakatuparan sa naaangkop na sandali. Kaya hindi mo maaaring isagawa ang alinman sa
ang mga code na ito ay hinaharangan ayon sa pangalan.

Ang isang "BEGIN" na bloke ng code ay isinasagawa sa lalong madaling panahon, iyon ay, sa sandaling ito ay ganap na
tinukoy, kahit na bago ma-parse ang natitirang file (o string). Maaaring mayroon ka
maramihang "BEGIN" block sa loob ng isang file (o eval'ed string); ipapatupad nila sa pagkakasunud-sunod ng
kahulugan. Dahil ang isang "BEGIN" na bloke ng code ay ipapatupad kaagad, maaari itong kumuha ng mga kahulugan
ng mga subroutine at tulad nito mula sa iba pang mga file sa oras na makikita ng natitirang bahagi ng compile
at oras ng pagtakbo. Sa sandaling tumakbo ang isang "BEGIN", ito ay agad na hindi natukoy at anumang code na ginamit nito ay
bumalik sa memory pool ni Perl.

Ang isang "END" na bloke ng code ay isinasagawa nang huli hangga't maaari, iyon ay, pagkatapos na matapos ang perl
pagpapatakbo ng programa at bago lumabas ang interpreter, kahit na ito ay lalabas
bilang isang resulta ng isang mamatay () function. (Ngunit hindi kung ito ay morphing sa isa pang programa sa pamamagitan ng
"exec", o tinatangay ng tubig sa pamamagitan ng isang senyas--kailangan mong bitag iyon sa iyong sarili (kung
magagawa mo).) Maaaring mayroon kang maramihang "END" na mga bloke sa loob ng isang file--patupad ang mga ito nang baligtad
pagkakasunud-sunod ng kahulugan; iyon ay: huling pumasok, unang lumabas (LIFO). Ang mga bloke ng "END" ay hindi naisasagawa
kapag nagpatakbo ka ng perl gamit ang switch na "-c", o kung nabigo ang compilation.

Tandaan na ang "END" na mga bloke ng code ay hindi naisakatuparan sa dulo ng isang string na "eval()": kung may "END"
Ang mga bloke ng code ay nilikha sa isang string na "eval()", sila ay isasagawa tulad ng iba
"END" code block ng package na iyon sa LIFO order bago pa man ang interpreter
lumabas.

Sa loob ng "END" code block, $? naglalaman ng halaga na ipapasa ng programa
"lumabas()". Maaari mong baguhin ang $? upang baguhin ang exit value ng program. Mag-ingat sa pagbabago
$? nang hindi sinasadya (hal. sa pamamagitan ng pagpapatakbo ng isang bagay sa pamamagitan ng "system").

Sa loob ng isang "END" block, ang value ng "${^GLOBAL_PHASE}" ay magiging "END".

Ang mga bloke ng code na "UNITCHECK", "CHECK" at "INIT" ay kapaki-pakinabang upang mahuli ang paglipat sa pagitan ng
bahagi ng compilation at ang yugto ng pagpapatupad ng pangunahing programa.

Ang mga bloke ng "UNITCHECK" ay pinapatakbo pagkatapos lamang ma-compile ang unit na tinukoy ang mga ito. Ang
pangunahing file ng programa at ang bawat module na nilo-load nito ay mga compilation unit, tulad ng mga string na "eval",
run-time code na pinagsama-sama gamit ang "(?{ })" construct sa isang regex, tumatawag sa "do FILE",
"require FILE", at code pagkatapos ng "-e" switch sa command line.

Ang mga bloke ng "BEGIN" at "UNITCHECK" ay hindi direktang nauugnay sa yugto ng interpreter.
Maaari silang malikha at maisakatuparan sa anumang yugto.

Ang mga bloke ng code na "CHECK" ay pinapatakbo pagkatapos lamang ng pauna Ang Perl compile phase ay nagtatapos at bago ang
magsisimula ang run time, sa LIFO order. Ang mga bloke ng code na "CHECK" ay ginagamit sa Perl compiler suite
upang i-save ang pinagsama-samang estado ng programa.

Sa loob ng block na "CHECK", ang value ng "${^GLOBAL_PHASE}" ay magiging "CHECK".

Ang "INIT" na mga bloke ay pinapatakbo bago ang Perl runtime ay nagsimulang ipatupad, sa "first in, first
out" (FIFO) na utos.

Sa loob ng block na "INIT", ang value ng "${^GLOBAL_PHASE}" ay magiging "INIT".

Ang "CHECK" at "INIT" ay humaharang sa code na pinagsama ng "require", string "do", o string "eval"
ay hindi isasagawa kung nangyari ang mga ito pagkatapos ng pagtatapos ng pangunahing bahagi ng compilation; pwede yan
maging isang problema sa mod_perl at iba pang patuloy na kapaligiran kung saan ginagamit ang mga function na iyon
load code sa runtime.

Kapag ginamit mo ang -n at -p lumipat sa Perl, "BEGIN" at "END" na gumagana tulad ng ginagawa nila
ang awkward, bilang isang degenerate na kaso. Parehong "BEGIN" at "CHECK" block ay pinapatakbo kapag ginamit mo ang -c
lumipat para sa isang compile-only syntax check, bagama't ang iyong pangunahing code ay hindi.

Ang begincheck nililinaw ng programa ang lahat, sa kalaunan:

#!/usr/bin/perl

# begincheck

print "10. Ang ordinaryong code ay tumatakbo sa runtime.\n";

WAKAS { print "16. Kaya ito na ang katapusan ng kuwento.\n" }
INIT { print " 7. Ang mga INIT block ay tumatakbo sa FIFO bago ang runtime.\n" }
UNITCHECK {
print " 4. At samakatuwid bago ang anumang CHECK block.\n"
}
CHECK { print " 6. Kaya ito ang ikaanim na linya.\n" }

print "11. It runs in order, of course.\n";

BEGIN { print " 1. BEGIN blocks ay nagpapatakbo ng FIFO sa panahon ng compilation.\n" }
WAKAS { print "15. Basahin ang perlmod para sa natitirang bahagi ng kuwento.\n" }
CHECK { print " 5. CHECK blocks run LIFO after all compilation.\n" }
INIT { print " 8. Patakbuhin itong muli, gamit ang Perl's -c switch.\n" }

print "12. Ito ay anti-obfuscated code.\n";

END { print "14. END blocks run LIFO at quitting time.\n" }
BEGIN { print " 2. Kaya pangalawa ang linyang ito.\n" }
UNITCHECK {
print " 3. Ang mga bloke ng UNITCHECK ay nagpapatakbo ng LIFO pagkatapos ma-compile ang bawat file.\n"
}
INIT { print " 9. Makikita mo kaagad ang pagkakaiba.\n" }

print "13. _looks_ lang dapat nakakalito.\n";

__END__

Perl Klase
Walang espesyal na syntax ng klase sa Perl, ngunit maaaring kumilos ang isang pakete bilang isang klase kung nagbibigay ito
mga subroutine upang kumilos bilang mga pamamaraan. Ang ganitong pakete ay maaari ring makuha ang ilan sa mga pamamaraan nito mula sa
isa pang klase (package) sa pamamagitan ng paglilista ng iba pang (mga) pangalan ng package sa global @ISA array nito
(na dapat ay isang package global, hindi isang lexical).

Para sa higit pa tungkol dito, tingnan ang perlootut at perlobj.

Perl Module
Ang module ay isang set lamang ng mga kaugnay na function sa isang library file, ibig sabihin, isang Perl package na may
ang parehong pangalan ng file. Ito ay partikular na idinisenyo upang magamit muli ng iba pang mga module o
mga programa. Maaari nitong gawin ito sa pamamagitan ng pagbibigay ng mekanismo para sa pag-export ng ilan sa mga simbolo nito
ang simbolo ng talahanayan ng anumang pakete na gumagamit nito, o maaari itong gumana bilang isang kahulugan ng klase at
gawing magagamit ang mga semantika nito nang tahasan sa pamamagitan ng mga tawag sa pamamaraan sa klase at mga bagay nito,
nang walang tahasang pag-export ng anuman. O maaari itong gawin ng kaunti sa pareho.

Halimbawa, para magsimula ng tradisyonal, hindi-OO na module na tinatawag na Some::Module, gumawa ng file
tinatawag Ilang/Module.pm at magsimula sa template na ito:

package Some::Module; # ipinapalagay Some/Module.pm

gumamit ng mahigpit;
gumamit ng mga babala;

MAGSIMULA {
nangangailangan ng Exporter;

# itakda ang bersyon para sa pagsusuri ng bersyon
ang aming $VERSION = 1.00;

# Magmana mula sa Exporter upang i-export ang mga function at variable
aming @ISA = qw(Exporter);

# Mga function at variable na na-export bilang default
aming @EXPORT = qw(func1 func2);

# Mga function at variable na maaaring opsyonal na i-export
aming @EXPORT_OK = qw($Var1 %Hashit func3);
}

Pumunta dito ang # na-export na package globals
ang aming $Var1 = '';
aming %Hashit = ();

# hindi na-export na package global ang pumunta dito
# (maa-access pa rin sila bilang $Some::Module::stuff)
aming @more = ();
ang aming $stuff = '';

# file-private lexical ang pumunta dito, bago ang anumang mga function na gumagamit ng mga ito
aking $priv_var = '';
aking %secret_hash = ();

# narito ang isang file-private function bilang isang pagsasara,
# matatawag bilang $priv_func->();
aking $priv_func = sub {
...
};

# gawin ang lahat ng iyong mga function, na-export man o hindi;
# tandaan na maglagay ng isang bagay na kawili-wili sa {} stubs
sub func1 { ... }
sub func2 { ... }

# ang isang ito ay hindi na-export, ngunit maaaring direktang tawagan
# bilang Some::Module::func3()
sub func3 { ... }

END { ... } # module clean-up code dito (global destructor)

1; # huwag kalimutang magbalik ng totoong halaga mula sa file

Pagkatapos ay magpatuloy upang ideklara at gamitin ang iyong mga variable sa mga function nang walang anumang mga kwalipikasyon. Tingnan mo
Exporter at ang perlmodlib para sa mga detalye sa mga isyu sa mekanika at istilo sa paggawa ng module.

Ang mga module ng Perl ay kasama sa iyong programa sa pamamagitan ng pagsasabi

gumamit ng Module;

or

gamitin ang LISTAHAN ng Module;

Ito ay eksaktong katumbas ng

MAGSIMULA { nangangailangan ng 'Module.pm'; 'Module'->import; }

or

MAGSIMULA { nangangailangan ng 'Module.pm'; 'Module'->import( LIST ); }

Bilang isang espesyal na kaso

gamitin ang Module ();

ay eksaktong katumbas ng

MAGSIMULA { nangangailangan ng 'Module.pm'; }

Lahat ng Perl module file ay may extension .pm. Ipinapalagay ito ng operator na "gamitin" kaya mo
hindi mo kailangang isulat"Module.pm" sa mga quotes. Nakakatulong din ito sa pag-iba ng bago
mga module mula sa lumang .pl at .ph mga file. Naka-capitalize din ang mga pangalan ng module maliban kung ito ay
gumagana bilang pragmas; Ang mga pragma ay may bisa na mga direktiba ng compiler, at kung minsan
tinatawag na "pragmatic modules" (o kahit na "pragmata" kung isa kang classicist).

Ang dalawang pahayag:

nangangailangan ng SomeModule;
nangangailangan ng "SomeModule.pm";

naiiba sa bawat isa sa dalawang paraan. Sa unang kaso, anumang double colon sa module
pangalan, gaya ng "Ilan::Module", ay isinalin sa separator ng direktoryo ng iyong system,
karaniwang "/". Ang pangalawang kaso ay hindi, at kailangang tukuyin nang literal. Ang
ang iba pang pagkakaiba ay ang pagkakita sa unang "nangangailangan" ng mga pahiwatig sa compiler na gumagamit ng
hindi direktang object notation na kinasasangkutan ng "SomeModule", tulad ng sa "$ob = purge SomeModule", ay
method calls, hindi function calls. (Oo, ito ay talagang makakagawa ng pagkakaiba.)

Dahil ang "paggamit" na pahayag ay nagpapahiwatig ng isang "BEGIN" na bloke, ang pag-import ng semantics ay nangyayari bilang
sa sandaling ma-compile ang "use" statement, bago ma-compile ang natitirang bahagi ng file. Ito ay
kung paano ito nagagawang gumana bilang isang mekanismo ng pragma, at kung paano nagagawang magdeklara ng mga module
mga subroutine na makikita bilang listahan o unary operator para sa natitirang bahagi ng kasalukuyang
file. Hindi ito gagana kung gagamit ka ng "require" sa halip na "use". Sa "require" kaya mo
pumasok sa problemang ito:

nangangailangan ng Cwd; # gawing naa-access ang Cwd::
$dito = Cwd::getcwd();

gumamit ng Cwd; # import na pangalan mula sa Cwd::
$dito = getcwd();

nangangailangan ng Cwd; # gawing naa-access ang Cwd::
$dito = getcwd(); # oops! walang pangunahing::getcwd()

Sa pangkalahatan, inirerekomenda ang "gamitin ang Module ()" kaysa sa "require Module", dahil tinutukoy nito
availability ng module sa oras ng pag-compile, hindi sa gitna ng execution ng iyong program. An
Ang pagbubukod ay kung dalawang module ang bawat isa ay sinubukang "gamitin" ang isa't isa, at ang bawat isa ay tinatawag ding a
function mula sa ibang module na iyon. Kung ganoon, madaling gamitin ang "require" sa halip.

Maaaring naka-nest ang mga Perl package sa loob ng ibang mga pangalan ng package, para magkaroon tayo ng mga pangalan ng package
naglalaman ng "::". Ngunit kung ginamit namin ang pangalan ng package nang direkta bilang isang filename na gagawin nito
para sa mahirap o imposibleng mga filename sa ilang system. Samakatuwid, kung ang pangalan ng isang module ay,
sabihin, "Text::Soundex", at ang kahulugan nito ay talagang matatagpuan sa file ng aklatan
Text/Soundex.pm.

Ang mga module ng Perl ay laging may a .pm file, ngunit maaari ding mayroong mga dynamic na naka-link na mga executable
(madalas na nagtatapos sa .so) o mga autoloaded subroutine na mga kahulugan (kadalasang nagtatapos sa .al)
nauugnay sa modyul. Kung gayon, ang mga ito ay magiging ganap na transparent sa gumagamit ng
modyul. Ito ay pananagutan ng .pm file upang i-load (o ayusin sa autoload) anuman
karagdagang pag-andar. Halimbawa, kahit na ang POSIX module ay nangyayari na gawin pareho
dynamic na loading at autoloading, masasabi ng user na "gamitin mo lang ang POSIX" para makuha ang lahat.

Paggawa iyong module threadsafe
Sinusuportahan ng Perl ang isang uri ng mga thread na tinatawag na mga interpreter thread (ithreads). Ang mga thread na ito ay maaari
gamitin nang tahasan at hayag.

Gumagana ang mga ithread sa pamamagitan ng pag-clone ng data tree upang walang data na maibahagi sa pagitan ng magkaibang
mga thread. Ang mga thread na ito ay maaaring gamitin sa pamamagitan ng paggamit ng "mga thread" na module o sa pamamagitan ng paggawa tinidor () on
win32 (pekeng tinidor () suporta). Kapag ang isang thread ay na-clone ang lahat ng data ng Perl ay na-clone, gayunpaman hindi-
Ang data ng Perl ay hindi maaaring awtomatikong mai-clone. Ang Perl pagkatapos ng 5.8.0 ay may suporta para sa "CLONE"
espesyal na subroutine. Sa "CLONE" maaari mong gawin ang anumang kailangan mong gawin, tulad halimbawa
pangasiwaan ang pag-clone ng data na hindi Perl, kung kinakailangan. Isang beses tatawagin ang "CLONE" bilang isang klase
paraan para sa bawat pakete na may tinukoy (o nagmamana nito). Ito ay tatawagin sa
konteksto ng bagong thread, kaya lahat ng mga pagbabago ay ginawa sa bagong lugar. Kasalukuyang CLONE
ay tinatawag na walang mga parameter maliban sa pangalan ng invocant na package, ngunit hindi dapat ang code
ipagpalagay na ito ay mananatiling hindi magbabago, dahil malamang na sa hinaharap na mga karagdagang parameter
ay ipapasa upang magbigay ng karagdagang impormasyon tungkol sa estado ng pag-clone.

Kung gusto mong i-CLONE ang lahat ng mga bagay, kakailanganin mong subaybayan ang mga ito sa bawat pakete. Ito ay
ginawa lamang gamit ang isang hash at Scalar::Util::weaken().

Ang Perl pagkatapos ng 5.8.7 ay may suporta para sa espesyal na subroutine na "CLONE_SKIP." Parang "CLONE",
Ang "CLONE_SKIP" ay tinatawag nang isang beses bawat pakete; gayunpaman, ito ay tinatawag bago magsimula ang pag-clone,
at sa konteksto ng parent thread. Kung nagbabalik ito ng totoong halaga, walang mga object ng
ang klase ay mai-clone; o sa halip, kokopyahin ang mga ito bilang unblessed, undef values. Para sa
halimbawa: kung sa magulang ay may dalawang sanggunian sa isang pinagpalang hash, pagkatapos ay sa
anak magkakaroon ng dalawang reference sa isang hindi natukoy na scalar value sa halip. Ito
nagbibigay ng isang simpleng mekanismo para sa paggawa ng module threadsafe; idagdag lang ang "sub CLONE_SKIP { 1
}" sa tuktok ng klase, at ang "DESTROY()" ay tatawagin na lang ng isang beses bawat object. Ng
Siyempre, kung ang thread ng bata ay kailangang gumamit ng mga bagay, pagkatapos ay isang mas sopistikadong
diskarte ang kailangan.

Tulad ng "CLONE", ang "CLONE_SKIP" ay kasalukuyang tinatawag na walang mga parameter maliban sa invocant
pangalan ng package, kahit na maaaring magbago iyon. Katulad nito, upang payagan ang pagpapalawak sa hinaharap, ang
ang return value ay dapat na isang solong 0 o 1 value.

Gumamit ng perlmod online gamit ang mga serbisyo ng onworks.net