perlmod - Dalam talian di Awan

JADUAL:

NAMA

perlmod - Modul Perl (pakej dan jadual simbol)

DESCRIPTION

Is ini yang dokumen anda adalah selepas?
Terdapat dokumen lain yang mungkin mengandungi maklumat yang anda cari:

doc ini
Pakej Perl, ruang nama dan beberapa maklumat tentang kelas.

perlnewmod
Tutorial membuat modul baru.

perlmodstyle
Amalan terbaik untuk membuat modul baharu.

Kami
Perl menyediakan mekanisme untuk ruang nama alternatif untuk melindungi pakej daripada terpijak
pembolehubah masing-masing. Sebenarnya, tidak ada perkara seperti pembolehubah global dalam
Perl. Pernyataan pakej mengisytiharkan unit kompilasi sebagai dalam yang diberikan
ruang nama. Skop pengisytiharan pakej adalah daripada pengisytiharan itu sendiri melalui
hujung blok yang disertakan, "eval", atau fail, yang mana datang dahulu (skop yang sama seperti
yang saya() and tempatan() pengendali). Pengecam dinamik tidak layak akan ada dalam ini
ruang nama, kecuali beberapa pengecam yang jika tidak layak, lalai kepada yang utama
pakej dan bukannya yang semasa seperti yang diterangkan di bawah. Kenyataan pakej hanya memberi kesan
pembolehubah dinamik--termasuk yang telah anda gunakan tempatan() pada--tetapi tidak pembolehubah leksikal
dibuat dengan saya(). Biasanya ia akan menjadi pengisytiharan pertama dalam fail yang disertakan oleh
"buat", "memerlukan", atau "menggunakan" pengendali. Anda boleh bertukar kepada pakej dalam lebih daripada satu
tempat; ia hanya mempengaruhi jadual simbol yang digunakan oleh pengkompil untuk selebihnya
blok itu. Anda boleh merujuk kepada pembolehubah dan pemegang fail dalam pakej lain dengan memberi awalan
pengecam dengan nama pakej dan bertitik dua: $Package::Variable. Jika pakej
nama adalah batal, pakej "utama" diandaikan. Iaitu, $::sail adalah bersamaan dengan
$utama::belayar.

Pembatas pakej lama ialah petikan tunggal, tetapi titik bertindih berganda kini menjadi pilihan
pembatas, sebahagiannya kerana ia lebih mudah dibaca oleh manusia, dan sebahagiannya kerana ia lebih banyak
boleh dibaca ke emacs makro. Ia juga membuatkan pengaturcara C++ berasa seperti mereka tahu apa yang berlaku
pada--berbanding menggunakan petikan tunggal sebagai pemisah, yang ada untuk menjadikan Ada
pengaturcara berasa seperti mereka tahu apa yang sedang berlaku. Kerana sintaks lama ialah
masih disokong untuk keserasian ke belakang, jika anda cuba menggunakan rentetan seperti "This is
$owner's house", anda akan mengakses $owner::s; iaitu pembolehubah $s dalam pakej
"pemilik", yang mungkin bukan maksud anda. Gunakan pendakap untuk menyahkekaburan, seperti dalam "Ini adalah
rumah ${owner}".

Pakej mungkin sendiri mengandungi pemisah pakej, seperti dalam $OUTER::INNER::var. ini
Walau bagaimanapun, tidak membayangkan apa-apa tentang susunan carian nama. Tiada pakej relatif:
semua simbol adalah sama ada setempat kepada pakej semasa, atau mesti berkelayakan sepenuhnya daripada
nama pakej luar ke bawah. Sebagai contoh, tiada tempat dalam pakej "LUAR" itu
$INNER::var merujuk kepada $OUTER::INNER::var. "INNER" merujuk kepada global yang berasingan sama sekali
pakej.

Hanya pengecam yang bermula dengan huruf (atau garis bawah) disimpan dalam simbol pakej
meja. Semua simbol lain disimpan dalam pakej "utama", termasuk semua pembolehubah tanda baca,
seperti $_. Selain itu, apabila tidak layak, pengecam STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC dan SIG terpaksa berada dalam pakej "utama", walaupun digunakan untuk
tujuan daripada yang terbina dalam. Jika anda mempunyai pakej yang dipanggil "m", "s", atau "y", maka
anda tidak boleh menggunakan bentuk pengecam yang layak kerana ia sebaliknya akan ditafsirkan
sebagai padanan pola, penggantian atau transliterasi.

Pembolehubah yang bermula dengan garis bawah digunakan untuk dipaksa ke dalam pakej utama, tetapi kami memutuskannya
adalah lebih berguna untuk penulis pakej dapat menggunakan garis bawah utama untuk menunjukkan
pembolehubah persendirian dan nama kaedah. Walau bagaimanapun, pembolehubah dan fungsi dinamakan dengan satu
"_", seperti $_ dan "sub _", masih dipaksa masuk ke dalam pakej "utama". Lihat juga "The
Sintaks Nama Pembolehubah" dalam perlvar.

rentetan "eval" disusun dalam pakej di mana fail eval () telah disusun.
(Tugasan kepada $SIG{}, walau bagaimanapun, anggap pengendali isyarat yang dinyatakan berada dalam "utama"
pakej. Layakkan nama pengendali isyarat jika anda ingin mempunyai pengendali isyarat dalam a
pakej.) Sebagai contoh, periksa perldb.pl dalam perpustakaan Perl. Ia pada mulanya bertukar
ke pakej "DB" supaya penyahpepijat tidak mengganggu pembolehubah dalam program
anda cuba nyahpepijat. Walau bagaimanapun, pada pelbagai titik, ia beralih semula kepada
pakej "utama" untuk menilai pelbagai ungkapan dalam konteks pakej "utama" (atau
dari mana sahaja anda datang). Lihat perldebug.

Simbol khas "__PACKAGE__" mengandungi pakej semasa, tetapi tidak boleh (mudah) digunakan
untuk membina nama pembolehubah.

Lihat perlsub untuk isu skop lain yang berkaitan dengan saya() and tempatan(), dan perlref berkenaan
penutupan.

Simbol Jadual
Jadual simbol untuk pakej kebetulan disimpan dalam cincang nama itu dengan dua
titik bertindih ditambah. Oleh itu, nama jadual simbol utama ialah %main::, atau %:: ringkasnya.
Begitu juga jadual simbol untuk pakej bersarang yang dinyatakan sebelum ini dinamakan
%LUARAN:: DALAM::.

Nilai dalam setiap entri cincang ialah perkara yang anda rujuk apabila anda menggunakan *nama
tatatanda typeglob.

tempatan *utama::foo = *utama::bar;

Anda boleh menggunakan ini untuk mencetak semua pembolehubah dalam pakej, contohnya. Piawaian
tetapi kuno dumpvar.pl perpustakaan dan modul CPAN Devel::Symdump gunakan ini.

Keputusan mencipta entri jadual simbol baharu secara langsung atau mengubah suai sebarang entri yang
belum lagi typeglobs tidak ditentukan dan tertakluk kepada perubahan antara keluaran perl.

Tugasan kepada typeglob menjalankan operasi pengaliasan, iaitu,

*batang = *richard;

menyebabkan pembolehubah, subrutin, format dan pengendalian fail serta direktori boleh diakses melalui
pengecam "richard" juga boleh diakses melalui pengecam "batang". Jika anda mahu
alias hanya pembolehubah atau subrutin tertentu, tetapkan rujukan sebaliknya:

*batang = \$richard;

Yang menjadikan $richard dan $dick pembolehubah yang sama, tetapi meninggalkan @richard dan @dick sebagai
tatasusunan berasingan. Rumit, eh?

Terdapat satu perbezaan halus antara pernyataan berikut:

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

"*foo = *bar" menjadikan glob jenis itu sendiri sinonim manakala "*foo = \$bar" menjadikan
Bahagian SKALAR daripada dua glob jenis berbeza merujuk kepada nilai skalar yang sama. Ini bermakna bahawa
kod berikut:

$bar = 1;
*foo = \$bar; # Jadikan $foo sebagai alias untuk $bar

{
$bar tempatan = 2; # Hadkan perubahan untuk menyekat
cetak $foo; # Cetakan '1'!
}

Akan mencetak '1', kerana $foo memegang rujukan kepada asal $bar. Yang tadi
disumbat oleh "local()" dan yang akan dipulihkan apabila blok itu tamat. Kerana
pembolehubah diakses melalui typeglob, anda boleh menggunakan "*foo = *bar" untuk mencipta alias
yang boleh dilokalkan. (Tetapi sedar bahawa ini bermakna anda tidak boleh mempunyai @foo and
@bar, dsb.)

Apa yang menjadikan semua ini penting ialah modul Pengeksport menggunakan pengalian glob sebagai
mekanisme import/eksport. Sama ada anda boleh menyetempatkan pembolehubah yang telah atau tidak
dieksport daripada modul bergantung pada cara ia dieksport:

@EXPORT = qw($FOO); # Bentuk biasa, tidak boleh disetempatkan
@EXPORT = qw(*FOO); # Boleh disetempat

Anda boleh mengatasi kes pertama dengan menggunakan nama yang layak sepenuhnya ($Package::FOO) di mana
anda memerlukan nilai setempat, atau dengan mengatasinya dengan menyebut "*FOO = *Pakej::FOO" dalam anda
skrip.

Mekanisme "*x = \$y" boleh digunakan untuk menghantar dan mengembalikan rujukan murah ke dalam atau dari
subrutin jika anda tidak mahu menyalin keseluruhannya. Ia hanya berfungsi apabila menugaskan kepada
pembolehubah dinamik, bukan leksikal.

%some_hash = (); # tidak boleh menjadi saya()
*some_hash = fn( \% another_hash );
sub fn {
tempatan *hashsym = shift;
# kini menggunakan %hashsym seperti biasa, dan anda
# akan menjejaskan %another_hash pemanggil
my %nhash = (); # buat apa yang awak mahu
kembalikan \%nhash;
}

Sebagai balasan, rujukan akan menimpa slot cincang dalam jadual simbol yang ditentukan oleh
*some_hash typeglob. Ini adalah cara yang agak rumit untuk menyampaikan rujukan dengan murah
apabila anda tidak mahu perlu ingat untuk menyahrujuk pembolehubah secara eksplisit.

Satu lagi kegunaan jadual simbol adalah untuk membuat skalar "malar".

*PI = \3.14159265358979;

Sekarang anda tidak boleh mengubah $PI, yang mungkin merupakan perkara yang baik secara keseluruhannya. Ini tidak sama
sebagai subrutin malar, yang tertakluk kepada pengoptimuman pada masa penyusunan. Pemalar
subrutin adalah satu prototaip untuk tidak mengambil hujah dan untuk mengembalikan ungkapan tetap.
Lihat perlsub untuk butiran tentang ini. Pragma "penggunaan pemalar" adalah singkatan yang mudah untuk
ini.

Anda boleh menyebut *foo{PACKAGE} dan *foo{NAME} untuk mengetahui nama dan pakej simbol *foo
entri meja datang dari. Ini mungkin berguna dalam subrutin yang lulus typeglobs sebagai
hujah:

sub identify_typeglob {
$glob saya = shift;
cetak 'Anda berikan saya ', *{$glob}{PACKAGE},
'::', *{$glob}{NAME}, "\n";
}
identify_typeglob *foo;
identify_typeglob *bar::baz;

Ini mencetak

Anda memberi saya main::foo
Anda memberi saya bar::baz

Notasi *foo{THING} juga boleh digunakan untuk mendapatkan rujukan kepada elemen individu
daripada *foo. Lihat perlref.

Takrifan subrutin (dan pengisytiharan, dalam hal ini) tidak semestinya begitu
terletak di dalam bungkusan yang meja simbolnya mereka duduki. Anda boleh menentukan subrutin
di luar pakejnya dengan melayakkan nama subrutin secara eksplisit:

pakej utama;
sub Some_package::foo { ... } # &foo ditakrifkan dalam Some_package

Ini hanyalah singkatan untuk tugasan typeglob pada masa penyusunan:

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

dan adalah tidak sama seperti menulis:

{
pakej Some_package;
sub foo { ... }
}

Dalam dua versi pertama, badan subrutin secara leksikal dalam pakej utama,
tidak dalam Some_package. Jadi sesuatu seperti ini:

pakej utama;

$Some_package::name = "fred";
$utama::nama = "barney";

sub Some_package::foo {
print "in ", __PACKAGE__, ": \$nama ialah '$nama'\n";
}

Some_package::foo();

cetakan:

dalam utama: $name ialah 'barney'

bukannya:

dalam Some_package: $name ialah 'fred'

Ini juga mempunyai implikasi untuk penggunaan kelayakan SUPER:: (lihat perlobj).

BERMULA, UNITCHECK, SEMAK, INIT and AKHIR
Lima blok kod yang dinamakan khas dilaksanakan pada permulaan dan pada akhir larian
program Perl. Ini ialah blok "BEGIN", "UNITCHECK", "CHECK", "INIT" dan "END".

Blok kod ini boleh diawali dengan "sub" untuk memberikan penampilan subrutin
(walaupun ini tidak dianggap gaya yang baik). Orang harus ambil perhatian bahawa kod ini menyekat
tidak benar-benar wujud sebagai subrutin yang dinamakan (walaupun penampilannya). Perkara yang memberi
jauh ini adalah hakikat yang anda boleh miliki lebih daripada 1 daripada blok kod ini dalam program,
dan mereka akan dapat semua dilaksanakan pada masa yang sesuai. Jadi anda tidak boleh melaksanakan mana-mana
kod ini blok mengikut nama.

Blok kod "MULAI" dilaksanakan secepat mungkin, iaitu, pada saat ia sepenuhnya
ditakrifkan, walaupun sebelum seluruh fail yang mengandungi (atau rentetan) dihuraikan. Anda mungkin ada
berbilang blok "MULAI" dalam fail (atau rentetan yang dinilai); mereka akan melaksanakan mengikut tertib
takrifan. Oleh kerana blok kod "MULAI" dilaksanakan serta-merta, ia boleh menarik definisi
subrutin dan seumpamanya daripada fail lain tepat pada masanya untuk dilihat kepada seluruh penyusun
dan masa berjalan. Sebaik sahaja "BERMULA" telah dijalankan, ia tidak ditentukan serta-merta dan sebarang kod yang digunakan adalah
kembali ke kolam memori Perl.

Blok kod "END" dilaksanakan selewat mungkin, iaitu selepas perl selesai
menjalankan program dan sejurus sebelum jurubahasa sedang keluar, walaupun ia sedang keluar
hasil daripada a mati () fungsi. (Tetapi tidak jika ia berubah menjadi program lain melalui
"exec", atau diterbangkan keluar dari air oleh isyarat--anda perlu memerangkapnya sendiri (jika
anda boleh).) Anda mungkin mempunyai berbilang blok "END" dalam fail--ia akan dilaksanakan secara terbalik
susunan definisi; iaitu: masuk terakhir, keluar dahulu (LIFO). Blok "END" tidak dilaksanakan
apabila anda menjalankan perl dengan suis "-c", atau jika kompilasi gagal.

Ambil perhatian bahawa blok kod "TAMAT" adalah tidak dilaksanakan pada penghujung rentetan "eval()": jika ada "END"
blok kod dicipta dalam rentetan "eval()", ia akan dilaksanakan sama seperti yang lain
Blok kod "TAMAT" pakej itu dalam susunan LIFO sejurus sebelum jurubahasa sedang
keluar.

Di dalam blok kod "END", $? mengandungi nilai yang akan dilalui oleh program
"keluar()". Anda boleh mengubah suai $? untuk menukar nilai keluar program. Berhati-hati untuk berubah
$? secara tidak sengaja (cth. dengan menjalankan sesuatu melalui "sistem").

Di dalam blok "END", nilai "${^GLOBAL_PHASE}" akan menjadi "END".

Blok kod "UNITCHECK", "CHECK" dan "INIT" berguna untuk menangkap peralihan antara
fasa penyusunan dan fasa pelaksanaan program utama.

Blok "UNITCHECK" dijalankan hanya selepas unit yang mentakrifkannya telah disusun. The
fail program utama dan setiap modul yang dimuatkan adalah unit kompilasi, seperti rentetan "eval",
kod masa jalan yang disusun menggunakan binaan "(?{ })" dalam regex, memanggil untuk "do FILE",
"memerlukan FILE", dan kod selepas suis "-e" pada baris arahan.

Blok "BEGIN" dan "UNITCHECK" tidak berkaitan secara langsung dengan fasa penterjemah.
Ia boleh dibuat dan dilaksanakan dalam mana-mana fasa.

Blok kod "SEMAK" dijalankan hanya selepas awal Fasa penyusunan Perl tamat dan sebelum
masa larian bermula, dalam susunan LIFO. Blok kod "SEMAK" digunakan dalam suite pengkompil Perl
untuk menyimpan keadaan terkumpul program.

Di dalam blok "CHECK", nilai "${^GLOBAL_PHASE}" akan menjadi "CHECK".

Blok "INIT" dijalankan sejurus sebelum masa jalan Perl memulakan pelaksanaan, dalam "first in, first
perintah keluar" (FIFO).

Di dalam blok "INIT", nilai "${^GLOBAL_PHASE}" akan menjadi "INIT".

Blok "CHECK" dan "INIT" dalam kod yang disusun oleh "require", rentetan "do", atau rentetan "eval"
tidak akan dilaksanakan jika ia berlaku selepas tamat fasa kompilasi utama; itu boleh
menjadi masalah dalam mod_perl dan persekitaran berterusan lain yang menggunakan fungsi tersebut untuk
muatkan kod semasa runtime.

Apabila anda menggunakan -n and -p bertukar kepada Perl, "MULAI" dan "TAMAT" berfungsi seperti yang mereka lakukan dalam
awk, sebagai kes merosot. Kedua-dua blok "BEGIN" dan "CHECK" dijalankan apabila anda menggunakan -c
beralih untuk semakan sintaks kompilasi sahaja, walaupun kod utama anda tidak.

. mula semak program menjelaskan semuanya, akhirnya:

#!/usr/bin/perl

# mula semak

cetak "10. Kod biasa berjalan pada masa jalan.\n";

TAMAT { cetak "16. Jadi ini adalah penghujung kisah.\n" }
INIT { print " 7. INIT blok menjalankan FIFO sejurus sebelum masa jalan.\n" }
UNITCHECK {
print " 4. Oleh itu sebelum sebarang CHECK blok.\n"
}
SEMAK { print " 6. Jadi ini ialah baris keenam.\n" }

cetak "11. Ia berjalan mengikut urutan, sudah tentu.\n";

BEGIN { print " 1. BEGIN blok menjalankan FIFO semasa penyusunan.\n" }
TAMAT { cetak "15. Baca perlmod untuk cerita yang lain.\n" }
CHECK { print " 5. CHECK blocks run LIFO after all compilation.\n" }
INIT { print " 8. Jalankan ini sekali lagi, menggunakan suis -c Perl.\n" }

cetak "12. Ini adalah kod anti-keliru.\n";

TAMAT { cetak "14. Blok TAMAT menjalankan LIFO pada masa berhenti.\n" }
BEGIN { print " 2. Jadi baris ini keluar kedua.\n" }
UNITCHECK {
print " 3. Blok UNITCHECK menjalankan LIFO selepas setiap fail disusun.\n"
}
INIT { print " 9. Anda akan melihat perbezaannya serta-merta.\n" }

print "13. Ia hanya _kelihatan_ seperti ia sepatutnya mengelirukan.\n";

__TAMAT__

Perl kelas
Tiada sintaks kelas khas dalam Perl, tetapi pakej boleh bertindak sebagai kelas jika ia menyediakan
subrutin untuk bertindak sebagai kaedah. Pakej sedemikian juga mungkin memperoleh beberapa kaedahnya daripada
kelas lain (pakej) dengan menyenaraikan nama pakej lain dalam tatasusunan @ISA globalnya
(yang mestilah pakej global, bukan leksikal).

Untuk maklumat lanjut tentang ini, lihat perlootut dan perlobj.

Perl Modul
Modul hanyalah satu set fungsi berkaitan dalam fail perpustakaan, iaitu, pakej Perl dengan
nama yang sama dengan fail. Ia direka khusus untuk boleh digunakan semula oleh modul lain atau
program. Ia mungkin melakukan ini dengan menyediakan mekanisme untuk mengeksport beberapa simbolnya ke dalam
jadual simbol mana-mana pakej yang menggunakannya, atau ia mungkin berfungsi sebagai definisi kelas dan
menjadikan semantiknya tersedia secara tersirat melalui panggilan kaedah pada kelas dan objeknya,
tanpa mengeksport apa-apa secara eksplisit. Atau ia boleh melakukan sedikit daripada kedua-duanya.

Contohnya, untuk memulakan modul bukan OO tradisional yang dipanggil Some::Module, buat fail
dipanggil Beberapa/Modul.pm dan mulakan dengan templat ini:

pakej Beberapa::Modul; # menganggap Some/Module.pm

gunakan ketat;
gunakan amaran;

BERMULA {
memerlukan Pengeksport;

# tetapkan versi untuk semakan versi
$VERSION kami = 1.00;

# Warisi daripada Pengeksport kepada fungsi eksport dan pembolehubah
@ISA kami = qw(Pengeksport);

# Fungsi dan pembolehubah yang dieksport secara lalai
@EXPORT kami = qw(func1 func2);

# Fungsi dan pembolehubah yang boleh dieksport secara pilihan
@EXPORT_OK kami = qw($Var1 %Hashit func3);
}

# pakej global yang dieksport pergi ke sini
$Var1 = '';
%Hashit = ();

# pakej global yang tidak dieksport pergi ke sini
# (mereka masih boleh diakses sebagai $Some::Module::stuff)
@more = ();
$barang kami = '';

# leksikal fail-peribadi pergi ke sini, sebelum sebarang fungsi yang menggunakannya
$priv_var saya = '';
my %secret_hash = ();

# berikut ialah fungsi fail peribadi sebagai penutup,
# boleh dipanggil sebagai $priv_func->();
$priv_func saya = sub {
...
};

# buat semua fungsi anda, sama ada dieksport atau tidak;
# ingat untuk meletakkan sesuatu yang menarik dalam stub {}.
sub func1 { ... }
sub func2 { ... }

# yang ini tidak dieksport, tetapi boleh dipanggil terus
# sebagai Some::Module::func3()
sub func3 { ... }

TAMAT { ... } # kod pembersihan modul di sini (pemusnah global)

1; # jangan lupa untuk mengembalikan nilai sebenar daripada fail

Kemudian teruskan untuk mengisytiharkan dan menggunakan pembolehubah anda dalam fungsi tanpa sebarang kelayakan. Lihat
Pengeksport dan perlmodlib untuk butiran tentang mekanik dan isu gaya dalam penciptaan modul.

Modul Perl disertakan ke dalam program anda dengan berkata

gunakan Modul;

or

gunakan SENARAI Modul;

Ini betul-betul setara dengan

BERMULA { memerlukan 'Module.pm'; 'Modul'->import; }

or

BERMULA { memerlukan 'Module.pm'; 'Modul'->import( LIST ); }

Sebagai kes khas

gunakan Modul ();

betul-betul setara dengan

BERMULA { memerlukan 'Module.pm'; }

Semua fail modul Perl mempunyai sambungan .pm. Pengendali "penggunaan" menganggap ini supaya anda
tidak perlu mengeja"Modul.pm" dalam petikan. Ini juga membantu membezakan yang baharu
modul dari lama .pl and .ph fail. Nama modul juga menggunakan huruf besar melainkan nama modul tersebut
berfungsi sebagai pragma; pragmas adalah arahan pengkompil yang berkuat kuasa, dan kadangkala
dipanggil "modul pragmatik" (atau pun "pragmata" jika anda seorang ahli klasik).

Dua kenyataan:

memerlukan SomeModule;
memerlukan "SomeModule.pm";

berbeza antara satu sama lain dalam dua cara. Dalam kes pertama, sebarang titik bertindih berganda dalam modul
nama, seperti "Sesetengah::Modul", diterjemahkan ke dalam pemisah direktori sistem anda,
biasanya "/". Kes kedua tidak, dan perlu dinyatakan secara literal. The
perbezaan lain ialah melihat petunjuk "memerlukan" pertama dalam pengkompil yang menggunakan
notasi objek tidak langsung yang melibatkan "SomeModule", seperti dalam "$ob = purge SomeModule", adalah
panggilan kaedah, bukan panggilan fungsi. (Ya, ini benar-benar boleh membuat perbezaan.)

Oleh kerana pernyataan "penggunaan" membayangkan blok "MULAI", pengimportan semantik berlaku sebagai
sebaik sahaja pernyataan "guna" disusun, sebelum fail yang lain dikompilasi. Ini adalah
bagaimana ia dapat berfungsi sebagai mekanisme pragma, dan juga bagaimana modul dapat mengisytiharkan
subrutin yang kemudiannya kelihatan sebagai pengendali senarai atau unari untuk sepanjang masa
fail. Ini tidak akan berfungsi jika anda menggunakan "memerlukan" dan bukannya "menggunakan". Dengan "memerlukan" anda boleh
masuk ke dalam masalah ini:

memerlukan Cwd; # jadikan Cwd:: boleh diakses
$here = Cwd::getcwd();

gunakan Cwd; # import nama daripada Cwd::
$di sini = getcwd();

memerlukan Cwd; # jadikan Cwd:: boleh diakses
$di sini = getcwd(); # oops! tiada utama::getcwd()

Secara umum, "gunakan Modul ()" disyorkan berbanding "memerlukan Modul", kerana ia menentukan
ketersediaan modul pada masa penyusunan, bukan di tengah-tengah pelaksanaan program anda. An
pengecualian adalah jika dua modul masing-masing cuba "menggunakan" satu sama lain, dan masing-masing juga dipanggil a
fungsi daripada modul lain itu. Dalam kes itu, ia adalah mudah untuk menggunakan "memerlukan" sebaliknya.

Pakej Perl mungkin bersarang di dalam nama pakej lain, jadi kami boleh mempunyai nama pakej
mengandungi "::". Tetapi jika kami menggunakan nama pakej itu secara langsung sebagai nama fail, ia akan menjadi
untuk nama fail yang sukar digunakan atau mustahil pada sesetengah sistem. Oleh itu, jika nama modul ialah,
sebut, "Teks::Soundex", maka takrifnya sebenarnya ditemui dalam fail perpustakaan
Teks/Soundex.pm.

Modul Perl sentiasa mempunyai a .pm fail, tetapi mungkin terdapat juga boleh laku yang dipautkan secara dinamik
(selalunya berakhir dengan .so) atau takrifan subrutin yang dimuatkan secara automatik (selalunya berakhir dengan .al)
dikaitkan dengan modul. Jika ya, ini akan telus sepenuhnya kepada pengguna
modul. Ia adalah tanggungjawab pihak .pm fail untuk memuatkan (atau mengatur untuk autoload) mana-mana
fungsi tambahan. Sebagai contoh, walaupun modul POSIX berlaku untuk melakukan kedua-duanya
pemuatan dinamik dan pemuatan automatik, pengguna boleh berkata hanya "gunakan POSIX" untuk mendapatkan semuanya.

Membuat Matlamat modul threadsafe
Perl menyokong sejenis utas yang dipanggil benang penterjemah (ithreads). Benang ini boleh
digunakan secara tersurat dan tersirat.

Ithreads berfungsi dengan mengklonkan pepohon data supaya tiada data dikongsi antara yang berbeza
benang. Benang ini boleh digunakan dengan menggunakan modul "benang" atau dengan melakukan garpu () on
win32 (palsu garpu () sokongan). Apabila benang diklon semua data Perl diklon, walau bagaimanapun tidak
Data Perl tidak boleh diklon secara automatik. Perl selepas 5.8.0 mempunyai sokongan untuk "CLONE"
subrutin khas. Dalam "CLONE" anda boleh melakukan apa sahaja yang anda perlu lakukan, seperti contohnya
mengendalikan pengklonan data bukan Perl, jika perlu. "KLONE" akan dipanggil sekali sebagai kelas
kaedah untuk setiap pakej yang telah ditentukan (atau mewarisinya). Ia akan dipanggil dalam
konteks urutan baharu, jadi semua pengubahsuaian dibuat di kawasan baharu. Pada masa ini CLONE
dipanggil tanpa parameter selain nama pakej invocan, tetapi kod tidak sepatutnya
menganggap bahawa ini akan kekal tidak berubah, kerana kemungkinan besar pada parameter tambahan akan datang
akan dihantar untuk memberi maklumat lanjut tentang keadaan pengklonan.

Jika anda ingin MENGKLON semua objek, anda perlu menjejakinya setiap pakej. Ini adalah
hanya dilakukan menggunakan hash dan Skalar::Util::melemah().

Perl selepas 5.8.7 mempunyai sokongan untuk subrutin khas "CLONE_SKIP". Seperti "CLONE",
"CLONE_SKIP" dipanggil sekali setiap pakej; namun, ia dipanggil sejurus sebelum pengklonan bermula,
dan dalam konteks benang induk. Jika ia mengembalikan nilai sebenar, maka tiada objek
kelas itu akan diklon; atau sebaliknya, mereka akan disalin sebagai nilai yang tidak diberkati, tidak pasti. Untuk
contoh: jika dalam ibu bapa terdapat dua rujukan kepada satu hash yang diberkati, maka dalam
anak akan ada dua rujukan kepada satu nilai skalar yang tidak ditentukan sebaliknya. ini
menyediakan mekanisme mudah untuk membuat threadsafe modul; cuma tambah "sub CLONE_SKIP { 1
}" di bahagian atas kelas dan "DESTROY()" kini hanya akan dipanggil sekali bagi setiap objek. Daripada
Sudah tentu, jika benang kanak-kanak perlu menggunakan objek, maka yang lebih canggih
pendekatan diperlukan.

Seperti "CLONE", "CLONE_SKIP" pada masa ini dipanggil tanpa parameter selain daripada invocant
nama pakej, walaupun itu mungkin berubah. Begitu juga, untuk membolehkan pengembangan masa depan, the
nilai pulangan hendaklah satu nilai 0 atau 1.

Gunakan perlmod dalam talian menggunakan perkhidmatan onworks.net