perlmod - Online în cloud

PROGRAM:

NUME

perlmod - module Perl (pachete și tabele de simboluri)

DESCRIERE

Is acest il document tu au fost după?
Există și alte documente care ar putea conține informațiile pe care le căutați:

Acest doc
Pachetele lui Perl, spațiile de nume și câteva informații despre clase.

perlnewmod
Tutorial despre realizarea unui nou modul.

perlmodstyle
Cele mai bune practici pentru realizarea unui nou modul.

Pachete
Perl oferă un mecanism pentru spații de nume alternative pentru a proteja pachetele împotriva călcării
variabilele reciproce. De fapt, nu există într-adevăr o variabilă globală în
Perl. Declarația pachet declară unitatea de compilare ca fiind în date
spatiu de nume. Sfera de aplicare a declarației de pachet este de la declarația însăși până la
sfârşitul blocului de anexare, „eval” sau fişier, oricare dintre acestea survine mai întâi (acelaşi domeniu ca
il Ale mele() si local() operatori). În aceasta vor fi identificatori dinamici necalificați
namespace, cu excepția acelor câțiva identificatori care, dacă nu sunt calificați, implicit la principal
pachet în locul celui actual, așa cum este descris mai jos. O declarație de pachet afectează numai
variabile dinamice, inclusiv cele pe care le-ați folosit local() pe--dar nu variabile lexicale
creat cu Ale mele(). De obicei, ar fi prima declarație dintr-un fișier inclus de
operatorii „face”, „require” sau „utilizați”. Puteți trece într-un pachet în mai mult de unul
loc; influențează doar ce tabel de simboluri este folosit de compilator pentru restul
acel bloc. Vă puteți referi la variabile și manere de fișiere din alte pachete, prefixând
identificator cu numele pachetului și două două puncte: $Package::Variable. Dacă pachetul
numele este nul, se presupune pachetul „principal”. Adică, $::sail este echivalent cu
$main::sail.

Vechiul delimitator de pachet era un singur ghilimeleu, dar două puncte sunt acum preferat
delimitator, în parte pentru că este mai lizibil pentru oameni și în parte pentru că este mai mult
lizibil pentru emacs macro-uri. De asemenea, îi face pe programatorii C++ să simtă că știu ce se întâmplă
on--spre deosebire de a folosi ghilimele unice ca separator, care a fost acolo pentru a face Ada
programatorii simt că știau ce se întâmplă. Pentru că sintaxa de modă veche este
încă acceptat pentru compatibilitatea cu versiunile inverse, dacă încercați să utilizați un șir de caractere precum „Acesta este
$owner's house", veți accesa $owner::s; adică variabila $s din pachet
„proprietar”, ceea ce probabil nu este ceea ce ai vrut să spui. Folosiți acolade pentru a dezambigua, ca în „Acesta este
casa ${proprietar}”.

Pachetele pot conține în sine separatori de pachete, ca în $OUTER::INNER::var. Acest
nu implică nimic despre ordinea căutărilor de nume, totuși. Nu există pachete relative:
toate simbolurile sunt fie locale pentru pachetul curent, fie trebuie să fie complet calificate din
numele pachetului exterior în jos. De exemplu, nu există nicăieri în pachetul „EXTERIOR” care
$INNER::var se referă la $OUTER::INNER::var. „INNER” se referă la o globală total separată
pachet.

Doar identificatorii care încep cu litere (sau liniuță de subliniere) sunt stocați în simbolul unui pachet
masa. Toate celelalte simboluri sunt păstrate în pachetul „principal”, inclusiv toate variabilele de punctuație,
ca $_. În plus, atunci când nu sunt calificați, identificatorii STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC și SIG sunt forțate să fie în pachetul „principal”, chiar și atunci când sunt utilizate pentru alte
scopuri decât cele încorporate. Dacă aveți un pachet numit „m”, „s” sau „y”, atunci
nu puteți utiliza forma calificată a unui identificator deoarece ar fi în schimb interpretat
ca o potrivire a modelului, o substituție sau o transliterare.

Variabilele care încep cu liniuță de subliniere erau forțate în pachetul principal, dar am decis asta
a fost mai util pentru scriitorii de pachete pentru a putea folosi liniuța de subliniere pentru a indica
variabile private și nume de metode. Cu toate acestea, variabilele și funcțiile numite cu un singur
„_”, cum ar fi $_ și „sub _”, sunt încă forțate în pachetul „principal”. Vezi și „The
Sintaxa numelor de variabile" în perlvar.

Șirurile „eval”ed sunt compilate în pachetul în care eval() a fost compilat.
(Totuși, atribuirile către $SIG{} presupun că handlerul de semnal specificat este în „principal”
pachet. Calificați numele operatorului de semnal dacă doriți să aveți un handler de semnal în a
pachet.) De exemplu, examinați perldb.pl în biblioteca Perl. Inițial comută
la pachetul „DB”, astfel încât depanatorul să nu interfereze cu variabilele din program
încerci să depanezi. În diferite momente, însă, se comută temporar înapoi la
pachetul „principal” pentru a evalua diverse expresii în contextul pachetului „principal” (sau
oriunde ai veni). Vezi perldebug.

Simbolul special „__PACKAGE__” conține pachetul curent, dar nu poate fi utilizat (cu ușurință).
pentru a construi nume de variabile.

Consultați perlsub pentru alte probleme legate de domeniul de aplicare Ale mele() si local(), și perlref cu privire la
închideri.

Simbol Mese
Tabelul de simboluri pentru un pachet se întâmplă să fie stocat în hash-ul acelui nume cu două
două puncte anexate. Numele tabelului de simbol principal este astfel %main::, sau pe scurt %::.
La fel este denumit tabelul de simboluri pentru pachetul imbricat menționat mai devreme
%EXTERIOR::INTERIOR::.

Valoarea din fiecare intrare a hash este la care vă referiți atunci când utilizați *numele
notație typeglob.

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

Puteți utiliza acest lucru pentru a tipări toate variabilele dintr-un pachet, de exemplu. Standardul
dar învechit dumpvar.pl biblioteca și modulul CPAN Devel::Symdump folosesc acest lucru.

Rezultatele creării de noi intrări în tabelul de simboluri direct sau modificării oricăror intrări care
nu sunt deja typeglobs sunt nedefinite și pot fi schimbate între versiunile de perl.

Atribuirea unui typeglob efectuează o operație de alias, adică

*puisă = *richard;

cauzează variabile, subrutine, formate și mânere de fișiere și directoare accesibile prin intermediul
identificatorul „richard” să fie accesibil și prin identificatorul „dick”. Dacă dorești
alias doar o anumită variabilă sau subrutină, atribuiți o referință în schimb:

*pupa = \$richard;

Ceea ce face ca $richard și $dick să fie aceeași variabilă, dar îi lasă pe @richard și @dick
matrice separate. Delicat, nu?

Există o diferență subtilă între următoarele afirmații:

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

„*foo = *bar” face ca tipgloburile în sine să fie sinonime, în timp ce „*foo = \$bar” face ca
Porțiunile SCALARE ale două globuri de tip distincte se referă la aceeași valoare scalară. Aceasta înseamnă că
următorul cod:

$bar = 1;
*foo = \$bar; # Faceți din $foo un alias pentru $bar

{
local $bar = 2; # Restricționați modificările la blocare
print $foo; # Imprimă „1”!
}

Ar tipări „1”, deoarece $foo deține o referință la original $bar. Cel care a fost
umplut de „local()” și care va fi restaurat când blocul se termină. pentru că
variabilele sunt accesate prin typeglob, puteți folosi „*foo = *bar” pentru a crea un alias
care poate fi localizat. (Dar rețineți că acest lucru înseamnă că nu puteți avea un @foo separat și
@bar, etc.)

Ceea ce face ca toate acestea să fie importante este faptul că modulul Exportator folosește aliasarea glob ca
mecanism de import/export. Dacă puteți localiza sau nu corect o variabilă care a fost
exportat dintr-un modul depinde de modul în care a fost exportat:

@EXPORT = qw($FOO); # Forma uzuală, nu poate fi localizată
@EXPORT = qw(*FOO); # Poate fi localizat

Puteți rezolva primul caz folosind numele complet calificat ($Package::FOO) unde
aveți nevoie de o valoare locală sau înlocuind-o spunând „*FOO = *Package::FOO” în
script-ul.

Mecanismul „*x = \$y” poate fi folosit pentru a transmite și returna referințe ieftine în sau dinspre
subrutine dacă nu doriți să copiați totul. Funcționează doar când se atribuie la
variabile dinamice, nu lexicale.

%some_hash = (); # nu poate fi al meu()
*some_hash = fn( \%other_hash );
sub fn {
local *hashsym = shift;
# acum folosește %hashsym în mod normal și tu
# va afecta %another_hash al apelantului
%nhash-ul meu = (); # fa ce vrei
returnează \%nhash;
}

La întoarcere, referința va suprascrie slotul hash din tabelul de simboluri specificat de
*some_hash typeglob. Acesta este un mod oarecum complicat de a trece referințele la prețuri ieftine
când nu doriți să vă amintiți să dereferiți variabilele în mod explicit.

O altă utilizare a tabelelor de simboluri este pentru a face scalari „constanți”.

*PI = \3.14159265358979;

Acum nu puteți modifica $PI, ceea ce este probabil un lucru bun în general. Asta nu este la fel
ca subrutină constantă, care este supusă optimizării în timpul compilării. O constantă
subrutina este unul prototip pentru a nu accepta argumente și pentru a returna o expresie constantă.
Consultați perlsub pentru detalii despre acestea. Pragma „utilizare constantă” este o prescurtare convenabilă pentru
aceste.

Puteți spune *foo{PACKAGE} și *foo{NUME} pentru a afla ce nume și pachetul simbolului *foo
intrarea tabelului provine de la. Acest lucru poate fi util într-o subrutină care este trecută tipglob ca
argumente:

sub identificare_typeglob {
my $glob = shift;
tipăriți „Mi-ați dat”, *{$glob}{PACKAGE},
'::', *{$glob}{NAME}, „\n”;
}
identifică_typeglob *foo;
identifică_typeglob *bar::baz;

Aceasta se imprimă

Mi-ai dat principal::foo
Mi-ai dat bar::baz

Notația *foo{THING} poate fi folosită și pentru a obține referințe la elementele individuale
de *foo. Vezi perlref.

Definițiile subrutinelor (și declarațiile, de altfel) nu trebuie neapărat să fie
situate în pachetul al cărui tabel cu simboluri îl ocupă. Puteți defini o subrutină
în afara pachetului său, calificând în mod explicit numele subrutinei:

pachet principal;
sub Some_package::foo { ... } # &foo definit în Some_package

Aceasta este doar o prescurtare pentru o atribuire typeglob în timpul compilării:

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

şi este nu la fel cu scrisul:

{
pachet Some_package;
sub foo { ... }
}

În primele două versiuni, corpul subrutinei este lexical în pachetul principal,
nu în Unele_pachet. Deci ceva de genul asta:

pachet principal;

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

sub Some_package::foo {
print "în ", __PACKAGE__, ": \$numele este '$nume'\n";
}

Un_pachet::foo();

printuri:

în principal: $name este „barney”

Decat:

în Some_package: $name este „fred”

Acest lucru are și implicații pentru utilizarea calificatorului SUPER:: (vezi perlobj).

ÎNCEPE, UNITCHECK, VERIFICA, INIT si Sfârşit
Cinci blocuri de cod special numite sunt executate la începutul și la sfârșitul unei rulări
programul Perl. Acestea sunt blocurile „BEGIN”, „UNITCHECK”, „CHECK”, „INIT” și „END”.

Aceste blocuri de cod pot fi prefixate cu „sub” pentru a da aspectul unei subrutine
(deși acest lucru nu este considerat un stil bun). Ar trebui să rețineți că aceste blocuri de cod
nu există cu adevărat ca subrutine numite (în ciuda aspectului lor). Lucrul care dă
asta departe este faptul că poți avea mai mult decât unu dintre aceste blocuri de cod într-un program,
și vor primi toate executat la momentul oportun. Deci nu poți executa nimic
aceste blocuri de cod după nume.

Un bloc de cod „BEGIN” este executat cât mai curând posibil, adică în momentul în care este complet
definit, chiar înainte ca restul fișierului care conține (sau șir) să fie analizat. Ai putea avea
mai multe blocuri „BEGIN” într-un fișier (sau șir evaluat); se vor executa în ordinea de
definiție. Deoarece un bloc de cod „BEGIN” se execută imediat, poate extrage definiții
de subrutine și altele din alte fișiere la timp pentru a fi vizibile pentru restul compilației
și timpul de rulare. Odată ce a rulat un „BEGIN”, acesta este imediat nedefinit și orice cod folosit este
a revenit la fondul de memorie al lui Perl.

Un bloc de cod „END” este executat cât mai târziu posibil, adică după ce perl a terminat
rulează programul și chiar înainte ca interpretul să fie părăsit, chiar dacă se iese
ca urmare a die () funcţie. (Dar nu dacă se transformă într-un alt program prin
„exec”, sau a fi aruncat din apă de un semnal - trebuie să prindeți asta singur (dacă
puteți).) Este posibil să aveți mai multe blocuri „END” într-un fișier – acestea se vor executa invers
ordinea definirii; adică: ultimul intrat, primul ieşit (LIFO). Blocurile „END” nu sunt executate
când rulați perl cu comutatorul „-c” sau dacă compilarea eșuează.

Rețineți că blocurile de cod „END” sunt nu executat la sfârșitul unui șir „eval()”: dacă există „END”
blocurile de cod sunt create într-un șir „eval()”, ele vor fi executate la fel ca oricare altele
Blocul de cod „END” al acelui pachet în ordinea LIFO chiar înainte ca interpretul să fie lansat
ieșit.

În interiorul unui bloc de cod „END”, $? conține valoarea la care urmează să o treacă programul
"Ieșire()". Puteți modifica $? pentru a modifica valoarea de ieșire a programului. Atenție la schimbare
$? accidental (de exemplu, rulând ceva prin „sistem”).

În interiorul unui bloc „END”, valoarea „${^GLOBAL_PHASE}” va fi „END”.

Blocurile de cod „UNITCHECK”, „CHECK” și „INIT” sunt utile pentru a prinde tranziția între
faza de compilare și faza de execuție a programului principal.

Blocurile „UNITCHECK” sunt executate imediat după ce unitatea care le-a definit a fost compilată. The
fișierul de program principal și fiecare modul pe care îl încarcă sunt unități de compilare, la fel ca șirurile de „eval”,
cod de rulare compilat folosind constructul „(?{ })” într-o expresie regex, apeluri la „do FILE”,
„require FILE” și codați după comutatorul „-e” de pe linia de comandă.

Blocurile „BEGIN” și „UNITCHECK” nu sunt direct legate de faza interpretului.
Ele pot fi create și executate în orice fază.

Blocurile de cod „CHECK” sunt executate imediat după inițială Faza de compilare Perl se termină și înainte de
începe timpul de rulare, în ordinea LIFO. Blocurile de cod „CHECK” sunt folosite în suita de compilare Perl
pentru a salva starea compilată a programului.

În interiorul unui bloc „CHECK”, valoarea „${^GLOBAL_PHASE}” va fi „CHECK”.

Blocurile „INIT” sunt rulate chiar înainte ca timpul de execuție Perl să înceapă execuția, în „first in, first
afară" (FIFO).

În interiorul unui bloc „INIT”, valoarea „${^GLOBAL_PHASE}” va fi „INIT”.

Blocurile „CHECK” și „INIT” din codul compilat de „require”, șirul „do” sau șirul „eval”
nu vor fi executate dacă apar după încheierea fazei principale de compilare; care poate
fi o problemă în mod_perl și alte medii persistente care folosesc acele funcții pentru
codul de încărcare în timpul execuției.

Când utilizați -n si -p comută la Perl, „BEGIN” și „END” funcționează la fel ca în
Wow, ca un caz degenerat. Ambele blocuri „BEGIN” și „CHECK” sunt rulate atunci când utilizați -c
comutați pentru o verificare a sintaxei numai pentru compilare, deși codul dvs. principal nu este.

începe verificarea programul clarifică totul, în cele din urmă:

#!/usr/bin/perl

# începe verificarea

printează „10. Codul obișnuit rulează în timpul execuției.\n”;

END { print "16. Deci acesta este sfârșitul poveștii.\n" }
INIT { print " 7. Blocurile INIT rulează FIFO chiar înainte de rulare.\n" }
UNITCHECK {
print " 4. Și, prin urmare, înainte de orice blocuri VERIFICARE.\n"
}
VERIFICAȚI { print " 6. Deci aceasta este a șasea linie.\n" }

printează „11. Funcționează în ordine, desigur.\n”;

BEGIN { print " 1. BEGIN blocurile rulează FIFO în timpul compilării.\n" }
END { print "15. Citiți perlmod pentru restul poveștii.\n" }
VERIFICAȚI { printează " 5. VERIFICAȚI blocurile rulează LIFO după toată compilarea.\n" }
INIT { print " 8. Rulați acest lucru din nou, folosind comutatorul -c al lui Perl.\n" }

tipăriți „12. Acesta este un cod anti-obscurcat.\n”;

END { tipăriți „14. Blocurile END rulează LIFO la momentul părăsirii.\n” }
BEGIN { print " 2. Deci această linie iese a doua.\n" }
UNITCHECK {
print " 3. Blocurile UNITCHECK rulează LIFO după ce fiecare fișier este compilat.\n"
}
INIT { print " 9. Veți vedea diferența imediat.\n" }

printează „13. Doar _pare_ ar trebui să fie confuz.\n”;

__SFÂRȘIT__

Perl Clase
Nu există o sintaxă de clasă specială în Perl, dar un pachet poate acționa ca o clasă dacă oferă
subrutine să acționeze ca metode. Un astfel de pachet poate deriva, de asemenea, unele dintre metodele sale
altă clasă (pachet) listând celelalte nume de pachet în matricea sa globală @ISA
(care trebuie să fie un pachet global, nu un lexical).

Pentru mai multe despre aceasta, consultați perlootut și perlobj.

Perl Module
Un modul este doar un set de funcții înrudite într-un fișier de bibliotecă, adică un pachet Perl cu
același nume ca și fișierul. Este special conceput pentru a fi reutilizabil de către alte module sau
programe. Poate face acest lucru furnizând un mecanism pentru exportul unor simboluri în
tabelul de simboluri al oricărui pachet care îl folosește sau poate funcționa ca definiție de clasă și
să-și facă disponibilă implicit semantica prin apeluri de metodă asupra clasei și a obiectelor acesteia,
fără a exporta nimic în mod explicit. Sau poate face puțin din ambele.

De exemplu, pentru a porni un modul tradițional, non-OO numit Some::Module, creați un fișier
denumit Unii/Modul.pm și începeți cu acest șablon:

pachet Unele::Modul; # presupune Some/Module.pm

folosiți strict;
folosiți avertismente;

ÎNCEPE {
solicita Exportator;

# setați versiunea pentru verificarea versiunii
nostru $VERSION = 1.00;

# Moșteniți de la Exportator pentru a exporta funcții și variabile
nostru @ISA = qw(Exportator);

# Funcții și variabile care sunt exportate implicit
nostru @EXPORT = qw(func1 func2);

# Funcții și variabile care pot fi exportate opțional
nostru @EXPORT_OK = qw($Var1 %Hashit func3);
}

# pachetele globale exportate merg aici
nostru $Var1 = '';
%Hashit-ul nostru = ();

# pachete globale neexportate merg aici
# (sunt încă accesibile ca $Some::Module::stuff)
nostru @mai mult = ();
$lucrurile noastre = '';

# lexicale private de fișiere merg aici, înaintea oricăror funcții care le folosesc
my $priv_var = '';
%secret_hash-ul meu = ();

# aici este o funcție de fișier privat ca închidere,
# apelabil ca $priv_func->();
my $priv_func = sub {
...
};

# faceți toate funcțiile dvs., fie exportate sau nu;
# amintiți-vă să puneți ceva interesant în {} cioturi
sub funcția1 { ... }
sub funcția2 { ... }

# acesta nu este exportat, dar poate fi apelat direct
# as Some::Module::func3()
sub funcția3 { ... }

END { ... } # cod de curățare a modulului aici (destructor global)

1; # nu uitați să returnați o valoare adevărată din fișier

Apoi continuați să declarați și să utilizați variabilele în funcții fără nicio calificare. Vedea
Exportator și perlmodlib pentru detalii despre mecanică și probleme de stil în crearea modulelor.

Modulele Perl sunt incluse în programul dvs. spunând

utilizați Modulul;

or

utilizați Modul LIST;

Acest lucru este exact echivalent cu

BEGIN { necesită „Module.pm”; 'Modul'->import; }

or

BEGIN { necesită „Module.pm”; 'Modul'->import( LISTA ); }

Ca caz special

utilizați Modulul ();

este exact echivalent cu

BEGIN { necesită „Module.pm”; }

Toate fișierele modulului Perl au extensia .p.m. Operatorul „utilizare” presupune acest lucru, astfel încât dvs
nu trebuie să precizeze"Modul.pm" între ghilimele. Acest lucru ajută și la diferențierea noilor
module din vechime .pl si .ph fișiere. Numele modulelor sunt, de asemenea, scrise cu majuscule, dacă nu sunt
funcționând ca pragma; pragmas sunt de fapt directive ale compilatorului și uneori sunt
numite „module pragmatice” (sau chiar „pragmata” dacă ești clasicist).

Cele două afirmații:

necesită SomeModule;
necesită „SomeModule.pm”;

diferă unul de altul în două moduri. În primul caz, orice două puncte duble din modul
numele, cum ar fi „Some::Module”, sunt traduse în separatorul de directoare al sistemului dvs.,
de obicei "/". Al doilea caz nu este și ar trebui să fie specificat literal. The
o altă diferență este că vederea primelor indicii „require” în compilatorul care folosește of
Notarea obiectelor indirecte care implică „SomeModule”, ca în „$ob = purge SomeModule”, sunt
apeluri de metodă, nu apeluri de funcție. (Da, asta chiar poate face diferența.)

Deoarece instrucțiunea „use” implică un bloc „BEGIN”, importarea semanticii are loc ca
imediat ce instrucțiunea „use” este compilată, înainte ca restul fișierului să fie compilat. Aceasta este
modul în care poate funcționa ca mecanism pragma și, de asemenea, modul în care modulele pot declara
subrutine care sunt apoi vizibile ca listă sau operatori unari pentru restul curentului
fişier. Acest lucru nu va funcționa dacă folosiți „require” în loc de „use”. Cu „require” poți
intra in problema asta:

necesită Cwd; # face Cwd:: accesibil
$aici = Cwd::getcwd();

utilizați Cwd; # import nume din Cwd::
$aici = getcwd();

necesită Cwd; # face Cwd:: accesibil
$aici = getcwd(); # hopa! nu main::getcwd()

În general, „utilizați Modulul ()” este recomandat în detrimentul „require Module”, deoarece determină
disponibilitatea modulelor în momentul compilării, nu în mijlocul execuției programului dvs. Un
excepția ar fi dacă două module ar încerca fiecare să se „folosească” unul pe celălalt și fiecare numit, de asemenea, a
funcția de la celălalt modul. În acest caz, este ușor să folosiți „require”.

Pachetele Perl pot fi imbricate în alte nume de pachete, astfel încât să putem avea nume de pachete
conținând "::". Dar dacă am folosi acel nume de pachet direct ca nume de fișier, ar fi
pentru nume de fișiere grele sau imposibile pe unele sisteme. Prin urmare, dacă numele unui modul este,
spuneți „Text::Soundex”, atunci definiția sa se găsește de fapt în fișierul bibliotecă
Text/Soundex.pm.

Modulele Perl au întotdeauna un .p.m fișier, dar pot exista și executabile conectate dinamic
(se termină adesea în .asa de) sau definițiile subrutinei încărcate automat (se termină adesea în .al)
asociat cu modulul. Dacă da, acestea vor fi complet transparente pentru utilizatorul
modul. Este responsabilitatea .p.m fișier pentru a încărca (sau aranja pentru a încărca automat) oricare
funcționalitate suplimentară. De exemplu, deși modulul POSIX se întâmplă să facă ambele
încărcare dinamică și încărcare automată, utilizatorul poate spune doar „utilizați POSIX” pentru a obține totul.

Efectuarea ta modul fir de siguranta
Perl acceptă un tip de fire numite fire interpretor (ithreads). Aceste fire pot
să fie utilizat în mod explicit și implicit.

Ithread-urile funcționează prin clonarea arborelui de date, astfel încât nicio dată să nu fie partajată între diferiți
fire. Aceste fire pot fi folosite folosind modulul „threads” sau făcând furculiţă() on
win32 (fals furculiţă() a sustine). Când un fir de execuție este clonat, toate datele Perl sunt clonate, totuși non-
Datele Perl nu pot fi clonate automat. Perl după 5.8.0 are suport pentru „CLONE”
subrutină specială. În „CLONE” poți face tot ce trebuie să faci, de exemplu
gestionați clonarea datelor non-Perl, dacă este necesar. „CLONE” va fi numit o dată ca clasă
metoda pentru fiecare pachet care îl are definit (sau îl moștenește). Se va numi în
contextul noului thread, astfel încât toate modificările sunt făcute în noua zonă. Momentan CLONE
este apelat fără alți parametri decât numele pachetului invocat, dar codul nu ar trebui
presupunem că aceasta va rămâne neschimbată, deoarece este probabil ca în viitor parametri suplimentari
vor fi transmise pentru a oferi mai multe informații despre starea clonării.

Dacă doriți să CLONați toate obiectele, va trebui să le urmăriți per pachet. Aceasta este
pur și simplu făcut folosind un hash și Scalar::Util::weaken().

Perl după 5.8.7 are suport pentru subrutina specială „CLONE_SKIP”. Ca „CLONE”,
„CLONE_SKIP” este apelat o dată pe pachet; cu toate acestea, este numit chiar înainte de începerea clonării,
iar în contextul firului părinte. Dacă returnează o valoare adevărată, atunci nu există obiecte ale
acea clasă va fi clonată; sau mai degrabă, ele vor fi copiate ca valori unblessed, undef. Pentru
exemplu: dacă în părinte există două referințe la un singur hash binecuvântat, atunci în
copil vor exista în schimb două referințe la o singură valoare scalară nedefinită. Acest
oferă un mecanism simplu pentru a face un modul sigur pentru fire; doar adăugați „sub CLONE_SKIP { 1
}" din partea de sus a clasei, iar "DESTROY()" va fi apelat acum o singură dată per obiect.
desigur, în cazul în care firul copil trebuie să facă uz de obiecte, atunci un mai sofisticat
este nevoie de abordare.

La fel ca „CLONE”, „CLONE_SKIP” este apelat în prezent fără alți parametri decât invocatorul
numele pachetului, deși acesta se poate schimba. În mod similar, pentru a permite extinderea viitoare,
valoarea returnată ar trebui să fie o singură valoare 0 sau 1.

Utilizați perlmod online folosind serviciile onworks.net