ນີ້ແມ່ນຄໍາສັ່ງ perlmod ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
perlmod - ໂມດູນ Perl (ຊຸດແລະຕາຕະລາງສັນຍາລັກ)
ລາຍລະອຽດ
Is ນີ້ ໄດ້ ເອກະສານ ທ່ານ ໄດ້ ຫຼັງຈາກ?
ມີເອກະສານອື່ນໆທີ່ອາດມີຂໍ້ມູນທີ່ທ່ານກໍາລັງຊອກຫາ:
ເອກະສານນີ້
ແພັກເກດ Perl, namespaces, ແລະຂໍ້ມູນບາງຢ່າງກ່ຽວກັບຫ້ອງຮຽນ.
perlnewmod
ການສອນກ່ຽວກັບການສ້າງໂມດູນໃຫມ່.
perlmodstyle
ການປະຕິບັດທີ່ດີທີ່ສຸດສໍາລັບການສ້າງໂມດູນໃຫມ່.
ການຫຸ້ມຫໍ່
Perl ສະຫນອງກົນໄກສໍາລັບ namespaces ທາງເລືອກເພື່ອປົກປ້ອງຊຸດຈາກການ stomping ສຸດ
ຕົວແປຂອງກັນແລະກັນ. ໃນຄວາມເປັນຈິງ, ບໍ່ມີສິ່ງດັ່ງກ່າວເປັນຕົວແປທົ່ວໂລກ
Perl. ຄໍາຖະແຫຼງການຊຸດປະກາດຫນ່ວຍງານລວບລວມວ່າຢູ່ໃນທີ່ກໍານົດໄວ້
namespace. ຂອບເຂດຂອງການປະກາດຊຸດແມ່ນມາຈາກການປະກາດຕົວມັນເອງຜ່ານ
ໃນຕອນທ້າຍຂອງຕັນປິດ, "eval", ຫຼືໄຟລ໌, ອັນໃດກໍ່ຕາມທີ່ມາກ່ອນ (ຂອບເຂດດຽວກັນກັບ
ໄດ້ ຂອງຂ້ອຍ() ແລະ ທ້ອງຖິ່ນ() ຜູ້ປະກອບການ). ຕົວລະບຸແບບເຄື່ອນໄຫວທີ່ບໍ່ມີເງື່ອນໄຂຈະຢູ່ໃນນີ້
namespace, ຍົກເວັ້ນສໍາລັບຕົວລະບຸຈໍານວນຫນ້ອຍທີ່ຖ້າບໍ່ມີເງື່ອນໄຂ, ເລີ່ມຕົ້ນເປັນຕົ້ນຕໍ
package ແທນທີ່ຈະເປັນປະຈຸບັນດັ່ງທີ່ອະທິບາຍຂ້າງລຸ່ມນີ້. ໃບແຈ້ງຍອດຊຸດມີຜົນກະທົບເທົ່ານັ້ນ
ຕົວແປແບບໄດນາມິກ - ລວມທັງຕົວແປທີ່ທ່ານເຄີຍໃຊ້ ທ້ອງຖິ່ນ() on-- ແຕ່ ບໍ່ ຕົວແປ lexical
ສ້າງຂື້ນດ້ວຍ ຂອງຂ້ອຍ(). ໂດຍປົກກະຕິມັນຈະເປັນຄໍາປະກາດທໍາອິດໃນໄຟລ໌ທີ່ລວມຢູ່ໃນ
"ເຮັດ", "ຕ້ອງການ", ຫຼື "ໃຊ້". ທ່ານສາມາດປ່ຽນເປັນຊຸດໃນຫຼາຍກວ່າຫນຶ່ງ
ສະຖານທີ່; ມັນພຽງແຕ່ມີອິດທິພົນຕໍ່ຕາຕະລາງສັນຍາລັກທີ່ຖືກນໍາໃຊ້ໂດຍ compiler ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງ
ຕັນນັ້ນ. ທ່ານສາມາດອ້າງເຖິງຕົວແປແລະ filehandles ໃນຊຸດອື່ນໆໂດຍການນໍາຫນ້າ
ຕົວລະບຸທີ່ມີຊື່ແພັກເກດ ແລະຈໍ້າສອງເມັດ: $Package::ຕົວແປ. ຖ້າຊຸດ
ຊື່ແມ່ນ null, ຊຸດ "ຕົ້ນຕໍ" ແມ່ນສົມມຸດ. ນັ້ນແມ່ນ, $::sail ແມ່ນທຽບເທົ່າກັບ
$main:: sail.
ຕົວຂັ້ນຊຸດເກົ່າແມ່ນໃບສະເໜີລາຄາອັນດຽວ, ແຕ່ ຈໍ້າສອງເທົ່າໃນປັດຈຸບັນແມ່ນເປັນທີ່ຕ້ອງການ
ຕົວຂັ້ນ, ໃນສ່ວນຫນຶ່ງແມ່ນຍ້ອນວ່າມັນສາມາດອ່ານໄດ້ຫຼາຍສໍາລັບມະນຸດ, ແລະບາງສ່ວນເນື່ອງຈາກວ່າມັນຫຼາຍ
ສາມາດອ່ານໄດ້ emacs ມະຫາພາກ. ມັນຍັງເຮັດໃຫ້ນັກຂຽນໂປລແກລມ C ++ ມີຄວາມຮູ້ສຶກຄືກັບວ່າພວກເຂົາຮູ້ວ່າແມ່ນຫຍັງຈະເກີດຂຶ້ນ
on-- ກົງກັນຂ້າມກັບການໃຊ້ quote ດຽວເປັນຕົວແຍກ, ເຊິ່ງຢູ່ທີ່ນັ້ນເພື່ອເຮັດໃຫ້ Ada
ຜູ້ຂຽນໂປລແກລມມີຄວາມຮູ້ສຶກຄືກັບວ່າພວກເຂົາຮູ້ວ່າມີຫຍັງເກີດຂຶ້ນ. ເນື່ອງຈາກວ່າ syntax ເກົ່າແກ່ແມ່ນ
ຍັງໄດ້ຮັບການສະຫນັບສະຫນູນສໍາລັບການເຂົ້າກັນໄດ້ກັບກັບຄືນໄປບ່ອນ, ຖ້າທ່ານພະຍາຍາມໃຊ້ສະຕິງເຊັ່ນ "ນີ້ແມ່ນ
$owner's house", ທ່ານຈະເຂົ້າເຖິງ $owner::s; ນັ້ນແມ່ນຕົວແປ $s ໃນແພັກເກັດ.
"ເຈົ້າຂອງ", ເຊິ່ງອາດຈະບໍ່ແມ່ນສິ່ງທີ່ທ່ານຫມາຍເຖິງ. ໃຊ້ວົງເລັບເພື່ອ disambiguate, ໃນ "ນີ້ແມ່ນ
ເຮືອນຂອງ ${owner}".
ແພັກເກດຕົວມັນເອງອາດມີຕົວແຍກແພັກເກັດ, ຄືກັບໃນ $OUTER::INNER::var. ນີ້
ຢ່າງໃດກໍຕາມ, ບໍ່ມີຫຍັງກ່ຽວກັບຄໍາສັ່ງຂອງການຊອກຫາຊື່. ບໍ່ມີແພັກເກດທີ່ກ່ຽວຂ້ອງ:
ສັນຍາລັກທັງຫມົດແມ່ນຢູ່ໃນທ້ອງຖິ່ນກັບຊຸດປັດຈຸບັນ, ຫຼືຕ້ອງໄດ້ຮັບການມີຄຸນສົມບັດຢ່າງເຕັມທີ່ຈາກ
ຊື່ຊຸດນອກລົງ. ຕົວຢ່າງ, ບໍ່ມີບ່ອນໃດຢູ່ໃນຊຸດ "OUTER" ນັ້ນ
$INNER::var ຫມາຍເຖິງ $OUTER::INNER::var. "INNER" ຫມາຍເຖິງໂລກທີ່ແຍກຕ່າງຫາກທັງຫມົດ
package
ມີພຽງແຕ່ຕົວລະບຸທີ່ເລີ່ມຕົ້ນດ້ວຍຕົວອັກສອນ (ຫຼືຂີດກ້ອງ) ທີ່ຖືກເກັບໄວ້ໃນສັນຍາລັກຂອງແພັກເກັດ
ໂຕະ. ສັນຍາລັກອື່ນໆທັງໝົດຖືກເກັບໄວ້ໃນຊຸດ "ຫຼັກ", ລວມທັງຕົວແປເຄື່ອງໝາຍວັກຕອນທັງໝົດ,
ເຊັ່ນ $_. ນອກຈາກນັ້ນ, ເມື່ອບໍ່ມີເງື່ອນໄຂ, ຕົວລະບຸ STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC, ແລະ SIG ຖືກບັງຄັບໃຫ້ຢູ່ໃນຊຸດ "ຕົ້ນຕໍ", ເຖິງແມ່ນວ່າຈະໃຊ້ສໍາລັບເຄື່ອງອື່ນໆ.
ຈຸດປະສົງກ່ວາທີ່ມີຢູ່ໃນຕົວຂອງເຂົາເຈົ້າ. ຖ້າທ່ານມີຊຸດທີ່ເອີ້ນວ່າ "m", "s", ຫຼື "y", ຫຼັງຈາກນັ້ນ
ທ່ານບໍ່ສາມາດນໍາໃຊ້ຮູບແບບທີ່ມີຄຸນສົມບັດຂອງຕົວລະບຸໄດ້ເນື່ອງຈາກວ່າມັນຈະເປັນແທນທີ່ຈະຕີຄວາມຫມາຍ
ເປັນການຈັບຄູ່ຮູບແບບ, ການປ່ຽນແທນ, ຫຼືການແປ.
ຕົວແປທີ່ເລີ່ມຕົ້ນດ້ວຍເຄື່ອງໝາຍຂີດກ້ອງຖືກບັງຄັບໃຫ້ເປັນແພັກເກັດຫຼັກ, ແຕ່ພວກເຮົາຕັດສິນໃຈແລ້ວ
ມີປະໂຫຍດຫຼາຍສຳລັບນັກຂຽນແພັກເກັດທີ່ສາມາດໃຊ້ຂີດກ້ອງເພື່ອຊີ້ບອກໄດ້
ຕົວແປສ່ວນຕົວ ແລະຊື່ວິທີການ. ຢ່າງໃດກໍຕາມ, ຕົວແປແລະຫນ້າທີ່ທີ່ມີຊື່ດຽວ
"_", ເຊັ່ນ $_ ແລະ "sub _", ຍັງຖືກບັງຄັບໃຫ້ເຂົ້າໄປໃນຊຸດ "ຕົ້ນຕໍ". ເບິ່ງ "The
Syntax ຂອງຊື່ຕົວແປ" ໃນ perlvar.
"eval"ed strings ຖືກລວບລວມຢູ່ໃນຊຸດທີ່ eval() ໄດ້ຖືກລວບລວມ.
(ຢ່າງໃດກໍຕາມ, ການມອບໝາຍໃຫ້ $SIG{}, ສົມມຸດວ່າຕົວຈັດການສັນຍານທີ່ລະບຸໄວ້ໃນ "ຫຼັກ"
ຊຸດ. ກຳນົດຊື່ຕົວຈັດການສັນຍານຖ້າທ່ານຕ້ອງການມີຕົວຈັດການສັນຍານໃນ a
package.) ສໍາລັບການຍົກຕົວຢ່າງ, ກວດເບິ່ງ perldb.pl ໃນຫໍສະຫມຸດ Perl. ມັນໃນເບື້ອງຕົ້ນສະຫຼັບ
ໄປຫາຊຸດ "DB" ເພື່ອວ່າຕົວດີບັກບໍ່ແຊກແຊງຕົວແປໃນໂປຼແກຼມ
ທ່ານກໍາລັງພະຍາຍາມແກ້ໄຂ. ໃນຈຸດຕ່າງໆ, ແນວໃດກໍ່ຕາມ, ມັນຊົ່ວຄາວປ່ຽນກັບຄືນໄປບ່ອນ
ຊຸດ "ຕົ້ນຕໍ" ເພື່ອປະເມີນການສະແດງອອກຕ່າງໆໃນສະພາບການຂອງຊຸດ "ຕົ້ນຕໍ" (ຫຼື
ບໍ່ວ່າເຈົ້າມາຈາກໃສ). ເບິ່ງ perldbug.
ສັນຍາລັກພິເສດ "__PACKAGE__" ປະກອບດ້ວຍຊຸດປັດຈຸບັນ, ແຕ່ບໍ່ສາມາດນໍາໃຊ້ (ຢ່າງງ່າຍດາຍ)
ເພື່ອສ້າງຊື່ຕົວແປ.
ເບິ່ງ perlsub ສໍາລັບບັນຫາຂອບເຂດອື່ນໆທີ່ກ່ຽວຂ້ອງກັບ ຂອງຂ້ອຍ() ແລະ ທ້ອງຖິ່ນ(), ແລະ perlref ກ່ຽວກັບ
ການປິດ.
ສັນຍາລັກ ຕາຕະລາງ
ຕາຕະລາງສັນຍາລັກສໍາລັບຊຸດທີ່ເກີດຂື້ນຈະຖືກເກັບໄວ້ໃນ hash ຂອງຊື່ນັ້ນດ້ວຍສອງ
ຈໍ້າສອງເມັດຕໍ່ທ້າຍ. ຊື່ຕາຕະລາງສັນຍາລັກຫຼັກແມ່ນ %main::, ຫຼື %:: ສໍາລັບສັ້ນ.
ເຊັ່ນດຽວກັນ, ຕາຕະລາງສັນຍາລັກສໍາລັບຊຸດຮັງທີ່ໄດ້ກ່າວມາກ່ອນຫນ້ານີ້ແມ່ນມີຊື່
%OUTER::ພາຍໃນ::.
ຄ່າໃນແຕ່ລະລາຍການຂອງ hash ແມ່ນສິ່ງທີ່ທ່ານກໍາລັງອ້າງເຖິງເມື່ອທ່ານໃຊ້ * ຊື່
ຫມາຍເຫດ typeglob.
local *main::foo = *main::bar;
ທ່ານສາມາດໃຊ້ອັນນີ້ເພື່ອພິມຕົວແປທັງໝົດໃນແພັກເກັດ, ຕົວຢ່າງ. ມາດຕະຖານ
ແຕ່ເກົ່າແກ່ dumpvar.pl ຫ້ອງສະຫມຸດແລະໂມດູນ CPAN Devel::Symdump ເຮັດໃຫ້ການນໍາໃຊ້ນີ້.
ຜົນໄດ້ຮັບຂອງການສ້າງລາຍການຕາຕະລາງສັນຍາລັກໃຫມ່ໂດຍກົງຫຼືປັບປຸງແກ້ໄຂໃດຫນຶ່ງທີ່
ບໍ່ແມ່ນແລ້ວ typeglobs ແມ່ນບໍ່ໄດ້ກໍານົດແລະມີການປ່ຽນແປງລະຫວ່າງການປ່ອຍ perl.
ການມອບໝາຍໃຫ້ typeglob ດໍາເນີນການ aliasing, ie,
*dick = *richard;
ເຮັດໃຫ້ຕົວແປ, routines ຍ່ອຍ, ຮູບແບບ, ແລະໄຟລ໌ແລະໄດເລກະທໍລີ handles ສາມາດເຂົ້າເຖິງໄດ້ໂດຍຜ່ານ
ຕົວລະບຸ "richard" ຍັງສາມາດເຂົ້າເຖິງໄດ້ໂດຍຜ່ານຕົວລະບຸ "dick". ຖ້າທ່ານຕ້ອງການ
alias ພຽງແຕ່ເປັນຕົວແປສະເພາະຫຼື subroutine, ກໍານົດການອ້າງອີງແທນ:
*dick = \$richard;
ເຊິ່ງເຮັດໃຫ້ $richard ແລະ $dick ເປັນຕົວແປດຽວກັນ, ແຕ່ປ່ອຍໃຫ້ @richard ແລະ @dick ເປັນ
array ແຍກຕ່າງຫາກ. Tricky, eh?
ມີຄວາມແຕກຕ່າງກັນເລັກນ້ອຍລະຫວ່າງຄໍາຖະແຫຼງຕໍ່ໄປນີ້:
*foo = *bar;
*foo = \$bar;
"*foo = *bar" ເຮັດໃຫ້ typeglobs ຕົວຂອງມັນເອງມີຄວາມຄ້າຍຄືກັນໃນຂະນະທີ່ "*foo = \$bar" ເຮັດໃຫ້
ສ່ວນ SCALAR ຂອງສອງ typeglobs ທີ່ແຕກຕ່າງກັນຫມາຍເຖິງຄ່າ scalar ດຽວກັນ. ນີ້ຫມາຍຄວາມວ່າ
ລະຫັດຕໍ່ໄປນີ້:
$bar = 1;
*foo = \$bar; # ເຮັດໃຫ້ $foo ເປັນນາມແຝງສໍາລັບ $bar
{
ທ້ອງຖິ່ນ $bar = 2; # ຈຳກັດການປ່ຽນແປງຕໍ່ກັບບລັອກ
ພິມ $foo; #ພິມ '1'!
}
ຈະພິມ '1', ເພາະວ່າ $foo ຖືການອ້າງອີງເຖິງ ຕົ້ນສະບັບ $bar. ອັນນັ້ນແມ່ນ
stuffed ໄປໂດຍ "local()" ແລະທີ່ຈະໄດ້ຮັບການຟື້ນຟູໃນເວລາທີ່ຕັນສິ້ນສຸດລົງ. ເນື່ອງຈາກວ່າ
ຕົວແປແມ່ນເຂົ້າເຖິງຜ່ານ typeglob, ທ່ານສາມາດໃຊ້ "*foo = *bar" ເພື່ອສ້າງນາມແຝງ.
ເຊິ່ງສາມາດຖືກແປເປັນທ້ອງຖິ່ນ. (ແຕ່ຈົ່ງຮູ້ວ່ານີ້ຫມາຍຄວາມວ່າທ່ານບໍ່ສາມາດມີ @foo ແຍກຕ່າງຫາກແລະ
@bar, ແລະອື່ນໆ.)
ສິ່ງທີ່ເຮັດໃຫ້ທັງຫມົດນີ້ມີຄວາມສໍາຄັນແມ່ນວ່າໂມດູນຜູ້ສົ່ງອອກໃຊ້ glob aliasing ເປັນ
ກົນໄກການນໍາເຂົ້າ / ສົ່ງອອກ. ບໍ່ວ່າເຈົ້າສາມາດຕັ້ງຕົວແປໄດ້ຢ່າງຖືກຕ້ອງຫຼືບໍ່
ສົ່ງອອກຈາກໂມດູນແມ່ນຂຶ້ນກັບວິທີທີ່ມັນຖືກສົ່ງອອກ:
@EXPORT = qw($FOO); # ຮູບແບບປົກກະຕິ, ບໍ່ສາມາດແປໄດ້
@EXPORT = qw(*FOO); # ສາມາດແປໄດ້
ທ່ານສາມາດເຮັດວຽກປະມານກໍລະນີທໍາອິດໂດຍການນໍາໃຊ້ຊື່ທີ່ມີຄຸນສົມບັດຢ່າງເຕັມທີ່ ($Package::FOO) ບ່ອນທີ່
ທ່ານຕ້ອງການມູນຄ່າທ້ອງຖິ່ນ, ຫຼືໂດຍການ overriding ມັນໂດຍການເວົ້າວ່າ "*FOO = *Package::FOO" ໃນຂອງທ່ານ
script
ກົນໄກ "*x = \$y" ອາດຈະຖືກໃຊ້ເພື່ອຜ່ານ ແລະສົ່ງຄືນການອ້າງອີງລາຄາຖືກເຂົ້າໄປໃນ ຫຼືຈາກ
subroutines ຖ້າເຈົ້າບໍ່ຕ້ອງການຄັດລອກສິ່ງທັງຫມົດ. ມັນເຮັດວຽກພຽງແຕ່ເມື່ອມອບຫມາຍໃຫ້
ຕົວແປແບບເຄື່ອນໄຫວ, ບໍ່ແມ່ນ lexicals.
%some_hash = (); # ບໍ່ສາມາດເປັນຂອງຂ້ອຍ ()
*some_hash = fn(\%another_hash );
ຍ່ອຍ fn {
local *hashsym = shift;
# ດຽວນີ້ໃຊ້ %hashsym ປົກກະຕິ, ແລະເຈົ້າ
# ຈະສົ່ງຜົນກະທົບຕໍ່ %another_hash ຂອງຜູ້ໂທ
%nhash = (); #ເຮັດຕາມທີ່ເຈົ້າຕ້ອງການ
ກັບຄືນ \%nhash;
}
ໃນການກັບຄືນ, ການອ້າງອິງຈະຂຽນທັບຊ່ອງ hash ໃນຕາຕະລາງສັນຍາລັກທີ່ລະບຸໄວ້ໂດຍ
* some_hash typeglob. ນີ້ແມ່ນວິທີການທີ່ຫຍຸ້ງຍາກເລັກນ້ອຍໃນການຖ່າຍທອດເອກະສານອ້າງອີງລາຄາຖືກ
ໃນເວລາທີ່ທ່ານບໍ່ຕ້ອງການທີ່ຈະຈື່ຈໍາທີ່ຈະ dereference ຕົວແປຢ່າງຊັດເຈນ.
ການນໍາໃຊ້ຕາຕະລາງສັນຍາລັກອີກອັນຫນຶ່ງແມ່ນສໍາລັບການເຮັດເກັດ "ຄົງທີ່".
*PI = \3.14159265358979;
ໃນປັດຈຸບັນທ່ານບໍ່ສາມາດປ່ຽນແປງ $PI, ເຊິ່ງອາດຈະເປັນສິ່ງທີ່ດີທັງຫມົດ. ອັນນີ້ບໍ່ຄືກັນ
ເປັນ subroutine ຄົງທີ່, ເຊິ່ງຂຶ້ນກັບການເພີ່ມປະສິດທິພາບໃນເວລາລວບລວມ. ຄົງທີ່
subroutine ແມ່ນຫນຶ່ງ prototyped ທີ່ຈະບໍ່ໂຕ້ຖຽງແລະສົ່ງຄືນການສະແດງອອກຄົງທີ່.
ເບິ່ງ perlsub ສໍາລັບລາຍລະອຽດກ່ຽວກັບການເຫຼົ່ານີ້. Pragma "ໃຊ້ຄົງທີ່" ແມ່ນຫຍໍ້ທີ່ສະດວກສໍາລັບ
ເຫຼົ່ານີ້.
ທ່ານສາມາດເວົ້າວ່າ *foo{PACKAGE} ແລະ *foo{NAME} ເພື່ອຊອກຫາວ່າຊື່ໃດ ແລະຊຸດສັນຍາລັກ *foo
ຕາຕະລາງເຂົ້າມາຈາກ. ອັນນີ້ອາດຈະເປັນປະໂຫຍດໃນລາຍການຍ່ອຍທີ່ໄດ້ຮັບຜ່ານ typeglobs ເປັນ
ການໂຕ້ຖຽງ:
subify_typeglob {
$glob ຂອງຂ້ອຍ = shift;
ພິມ 'ເຈົ້າໃຫ້ຂ້ອຍ', *{$glob}{PACKAGE},
'::', *{$glob}{NAME}, "\n";
}
ident_typeglob *foo;
ident_typeglob *bar::baz;
ນີ້ພິມ
ເຈົ້າໃຫ້ຂ້ອຍຕົ້ນຕໍ ::foo
ເຈົ້າໃຫ້ຂ້ອຍບາ ::baz
ໝາຍເຫດ *foo{THING} ຍັງສາມາດຖືກໃຊ້ເພື່ອຮັບການອ້າງອີງເຖິງອົງປະກອບແຕ່ລະອັນ
ຂອງ *foo. ເບິ່ງ perlref.
ຄໍານິຍາມຍ່ອຍ (ແລະການປະກາດ, ສໍາລັບເລື່ອງນັ້ນ) ບໍ່ຈໍາເປັນຕ້ອງເປັນ
ຕັ້ງຢູ່ໃນຊຸດທີ່ມີຕາຕະລາງສັນຍາລັກທີ່ພວກເຂົາຄອບຄອງ. ທ່ານສາມາດກໍານົດ subroutine ໄດ້
ຢູ່ນອກຊຸດຂອງມັນໂດຍການກຳນົດຊື່ຂອງໂປຣເຈັກຍ່ອຍຢ່າງຈະແຈ້ງ:
package main;
sub Some_package::foo { ... } # &foo ກຳນົດໄວ້ໃນ Some_package
ນີ້ແມ່ນພຽງແຕ່ຫຍໍ້ມາຈາກການມອບໝາຍ typeglob ໃນເວລາລວບລວມ:
BEGIN { *Some_package::foo = ຍ່ອຍ { ... } }
ແລະແມ່ນ ບໍ່ ຄືກັນກັບການຂຽນ:
{
package Some_package;
ຍ່ອຍ foo { ... }
}
ໃນສອງສະບັບທໍາອິດ, ຮ່າງກາຍຂອງ subroutine ແມ່ນ lexically ໃນຊຸດຕົ້ນຕໍ,
ບໍ່ ໃນ Some_package. ດັ່ງນັ້ນບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:
package main;
$Some_package::name = "fred";
$main::name = "barney";
sub Some_package::foo {
ພິມ "ໃນ ", __PACKAGE__, ": \$name ແມ່ນ '$name'\n";
}
Some_package::foo();
ພິມ:
ໃນຕົ້ນຕໍ: $name ແມ່ນ 'barney'
ແທນທີ່ຈະ:
ໃນ Some_package: $name ແມ່ນ 'fred'
ນີ້ຍັງມີຜົນກະທົບສໍາລັບການນໍາໃຊ້ SUPER:: qualifier (ເບິ່ງ perlobj).
ເລີ່ມຕົ້ນ, UNITCHEC, ກວດເບິ່ງ, ໃນມັນ ແລະ END
ຫ້າບລັອກລະຫັດທີ່ມີຊື່ພິເສດແມ່ນຖືກປະຕິບັດໃນຕອນເລີ່ມຕົ້ນແລະໃນຕອນທ້າຍຂອງການແລ່ນ
ໂຄງການ Perl. ເຫຼົ່ານີ້ແມ່ນ "BEGIN", "UNITCHEC", "ກວດເບິ່ງ", "INIT", ແລະ "END".
ບລັອກລະຫັດເຫຼົ່ານີ້ສາມາດຖືກນໍາຫນ້າດ້ວຍ "sub" ເພື່ອໃຫ້ຮູບລັກສະນະຂອງ subroutine ໄດ້
(ເຖິງແມ່ນວ່ານີ້ບໍ່ໄດ້ຖືກພິຈາລະນາຮູບແບບທີ່ດີ). ຫນຶ່ງຄວນສັງເກດວ່າລະຫັດເຫຼົ່ານີ້ຕັນ
ບໍ່ມີຈິງເທົ່າທີ່ຕັ້ງຊື່ຍ່ອຍ (ເຖິງວ່າຈະມີຮູບລັກສະນະຂອງມັນ). ສິ່ງທີ່ໃຫ້
ນີ້ຢູ່ໄກແມ່ນຄວາມຈິງທີ່ວ່າທ່ານສາມາດມີ ເພີ່ມເຕີມ ກ່ວາ ຫນຶ່ງ ຂອງບລັອກລະຫັດເຫຼົ່ານີ້ຢູ່ໃນໂຄງການ,
ແລະພວກເຂົາຈະໄດ້ຮັບ ທັງຫມົດ ປະຕິບັດໃນເວລາທີ່ເຫມາະສົມ. ດັ່ງນັ້ນທ່ານບໍ່ສາມາດດໍາເນີນການໃດໆ
ລະຫັດເຫຼົ່ານີ້ຖືກບລັອກໂດຍຊື່.
ບລັອກລະຫັດ "BEGIN" ຈະຖືກປະຕິບັດໄວເທົ່າທີ່ຈະໄວໄດ້, ນັ້ນແມ່ນ, ໃນປັດຈຸບັນມັນສົມບູນ
ຖືກກໍານົດ, ເຖິງແມ່ນວ່າກ່ອນທີ່ສ່ວນທີ່ເຫຼືອຂອງໄຟລ໌ທີ່ມີ (ຫຼືສະຕຣິງ) ຖືກວິເຄາະ. ທ່ານອາດຈະມີ
ຕັນ "BEGIN" ຫຼາຍອັນພາຍໃນໄຟລ໌ (ຫຼື evaal'ed string); ພວກເຂົາເຈົ້າຈະປະຕິບັດຕາມລໍາດັບຂອງ
ຄໍານິຍາມ. ເນື່ອງຈາກວ່າບລັອກລະຫັດ "BEGIN" ດໍາເນີນການທັນທີ, ມັນສາມາດດຶງຄໍານິຍາມຕ່າງໆ
ຂອງ subroutines ແລະອື່ນໆຈາກໄຟລ໌ອື່ນໆໃນເວລາທີ່ຈະສັງເກດເຫັນກັບສ່ວນທີ່ເຫຼືອຂອງການລວບລວມ
ແລະເວລາແລ່ນ. ເມື່ອ "BEGIN" ແລ່ນ, ມັນບໍ່ໄດ້ຖືກ ກຳ ນົດທັນທີແລະລະຫັດໃດໆທີ່ມັນໃຊ້
ກັບຄືນໄປຫາສະລອຍນ້ໍາຄວາມຊົງຈໍາຂອງ Perl.
ບລັອກລະຫັດ "END" ຖືກປະຕິບັດຊ້າທີ່ສຸດເທົ່າທີ່ເປັນໄປໄດ້, ນັ້ນແມ່ນ, ຫຼັງຈາກ perl ສໍາເລັດ
ດໍາເນີນການໂຄງການແລະພຽງແຕ່ກ່ອນທີ່ນາຍພາສາຈະຖືກອອກ, ເຖິງແມ່ນວ່າມັນຈະອອກ
ເປັນຜົນມາຈາກການເປັນ ຕາຍ ຫນ້າທີ່. (ແຕ່ບໍ່ແມ່ນຖ້າຫາກວ່າມັນ morphing ເຂົ້າໄປໃນໂຄງການອື່ນໂດຍຜ່ານ
"exec", ຫຼືຖືກລະເບີດອອກຈາກນ້ໍາໂດຍສັນຍານ - ທ່ານຕ້ອງໃສ່ກັບດັກຕົວເອງ (ຖ້າ
ເຈົ້າສາມາດເຮັດໄດ້)) ເຈົ້າອາດມີຫຼາຍອັນ "END" ພາຍໃນໄຟລ໌ - ພວກມັນຈະດຳເນີນການໃນທາງກັບກັນ
ຄໍາສັ່ງຂອງຄໍານິຍາມ; ນັ້ນແມ່ນ: ສຸດທ້າຍ, ອອກກ່ອນ (LIFO). ຕັນ "END" ບໍ່ໄດ້ຖືກປະຕິບັດ
ເມື່ອທ່ານເອີ້ນໃຊ້ perl ດ້ວຍປຸ່ມ "-c", ຫຼືຖ້າການລວບລວມລົ້ມເຫລວ.
ໃຫ້ສັງເກດວ່າ "END" ບລັອກລະຫັດແມ່ນ ບໍ່ ປະຕິບັດໃນຕອນທ້າຍຂອງສະຕຣິງ "eval(): ຖ້າມີ "END"
ບລັອກລະຫັດຖືກສ້າງຢູ່ໃນສາຍ "eval()", ພວກມັນຈະຖືກປະຕິບັດຄືກັນກັບສິ່ງອື່ນໆ
ບລັອກລະຫັດ "END" ຂອງຊຸດນັ້ນຢູ່ໃນຄໍາສັ່ງ LIFO ກ່ອນທີ່ນາຍພາສາຈະຖືກ
ອອກແລ້ວ.
ພາຍໃນບລັອກລະຫັດ "END", $? ປະກອບມີຄ່າທີ່ໂຄງການຈະຜ່ານໄປ
"ອອກ()". ທ່ານສາມາດດັດແປງ $? ການປ່ຽນແປງຄ່າອອກຂອງໂຄງການ. ລະວັງການປ່ຽນແປງ
$? ໂດຍບັງເອີນ (ເຊັ່ນ: ແລ່ນຜ່ານ "ລະບົບ").
ພາຍໃນບລັອກ "END", ຄ່າຂອງ "${^GLOBAL_PHASE}" ຈະເປັນ "END".
ບລັອກລະຫັດ "UNITCHECK", "CHECK" ແລະ "INIT" ແມ່ນເປັນປະໂຫຍດເພື່ອຈັບການປ່ຽນແປງລະຫວ່າງ
ໄລຍະການລວບລວມແລະໄລຍະການປະຕິບັດຂອງໂຄງການຕົ້ນຕໍ.
ຕັນ "UNITCHECK" ແມ່ນດໍາເນີນການພຽງແຕ່ຫຼັງຈາກຫນ່ວຍງານທີ່ກໍານົດພວກມັນໄດ້ຖືກລວບລວມ. ໄດ້
ໄຟລ໌ໂຄງການຕົ້ນຕໍແລະແຕ່ລະໂມດູນທີ່ມັນໂຫລດແມ່ນຫນ່ວຍງານລວບລວມ, ເຊັ່ນດຽວກັບ string "eval",
ລະຫັດເວລາແລ່ນຖືກລວບລວມໂດຍໃຊ້ໂຄງສ້າງ "(?{ })" ໃນ regex, ໂທຫາ "ເຮັດ FILE",
"ຕ້ອງການ FILE", ແລະລະຫັດຫຼັງຈາກສະຫຼັບ "-e" ໃນເສັ້ນຄໍາສັ່ງ.
ບລັອກ "BEGIN" ແລະ "UNITCHECK" ບໍ່ກ່ຽວຂ້ອງໂດຍກົງກັບໄລຍະຂອງນາຍພາສາ.
ພວກເຂົາສາມາດສ້າງແລະປະຕິບັດໃນໄລຍະໃດຫນຶ່ງ.
"ກວດເບິ່ງ" ບລັອກລະຫັດແມ່ນດໍາເນີນການພຽງແຕ່ຫຼັງຈາກ ໃນເບື້ອງຕົ້ນ Perl ລວບລວມໄລຍະສິ້ນສຸດລົງແລະກ່ອນທີ່ຈະ
ເວລາແລ່ນເລີ່ມຕົ້ນ, ໃນຄໍາສັ່ງ LIFO. ບລັອກລະຫັດ "ກວດສອບ" ຖືກໃຊ້ໃນຊຸດຄອມພີວເຕີ Perl
ເພື່ອບັນທຶກສະຖານະທີ່ລວບລວມຂອງໂຄງການ.
ພາຍໃນບລັອກ "CHECK", ຄ່າຂອງ "${^GLOBAL_PHASE}" ຈະເປັນ "CHECK".
ຕັນ "INIT" ແມ່ນດໍາເນີນການກ່ອນທີ່ Perl runtime ເລີ່ມຕົ້ນການປະຕິບັດ, ໃນ "ທໍາອິດໃນ, ທໍາອິດ.
ອອກ" (FIFO).
ພາຍໃນບລັອກ "INIT", ຄ່າຂອງ "${^GLOBAL_PHASE}" ຈະເປັນ "INIT".
ຕັນ "ກວດສອບ" ແລະ "INIT" ໃນລະຫັດທີ່ລວບລວມໂດຍ "require", string "do", ຫຼື string "eval"
ຈະບໍ່ຖືກປະຕິບັດຖ້າພວກເຂົາເກີດຂຶ້ນຫຼັງຈາກສິ້ນສຸດໄລຍະການລວບລວມຂໍ້ມູນຕົ້ນຕໍ; ທີ່ສາມາດ
ເປັນບັນຫາໃນ mod_perl ແລະສະພາບແວດລ້ອມຄົງທີ່ອື່ນໆທີ່ນໍາໃຊ້ຫນ້າທີ່ເຫຼົ່ານັ້ນເພື່ອ
ໂຫຼດລະຫັດໃນເວລາແລ່ນ.
ເມື່ອທ່ານໃຊ້ -n ແລະ -p ສະຫຼັບໄປໃຊ້ Perl, "BEGIN" ແລະ "END" ເຮັດວຽກຄືກັນກັບພວກເຂົາ
ງຸ່ມ, ເປັນກໍລະນີ degenerate. ທັງສອງບລັອກ "BEGIN" ແລະ "ກວດສອບ" ແມ່ນດໍາເນີນການເມື່ອທ່ານໃຊ້ -c
ສະຫຼັບສໍາລັບການກວດສອບ syntax ລວບລວມພຽງແຕ່, ເຖິງແມ່ນວ່າລະຫັດຕົ້ນຕໍຂອງທ່ານບໍ່ແມ່ນ.
ໄດ້ ເລີ່ມກວດ ໂຄງການເຮັດໃຫ້ມັນຊັດເຈນທັງຫມົດ, ໃນທີ່ສຸດ:
#!/usr/bin/perl
# ເລີ່ມຕົ້ນກວດສອບ
ພິມ "10. ລະຫັດທຳມະດາແລ່ນໃນເວລາແລ່ນ.\n";
END { print "16. ດັ່ງນັ້ນນີ້ແມ່ນຕອນທ້າຍຂອງນິທານ.\n" }
INIT { print " 7. INIT blocks ແລ່ນ FIFO ກ່ອນ runtime.\n" }
ຖອນການກວດສອບ {
ພິມ " 4. ແລະດັ່ງນັ້ນກ່ອນທີ່ຈະປິດການກວດສອບໃດໆ.\n"
}
ກວດເບິ່ງ { ພິມ " 6. ດັ່ງນັ້ນນີ້ແມ່ນແຖວທີຫົກ.\n" }
ພິມ "11. ມັນແລ່ນຕາມລຳດັບ, ແນ່ນອນ.\n";
BEGIN {ພິມ " 1. BEGIN blocks ແລ່ນ FIFO ໃນລະຫວ່າງການລວບລວມ.\n" }
END { ພິມ "15. ອ່ານ perlmod ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງເລື່ອງ.\n" }
ກວດເບິ່ງ { ພິມ " 5. ກວດເບິ່ງບລັອກແລ່ນ LIFO ຫຼັງຈາກການລວບລວມຂໍ້ມູນທັງໝົດ.\n" }
INIT { print " 8. ແລ່ນອັນນີ້ອີກຄັ້ງ, ໂດຍໃຊ້ປຸ່ມ Perl's -c switch.\n" }
ພິມ "12. ນີ້ແມ່ນລະຫັດຕ້ານການສັບສົນ.\n";
END { ພິມ "14. END ບລັອກແລ່ນ LIFO ໃນເວລາອອກ.\n" }
BEGIN {ພິມ " 2. ດັ່ງນັ້ນເສັ້ນນີ້ອອກມາທີສອງ.\n" }
ຖອນການກວດສອບ {
ພິມ " 3. UNITCHECK ແລ່ນ LIFO ຫຼັງຈາກແຕ່ລະໄຟລ໌ຖືກລວບລວມ.\n"
}
INIT { print " 9. ທ່ານຈະເຫັນຄວາມແຕກຕ່າງໃນທັນທີ.\n" }
ພິມ "13. ມັນພຽງແຕ່ _looks_ ມັນຄວນຈະສັບສົນ.\n";
__END__
Perl ຫ້ອງຮຽນ
ບໍ່ມີ syntax ຫ້ອງຮຽນພິເສດໃນ Perl, ແຕ່ຊຸດຫນຶ່ງອາດຈະເຮັດຫນ້າທີ່ເປັນຫ້ອງຮຽນຖ້າມັນສະຫນອງ
subroutines ເພື່ອປະຕິບັດເປັນວິທີການ. ຊຸດດັ່ງກ່າວອາດຈະມາຈາກບາງວິທີການຂອງມັນ
class ອື່ນ (package) ໂດຍສະແດງຊື່ແພັກເກັດອື່ນໃນ array @ISA ທົ່ວໂລກ
(ເຊິ່ງຈະຕ້ອງເປັນຊຸດທົ່ວໂລກ, ບໍ່ແມ່ນ lexical).
ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້, ເບິ່ງ perlootut ແລະ perlobj.
Perl ໂມດູນ
ໂມດູນແມ່ນພຽງແຕ່ຊຸດຂອງຫນ້າທີ່ທີ່ກ່ຽວຂ້ອງໃນໄຟລ໌ຫ້ອງສະຫມຸດ, ie, ຊຸດ Perl ກັບ
ຊື່ດຽວກັນກັບໄຟລ໌. ມັນໄດ້ຖືກອອກແບບໂດຍສະເພາະເພື່ອນໍາໃຊ້ຄືນໃຫມ່ໂດຍໂມດູນອື່ນໆຫຼື
ໂຄງການ. ມັນອາດຈະເຮັດແນວນີ້ໂດຍການສະຫນອງກົນໄກສໍາລັບການສົ່ງອອກບາງສ່ວນຂອງສັນຍາລັກຂອງຕົນເຂົ້າໄປໃນ
ຕາຕະລາງສັນຍາລັກຂອງຊຸດໃດຫນຶ່ງໂດຍໃຊ້ມັນ, ຫຼືມັນອາດຈະເຮັດຫນ້າທີ່ເປັນຄໍານິຍາມຂອງຊັ້ນຮຽນແລະ
ເຮັດໃຫ້ semantics ຂອງມັນສາມາດໃຊ້ໄດ້ໂດຍ implicitly ໂດຍຜ່ານວິທີການໂທຫາຫ້ອງຮຽນແລະວັດຖຸຂອງມັນ,
ໂດຍບໍ່ມີການສົ່ງອອກຢ່າງຈະແຈ້ງ. ຫຼືມັນສາມາດເຮັດໄດ້ເລັກນ້ອຍຂອງທັງສອງ.
ຕົວຢ່າງ, ເພື່ອເລີ່ມຕົ້ນໂມດູນແບບດັ້ງເດີມ, ບໍ່ແມ່ນ OO ທີ່ເອີ້ນວ່າ Some::Module, ສ້າງໄຟລ໌
ເອີ້ນວ່າ Some/Module.pm ແລະເລີ່ມຕົ້ນດ້ວຍແມ່ແບບນີ້:
ຊຸດບາງ::ໂມດູນ; # ສົມມຸດ Some/Module.pm
ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;
{
ຕ້ອງການຜູ້ສົ່ງອອກ;
# ກໍານົດສະບັບສໍາລັບການກວດສອບສະບັບ
$VERSION ຂອງພວກເຮົາ = 1.00;
# ສືບທອດຈາກຜູ້ສົ່ງອອກໄປສູ່ຫນ້າທີ່ສົ່ງອອກແລະຕົວແປ
@ISA ຂອງພວກເຮົາ = qw(ຜູ້ສົ່ງອອກ);
# ຟັງຊັນແລະຕົວແປທີ່ຖືກສົ່ງອອກໂດຍຄ່າເລີ່ມຕົ້ນ
ຂອງພວກເຮົາ @EXPORT = qw(func1 func2);
# ຟັງຊັນແລະຕົວແປທີ່ສາມາດສົ່ງອອກເປັນທາງເລືອກ
@EXPORT_OK ຂອງພວກເຮົາ = qw($Var1 %Hashit func3);
}
# ແພັກເກດທີ່ສົ່ງອອກທົ່ວໂລກໄປບ່ອນນີ້
$Var1 ຂອງພວກເຮົາ = '';
%Hashit = ();
# ຊຸດທີ່ບໍ່ໄດ້ສົ່ງອອກທົ່ວໂລກໄປທີ່ນີ້
# (ພວກມັນຍັງສາມາດເຂົ້າເຖິງໄດ້ເປັນ $Some::Module::stuff)
@more = ();
$stuff ຂອງພວກເຮົາ = '';
# file-private lexicals ໄປທີ່ນີ້, ກ່ອນທີ່ຈະມີຟັງຊັນຕ່າງໆທີ່ໃຊ້ພວກມັນ
$priv_var ຂອງຂ້ອຍ = '';
%secret_hash = ();
# ນີ້ແມ່ນຟັງຊັນໄຟລ໌ສ່ວນຕົວເປັນການປິດ,
# ເອີ້ນວ່າ $priv_func->();
$priv_func ຂອງຂ້ອຍ = ຍ່ອຍ {
...
};
# ເຮັດຫນ້າທີ່ຂອງທ່ານທັງຫມົດ, ບໍ່ວ່າຈະສົ່ງອອກຫລືບໍ່;
# ຈື່ໄວ້ວ່າຄວນໃສ່ສິ່ງທີ່ໜ້າສົນໃຈໃນ {} stubs
sub func1 { ... }
sub func2 { ... }
# ອັນນີ້ບໍ່ໄດ້ສົ່ງອອກ, ແຕ່ສາມາດໂທຫາໂດຍກົງ
# ເປັນບາງ::Module::func3()
sub func3 { ... }
END { ... } # ລະຫັດລ້າງໂມດູນຢູ່ທີ່ນີ້ (ຕົວທຳລາຍທົ່ວໂລກ)
1; # ຢ່າລືມສົ່ງຄ່າທີ່ແທ້ຈິງຈາກໄຟລ໌
ຫຼັງຈາກນັ້ນ, ສືບຕໍ່ປະກາດແລະນໍາໃຊ້ຕົວແປຂອງທ່ານໃນຫນ້າທີ່ໂດຍບໍ່ມີຄຸນສົມບັດໃດໆ. ເບິ່ງ
ຜູ້ສົ່ງອອກແລະ perlmodlib ສໍາລັບລາຍລະອຽດກ່ຽວກັບກົນໄກແລະບັນຫາຮູບແບບໃນການສ້າງໂມດູນ.
ໂມດູນ Perl ຖືກລວມເຂົ້າໃນໂຄງການຂອງທ່ານໂດຍການເວົ້າ
ໃຊ້ໂມດູນ;
or
ໃຊ້ Module LIST;
ນີ້ແມ່ນແທ້ທຽບເທົ່າກັບ
BEGIN { ຕ້ອງການ 'Module.pm'; 'ໂມດູນ'->ນໍາເຂົ້າ; }
or
BEGIN { ຕ້ອງການ 'Module.pm'; 'ໂມດູນ'->ນຳເຂົ້າ(ລາຍຊື່); }
ເປັນກໍລະນີພິເສດ
ໃຊ້ Module ();
ແມ່ນແທ້ທຽບເທົ່າກັບ
BEGIN { ຕ້ອງການ 'Module.pm'; }
ໄຟລ໌ໂມດູນ Perl ທັງໝົດມີສ່ວນຂະຫຍາຍ pm. ຕົວປະຕິບັດການ "ໃຊ້" ຖືວ່ານີ້ດັ່ງນັ້ນທ່ານ
ບໍ່ ຈຳ ເປັນຕ້ອງສະກົດ "Module.pm" ໃນວົງຢືມ. ນີ້ຍັງຊ່ວຍໃຫ້ຄວາມແຕກຕ່າງໃຫມ່
ໂມດູນຈາກເກົ່າ pl ແລະ ph ໄຟລ໌. ຊື່ໂມດູນຍັງຖືກພິມເປັນຕົວພິມໃຫຍ່ເວັ້ນເສຍແຕ່ວ່າພວກມັນ
ເຮັດວຽກເປັນ pragmas; pragmas ແມ່ນຢູ່ໃນຄໍາສັ່ງ compiler ທີ່ມີປະສິດທິພາບ, ແລະບາງຄັ້ງ
ເອີ້ນວ່າ "ໂມດູນ pragmatic" (ຫຼືແມ້ກະທັ້ງ "pragmata" ຖ້າທ່ານເປັນຄລາສສິກ).
ສອງຄໍາຖະແຫຼງການ:
ຕ້ອງການ SomeModule;
ຕ້ອງການ "SomeModule.pm";
ແຕກຕ່າງຈາກກັນແລະກັນໃນສອງທາງ. ໃນກໍລະນີທໍາອິດ, ຈໍ້າສອງເມັດໃນໂມດູນ
ຊື່, ເຊັ່ນ "ບາງ::ໂມດູນ", ຖືກແປເປັນຕົວແຍກໄດເລກະທໍລີຂອງລະບົບຂອງທ່ານ,
ປົກກະຕິແລ້ວ "/". ກໍລະນີທີສອງບໍ່ໄດ້, ແລະຈະຕ້ອງໄດ້ລະບຸຕົວຫນັງສື. ໄດ້
ຄວາມແຕກຕ່າງອື່ນໆແມ່ນວ່າເຫັນຂໍ້ຄຶດ "ຕ້ອງການ" ທໍາອິດໃນ compiler ທີ່ໃຊ້
ຫມາຍເຫດວັດຖຸທາງອ້ອມທີ່ກ່ຽວຂ້ອງກັບ "SomeModule", ຄືກັບ "$ob = purg SomeModule", ແມ່ນ
ການໂທດ້ວຍວິທີການ, ບໍ່ແມ່ນການໂທທີ່ເຮັດວຽກ. (ແມ່ນແລ້ວ, ນີ້ກໍ່ສາມາດເຮັດໃຫ້ຄວາມແຕກຕ່າງໄດ້.)
ເນື່ອງຈາກວ່າຄໍາຖະແຫຼງທີ່ "ໃຊ້" ຫມາຍເຖິງ "BEGIN", ການນໍາເຂົ້າຂອງ semantics ເກີດຂຶ້ນ
ທັນທີທີ່ຄໍາຖະແຫຼງການ "ໃຊ້" ຖືກລວບລວມ, ກ່ອນທີ່ໄຟລ໌ທີ່ເຫຼືອຈະຖືກລວບລວມ. ນີ້ແມ່ນ
ມັນສາມາດເຮັດວຽກເປັນກົນໄກ pragma ໄດ້ແນວໃດ, ແລະຍັງວິທີທີ່ໂມດູນສາມາດປະກາດໄດ້
subroutines ທີ່ເຫັນໄດ້ຈາກບັນຊີລາຍຊື່ຫຼື unary operator ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງປະຈຸບັນ
ໄຟລ໌. ນີ້ຈະບໍ່ເຮັດວຽກຖ້າທ່ານໃຊ້ "require" ແທນທີ່ຈະ "ໃຊ້". ດ້ວຍ "ຕ້ອງການ" ທ່ານສາມາດເຮັດໄດ້
ເຂົ້າໄປໃນບັນຫານີ້:
ຕ້ອງການ Cwd; # ເຮັດໃຫ້ Cwd:: ເຂົ້າເຖິງ
$here = Cwd::getcwd();
ໃຊ້ Cwd; # ຊື່ນໍາເຂົ້າຈາກ Cwd::
$ here = getcwd();
ຕ້ອງການ Cwd; # ເຮັດໃຫ້ Cwd:: ເຂົ້າເຖິງ
$ here = getcwd(); # ອຸຍ! ບໍ່ມີຕົ້ນຕໍ::getcwd()
ໂດຍທົ່ວໄປ, "ໃຊ້ Module ()" ແມ່ນແນະນໍາໃຫ້ຫຼາຍກວ່າ "require Module", ເພາະວ່າມັນກໍານົດ
ຄວາມພ້ອມຂອງໂມດູນໃນເວລາລວບລວມ, ບໍ່ແມ່ນຢູ່ໃນລະຫວ່າງການປະຕິບັດໂຄງການຂອງທ່ານ. ອັນ
ຂໍ້ຍົກເວັ້ນແມ່ນຖ້າສອງໂມດູນແຕ່ລະຄົນພະຍາຍາມ "ໃຊ້" ເຊິ່ງກັນແລະກັນ, ແລະແຕ່ລະຄົນຍັງເອີ້ນວ່າ a
ຟັງຊັນຈາກໂມດູນອື່ນນັ້ນ. ໃນກໍລະນີດັ່ງກ່າວ, ມັນງ່າຍທີ່ຈະໃຊ້ "require" ແທນ.
ແພັກເກັດ Perl ອາດຈະຖືກຕັ້ງຢູ່ໃນຊື່ແພັກເກັດອື່ນ, ດັ່ງນັ້ນພວກເຮົາສາມາດມີຊື່ແພັກເກັດ
ບັນຈຸ "::". ແຕ່ຖ້າພວກເຮົາໃຊ້ຊື່ແພັກເກັດນັ້ນໂດຍກົງເປັນຊື່ໄຟລ໌ມັນກໍ່ຈະເຮັດໃຫ້
ສໍາລັບຊື່ໄຟລ໌ທີ່ບໍ່ມີປະໂຫຍດ ຫຼືເປັນໄປບໍ່ໄດ້ໃນບາງລະບົບ. ດັ່ງນັ້ນ, ຖ້າຊື່ຂອງໂມດູນແມ່ນ,
ເວົ້າວ່າ, "ຂໍ້ຄວາມ::Soundex", ຫຼັງຈາກນັ້ນຄໍານິຍາມຂອງມັນຖືກພົບເຫັນຢູ່ໃນໄຟລ໌ຫ້ອງສະຫມຸດ
ຂໍ້ຄວາມ/Soundex.pm.
ໂມດູນ Perl ສະເຫມີມີ pm ໄຟລ໌, ແຕ່ມັນອາດຈະມີການເຊື່ອມໂຍງແບບເຄື່ອນໄຫວ
(ມັກຈະສິ້ນສຸດໃນ ດັ່ງນັ້ນ,) ຫຼື autoloaded subroutine ຄໍານິຍາມ (ມັກຈະສິ້ນສຸດໃນ al)
ກ່ຽວຂ້ອງກັບໂມດູນ. ຖ້າເປັນດັ່ງນັ້ນ, ເຫຼົ່ານີ້ຈະມີຄວາມໂປ່ງໃສທັງຫມົດຕໍ່ຜູ້ໃຊ້ຂອງ
ໂມດູນ. ມັນເປັນຄວາມຮັບຜິດຊອບຂອງ pm ໄຟລ໌ທີ່ຈະໂຫລດ (ຫຼືຈັດໃຫ້ autoload) ໃດໆ
ການທໍາງານເພີ່ມເຕີມ. ຕົວຢ່າງ, ເຖິງແມ່ນວ່າໂມດູນ POSIX ເກີດຂຶ້ນເພື່ອເຮັດທັງສອງ
ການໂຫຼດແບບເຄື່ອນໄຫວແລະການໂຫຼດອັດຕະໂນມັດ, ຜູ້ໃຊ້ສາມາດເວົ້າພຽງແຕ່ "ໃຊ້ POSIX" ເພື່ອໃຫ້ໄດ້ຮັບມັນທັງຫມົດ.
ການເຮັດໃຫ້ ຂອງທ່ານ ໂມດູນ ປອດໄພກະທູ້
Perl ສະຫນັບສະຫນູນປະເພດຂອງກະທູ້ທີ່ເອີ້ນວ່າຫົວຂໍ້ແປ (ithreads). ກະທູ້ເຫຼົ່ານີ້ສາມາດ
ຖືກນໍາໃຊ້ຢ່າງຈະແຈ້ງແລະ implicitly.
ຫົວຂໍ້ເຮັດວຽກໂດຍການໂຄນຂໍ້ມູນຕົ້ນໄມ້ເພື່ອບໍ່ໃຫ້ຂໍ້ມູນຖືກແບ່ງປັນລະຫວ່າງທີ່ແຕກຕ່າງກັນ
ກະທູ້. ກະທູ້ເຫຼົ່ານີ້ສາມາດຖືກນໍາໃຊ້ໂດຍໃຊ້ໂມດູນ "ກະທູ້" ຫຼືໂດຍການເຮັດ ສ້ອມ () on
win32 (ປອມ ສ້ອມ () ສະຫນັບສະຫນູນ). ເມື່ອກະທູ້ຖືກໂຄນຂໍ້ມູນ Perl ທັງໝົດຖືກໂຄນ, ແນວໃດກໍ່ຕາມບໍ່ແມ່ນ.
ຂໍ້ມູນ Perl ບໍ່ສາມາດຖືກໂຄນອັດຕະໂນມັດໄດ້. Perl ຫຼັງຈາກ 5.8.0 ມີການສະຫນັບສະຫນູນ "CLONE"
ປົກກະຕິຍ່ອຍພິເສດ. ໃນ "CLONE" ທ່ານສາມາດເຮັດອັນໃດກໍ່ຕາມທີ່ທ່ານຕ້ອງການເຮັດ, ເຊັ່ນ: ຕົວຢ່າງ
ຈັດການ cloning ຂອງຂໍ້ມູນທີ່ບໍ່ແມ່ນ Perl, ຖ້າຈໍາເປັນ. "CLONE" ຈະຖືກເອີ້ນຄັ້ງດຽວເປັນຫ້ອງຮຽນ
ວິທີການສໍາລັບທຸກໆຊຸດທີ່ມີມັນກໍານົດ (ຫຼືສືບທອດມັນ). ມັນຈະຖືກເອີ້ນວ່າຢູ່ໃນ
ສະພາບການຂອງຫົວຂໍ້ໃຫມ່, ດັ່ງນັ້ນການດັດແກ້ທັງຫມົດແມ່ນເຮັດຢູ່ໃນພື້ນທີ່ໃຫມ່. ໃນປັດຈຸບັນ CLONE
ເອີ້ນວ່າບໍ່ມີຕົວກໍານົດການອື່ນນອກຈາກຊື່ຊຸດ invocant, ແຕ່ລະຫັດບໍ່ຄວນ
ສົມມຸດວ່ານີ້ຈະຍັງຄົງບໍ່ປ່ຽນແປງ, ຍ້ອນວ່າມັນເປັນໄປໄດ້ໃນຕົວກໍານົດການເພີ່ມເຕີມໃນອະນາຄົດ
ຈະໄດ້ຮັບການຜ່ານໃນການໃຫ້ຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບສະຖານະການຂອງ cloning.
ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະ CLONE ວັດຖຸທັງຫມົດທີ່ທ່ານຈະຈໍາເປັນຕ້ອງໄດ້ຕິດຕາມຂອງພວກເຂົາຕໍ່ຊຸດ. ນີ້ແມ່ນ
ເຮັດໄດ້ງ່າຍໆໂດຍໃຊ້ hash ແລະ Scalar::Util::weaken().
Perl ຫຼັງຈາກ 5.8.7 ມີການສະຫນັບສະຫນູນສໍາລັບ "CLONE_SKIP" ກິດຈະກໍາຍ່ອຍພິເສດ. ເຊັ່ນດຽວກັນກັບ "CLONE",
"CLONE_SKIP" ຖືກເອີ້ນເທື່ອດຽວຕໍ່ຊຸດ; ແນວໃດກໍ່ຕາມ, ມັນຖືກເອີ້ນວ່າກ່ອນທີ່ຈະ cloning ເລີ່ມຕົ້ນ,
ແລະໃນສະພາບການຂອງກະທູ້ພໍ່ແມ່. ຖ້າມັນກັບຄືນມູນຄ່າທີ່ແທ້ຈິງ, ຫຼັງຈາກນັ້ນບໍ່ມີວັດຖຸຂອງ
ຫ້ອງຮຽນນັ້ນຈະຖືກ cloned; ຫຼືແທນທີ່ຈະ, ພວກເຂົາເຈົ້າຈະຖືກຄັດລອກເປັນ unblessed, undef ຄ່າ. ສໍາລັບ
ຕົວຢ່າງ: ຖ້າຢູ່ໃນພໍ່ແມ່ມີສອງຄໍາອ້າງອີງເຖິງ hash ທີ່ໄດ້ຮັບພອນອັນດຽວ, ຫຼັງຈາກນັ້ນຢູ່ໃນ
ເດັກນ້ອຍຈະມີການອ້າງອີງສອງອັນຕໍ່ກັບຄ່າສະເກັດລາທີ່ບໍ່ໄດ້ກໍານົດອັນດຽວແທນ. ນີ້
ສະຫນອງກົນໄກງ່າຍດາຍສໍາລັບການເຮັດໃຫ້ກະທູ້ໂມດູນປອດໄພ; ພຽງແຕ່ເພີ່ມ "ຍ່ອຍ CLONE_SKIP { 1
}" ຢູ່ເທິງສຸດຂອງຊັ້ນຮຽນ, ແລະ "DESTROY()" ດຽວນີ້ຈະຖືກເອີ້ນພຽງແຕ່ຄັ້ງດຽວຕໍ່ວັດຖຸ.
ແນ່ນອນ, ຖ້າກະທູ້ເດັກນ້ອຍຕ້ອງການໃຊ້ວັດຖຸ, ຫຼັງຈາກນັ້ນມີຄວາມຊັບຊ້ອນຫຼາຍ
ວິທີການແມ່ນຈໍາເປັນ.
ເຊັ່ນດຽວກັບ "CLONE", "CLONE_SKIP" ປະຈຸບັນຖືກເອີ້ນໂດຍບໍ່ມີພາລາມິເຕີອື່ນນອກເຫນືອຈາກຜູ້ຮຽກຮ້ອງ
ຊື່ແພັກເກັດ, ເຖິງແມ່ນວ່າອາດຈະມີການປ່ຽນແປງ. ເຊັ່ນດຽວກັນ, ເພື່ອອະນຸຍາດໃຫ້ການຂະຫຍາຍຕົວໃນອະນາຄົດ, ໄດ້
ຄ່າກັບຄືນຄວນເປັນຄ່າ 0 ຫຼື 1 ອັນດຽວ.
ໃຊ້ perlmod ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
