ນີ້ແມ່ນຄໍາສັ່ງ perldebtut ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
perldebtut - ການສອນການແກ້ບັນຫາ Perl
ລາຍລະອຽດ
ການແນະນໍາທີ່ມີນ້ໍາຫນັກເບົາ (ຫຼາຍ) ໃນການນໍາໃຊ້ perl debugger, ແລະຕົວຊີ້ໄປຫາ
ທີ່ມີຢູ່ແລ້ວ, ແຫຼ່ງຂໍ້ມູນທີ່ເລິກເຊິ່ງກ່ຽວກັບໂຄງການ debugging perl.
ມີຄົນທີ່ບໍ່ຮູ້ຈັກຫຍັງເລີຍ
ກ່ຽວກັບການໃຊ້ perl debugger, ເຖິງແມ່ນວ່າພວກເຂົາໃຊ້ພາສາທຸກໆມື້. ນີ້ແມ່ນສໍາລັບພວກເຂົາ.
ການນໍາໃຊ້ ຢ່າງເຄັ່ງຄັດ
ກ່ອນອື່ນ ໝົດ, ມີບາງສິ່ງທີ່ເຈົ້າສາມາດເຮັດໄດ້ເພື່ອເຮັດໃຫ້ຊີວິດຂອງເຈົ້າມີຄວາມກົງໄປກົງມາຫຼາຍ
ໃນເວລາທີ່ມັນມາກັບ debugging ໂຄງການ perl, ໂດຍບໍ່ມີການນໍາໃຊ້ debugger ທັງຫມົດ. ເຖິງ
ສະແດງໃຫ້ເຫັນ, ນີ້ແມ່ນ script ງ່າຍດາຍ, ທີ່ມີຊື່ວ່າ "ສະບາຍດີ", ມີບັນຫາ:
#!/usr/bin/perl
$var1 = 'ສະບາຍດີໂລກ'; #ຢາກເຮັດແບບນັ້ນສະເໝີ :-)
$var2 = "$varl\n";
ພິມ $var2;
ອອກ;
ໃນຂະນະທີ່ນີ້ລວບລວມແລະດໍາເນີນການຢ່າງມີຄວາມສຸກ, ມັນອາດຈະບໍ່ເຮັດສິ່ງທີ່ຄາດຫວັງ, ຄືມັນ
ບໍ່ໄດ້ພິມ "ສະບາຍດີໂລກ\n" ເລີຍ; ໃນທາງກົງກັນຂ້າມ, ມັນຈະເຮັດສິ່ງທີ່ມັນແມ່ນ
ບອກໃຫ້ເຮັດ, ຄອມພິວເຕີເປັນແນວນັ້ນເລັກນ້ອຍ. ນັ້ນແມ່ນ, ມັນຈະພິມອອກເສັ້ນໃຫມ່
ລັກສະນະ, ແລະທ່ານຈະໄດ້ຮັບສິ່ງທີ່ຄ້າຍຄືເສັ້ນເປົ່າ. ເບິ່ງຄືວ່າມີ 2 ຕົວແປ
ເມື່ອ (ຍ້ອນການພິມຜິດ) ມີ 3 ແທ້ໆ:
$var1 = 'ສະບາຍດີໂລກ';
$varl = undef;
$var2 = "\n";
ເພື່ອຈັບບັນຫາແບບນີ້, ພວກເຮົາສາມາດບັງຄັບໃຫ້ແຕ່ລະຕົວແປຖືກປະກາດກ່ອນທີ່ຈະໃຊ້ໂດຍ
ດຶງຢູ່ໃນໂມດູນທີ່ເຄັ່ງຄັດ, ໂດຍການວາງ 'ໃຊ້ຢ່າງເຄັ່ງຄັດ;' ຫຼັງຈາກແຖວທໍາອິດຂອງ script.
ໃນປັດຈຸບັນໃນເວລາທີ່ທ່ານດໍາເນີນການມັນ, perl ຈົ່ມກ່ຽວກັບ 3 ຕົວແປທີ່ບໍ່ໄດ້ປະກາດແລະພວກເຮົາໄດ້ຮັບສີ່ຄວາມຜິດພາດ.
ຂໍ້ຄວາມເພາະວ່າຕົວແປຫນຶ່ງຖືກອ້າງອີງສອງຄັ້ງ:
ສັນຍາລັກທົ່ວໂລກ "$var1" ຕ້ອງການຊື່ແພັກເກັດທີ່ຊັດເຈນຢູ່ທີ່ ./t1 ແຖວ 4.
ສັນຍາລັກທົ່ວໂລກ "$var2" ຕ້ອງການຊື່ແພັກເກັດທີ່ຊັດເຈນຢູ່ທີ່ ./t1 ແຖວ 5.
ສັນຍາລັກທົ່ວໂລກ "$varl" ຕ້ອງການຊື່ແພັກເກັດທີ່ຊັດເຈນຢູ່ທີ່ ./t1 ແຖວ 5.
ສັນຍາລັກທົ່ວໂລກ "$var2" ຕ້ອງການຊື່ແພັກເກັດທີ່ຊັດເຈນຢູ່ທີ່ ./t1 ແຖວ 7.
ການປະຕິບັດ ./hello ຖືກຍົກເລີກເນື່ອງຈາກຄວາມຜິດພາດການລວບລວມ.
ລູເວີລີ! ແລະເພື່ອແກ້ໄຂນີ້, ພວກເຮົາປະກາດຕົວແປທັງຫມົດຢ່າງຊັດເຈນແລະໃນປັດຈຸບັນ script ຂອງພວກເຮົາເບິ່ງ
ເຊັ່ນນີ້:
#!/usr/bin/perl
ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ຂອງຂ້ອຍ $var1 = 'ສະບາຍດີໂລກ';
$varl ຂອງຂ້ອຍ = undef;
$var2 = "$varl\n" ຂອງຂ້ອຍ;
ພິມ $var2;
ອອກ;
ຫຼັງຈາກນັ້ນ, ພວກເຮົາເຮັດ (ຄວາມຄິດທີ່ດີສະເຫມີ) ການກວດສອບ syntax ກ່ອນທີ່ພວກເຮົາຈະພະຍາຍາມດໍາເນີນການອີກເທື່ອຫນຶ່ງ:
> perl -c ສະບາຍດີ
ສະບາຍດີ syntax OK
ແລະດຽວນີ້ເມື່ອພວກເຮົາແລ່ນມັນ, ພວກເຮົາຍັງໄດ້ຮັບ "\n", ແຕ່ຢ່າງນ້ອຍພວກເຮົາຮູ້ວ່າເປັນຫຍັງ. ພຽງແຕ່ໄດ້ຮັບນີ້
script ທີ່ຈະລວບລວມໄດ້ເປີດເຜີຍຕົວແປ '$varl' (ດ້ວຍຕົວອັກສອນ 'l') ແລະງ່າຍດາຍ.
ການປ່ຽນ $varl ເປັນ $var1 ແກ້ໄຂບັນຫາໄດ້.
ຊອກຫາ at ຂໍ້ມູນ ແລະ -w ແລະ v
ຕົກລົງ, ແຕ່ເມື່ອທ່ານຕ້ອງການເບິ່ງຂໍ້ມູນຂອງທ່ານແທ້ໆ, ແມ່ນຫຍັງຢູ່ໃນຕົວແປແບບເຄື່ອນໄຫວນັ້ນ,
ກ່ອນທີ່ຈະນໍາໃຊ້ມັນ?
#!/usr/bin/perl
ໃຊ້ຢ່າງເຄັ່ງຄັດ;
$key ຂອງຂ້ອຍ = 'ຍິນດີຕ້ອນຮັບ';
%data ຂອງຂ້ອຍ = (
'ນີ້' => qw(ນັ້ນ),
'tom' => qw(ແລະ jerry),
'ຍິນດີຕ້ອນຮັບ' => q(ສະບາຍດີໂລກ),
'zip' => q(ຍິນດີຕ້ອນຮັບ),
);
@data ຂອງຂ້ອຍ = ລະຫັດ %data;
ພິມ "$data{$key}\n";
ອອກ;
ເບິ່ງຄືວ່າ OK, ຫຼັງຈາກທີ່ມັນຜ່ານການກວດສອບ syntax (perl -c scriptname), ພວກເຮົາດໍາເນີນການແລະທັງຫມົດ.
ພວກເຮົາໄດ້ຮັບແມ່ນເສັ້ນເປົ່າອີກເທື່ອຫນຶ່ງ! ຮືມມມ.
ຫນຶ່ງໃນວິທີການແກ້ບັນຫາທົ່ວໄປຢູ່ທີ່ນີ້, ຈະເປັນການປະຖິ້ມຄໍາຖະແຫຼງການພິມບາງຢ່າງຢ່າງເສລີ,
ເພື່ອເພີ່ມການກວດສອບກ່ອນທີ່ພວກເຮົາຈະພິມອອກຂໍ້ມູນຂອງພວກເຮົາ, ແລະອັນອື່ນຫຼັງຈາກ:
ພິມ "ຕົກລົງທັງໝົດ\n" ຖ້າ grep($key, keys %data);
ພິມ "$data{$key}\n";
ພິມ "ແລ້ວໆ: '$data{$key}'\n";
ແລະລອງໃໝ່ອີກ:
> ຂໍ້ມູນ perl
ທັງຫມົດ OK
ສຳເລັດ:''
ຫຼັງຈາກທີ່ຫຼາຍ staring ຢູ່ສິ້ນດຽວກັນຂອງລະຫັດແລະບໍ່ເຫັນໄມ້ສໍາລັບຕົ້ນໄມ້ສໍາລັບການ
ບາງຄັ້ງ, ພວກເຮົາໄດ້ຮັບກາເຟຈອກຫນຶ່ງແລະພະຍາຍາມວິທີການອື່ນ. ນັ້ນແມ່ນ, ພວກເຮົາເອົາມາໃຫ້
ທະຫານມ້າໂດຍການໃຫ້ perl ໄດ້ '-d' ສະຫຼັບເສັ້ນຄໍາສັ່ງ:
> ຂໍ້ມູນ perl -d
ຟື້ນຟູຕົວຈັບການຕາຍເລີ່ມຕົ້ນແລ້ວ.
ກຳລັງໂຫຼດ DB routines ຈາກ perl5db.pl ເວີຊັ່ນ 1.07
ຮອງຮັບບັນນາທິການໄດ້.
ປ້ອນ h ຫຼື 'hh' ສໍາລັບການຊ່ວຍເຫຼືອ, ຫຼື 'man perldebug' ສໍາລັບການຊ່ວຍເຫຼືອເພີ່ມເຕີມ.
main::./data:4): my $key = 'ຍິນດີຕ້ອນຮັບ';
ດຽວນີ້, ສິ່ງທີ່ພວກເຮົາໄດ້ເຮັດຢູ່ນີ້ແມ່ນການເປີດຕົວ perl debugger ທີ່ມີຕົວຕົນຢູ່ໃນສະຄິບຂອງພວກເຮົາ. ມັນ
ຢຸດຢູ່ແຖວທໍາອິດຂອງລະຫັດປະຕິບັດໄດ້ແລະລໍຖ້າການປ້ອນຂໍ້ມູນ.
ກ່ອນທີ່ພວກເຮົາຈະໄປຕື່ມອີກ, ທ່ານຢາກຮູ້ວິທີການອອກຈາກຕົວດີບັກ: ໃຊ້ພຽງແຕ່
ຈົດໝາຍ 'q', ບໍ່ແມ່ນຄຳວ່າ 'ເຊົາ' ຫຼື 'ອອກ':
DB<1> q
>
ນັ້ນແມ່ນມັນ, ທ່ານກັບຄືນໄປບ່ອນ turf ເຮືອນອີກເທື່ອຫນຶ່ງ.
ຊ່ວຍເຫຼືອ
ເປີດຕົວດີບັກຂຶ້ນອີກຄັ້ງໃນສະຄຣິບຂອງເຈົ້າ ແລະພວກເຮົາຈະເບິ່ງຢູ່ໃນເມນູຊ່ວຍເຫຼືອ. ມີ
ສອງສາມວິທີການໂທຫາການຊ່ວຍເຫຼືອ: ງ່າຍດາຍ 'h'ຈະໄດ້ຮັບບັນຊີລາຍການສະຫຼຸບການຊ່ວຍເຫຼືອ,'|h' (ທໍ່-ຊ)
ຈະທໍ່ການຊ່ວຍເຫຼືອຜ່ານ pager ຂອງທ່ານ (ເຊິ່ງອາດຈະເປັນ 'ຫຼາຍ' ຫຼື 'ຫນ້ອຍ'), ແລະສຸດທ້າຍ,
'h h' (h-space-h) ຈະໃຫ້ທ່ານມີຫນ້າຈໍຊ່ວຍເຫຼືອທັງຫມົດ. ນີ້ແມ່ນໜ້າສະຫຼຸບ:
D1h
ລາຍຊື່/ແຫຼ່ງຄົ້ນຫາ: ຄວບຄຸມການດຳເນີນການສະຄຣິບ:
l [ln|sub] ລາຍການລະຫັດແຫຼ່ງ T Stack trace
- ຫຼື . ບອກແຖວກ່ອນໜ້າ/ປັດຈຸບັນ s [expr] ຂັ້ນຕອນດຽວ [in expr]
v [line] ເບິ່ງຮອບແຖວ n [expr] ຕໍ່ໄປ, ຂັ້ນຕອນຫຼາຍກວ່າ subs
f ຊື່ໄຟລ໌ ເບິ່ງແຫຼ່ງໃນໄຟລ໌ ເຮັດຊ້ຳ n ຫຼື s
/pattern/ ?patt? ຄົ້ນຫາ forw/backw r ກັບຄືນຈາກລາຍການຍ່ອຍ
M ສະແດງໂມດູນຮຸ່ນ c [ln|sub] ສືບຕໍ່ຈົນກ່ວາຕໍາແຫນ່ງ
ການຄວບຄຸມ Debugger: L ລາຍການ break/watch/actions
o [... ] ກໍານົດຕົວເລືອກ debugger t [expr] ສະຫຼັບການຕິດຕາມ [trace expr]
<[<]|{[{]|>[>] [cmd] ເຮັດ pre/post-prompt b [ln|event|sub] [cnd] ຕັ້ງຈຸດຢຸດ
! [N|pat] ເຮັດຄືນຄໍາສັ່ງກ່ອນໜ້າ B ln|* ລຶບ a/all breakpoints
H [-num] ສະແດງຄໍາສັ່ງເລກສຸດທ້າຍ a [ln] cmd Do cmd ກ່ອນແຖວ
= [a val] ກຳນົດ/ລາຍຊື່ນາມແຝງ A ln|* ລົບ a/all actions
h [db_cmd] ຂໍຄວາມຊ່ວຍເຫຼືອກ່ຽວກັບຄໍາສັ່ງ w expr ເພີ່ມການສະແດງອອກຂອງໂມງ
hh ສໍາເລັດຫນ້າຊ່ວຍເຫຼືອ W expr|* ລຶບ a/all watch exprs
|[|]db_cmd ສົ່ງຜົນອອກໄປຫາ pager ![!] syscmd ແລ່ນ cmd ໃນຂະບວນການຍ່ອຍ
q ຫຼື ^D ອອກ R ພະຍາຍາມປິດເປີດໃໝ່
ການກວດສອບຂໍ້ມູນ: expr ປະຕິບັດລະຫັດ perl, ຍັງເບິ່ງ: s,n,t expr
x|m expr Evals expr ໃນບໍລິບົດລາຍການ, dumps ຜົນໄດ້ຮັບຫຼືລາຍການວິທີການ.
p expr ພິມສະແດງອອກ (ໃຊ້ຊຸດປະຈຸບັນຂອງ script).
S [[!]pat] ບອກຊື່ຍ່ອຍຍ່ອຍ [ບໍ່] ຮູບແບບທີ່ກົງກັນ
V [Pk [Vars]] ລາຍຊື່ຕົວແປໃນຊຸດ. Vars ສາມາດເປັນ ~ ຮູບແບບຫຼື !pattern.
X [Vars] ຄືກັນກັບ "V current_package [Vars]".
y [n [Vars]] ລາຍການ lexicals ໃນຂອບເຂດທີ່ສູງກວ່າ . Vars ຄືກັນກັບ V.
ສໍາລັບການຊ່ວຍເຫຼືອເພີ່ມເຕີມ, ພິມ h cmd_letter, ຫຼື run man perldebug ສໍາລັບເອກະສານທັງຫມົດ.
ທາງເລືອກທີ່ສັບສົນຫຼາຍກ່ວາທີ່ທ່ານສາມາດສັ່ນໄມ້ໃຫຍ່ຢູ່! ມັນບໍ່ແມ່ນບໍ່ດີເທົ່າທີ່ມັນເບິ່ງແລະ
ມັນເປັນປະໂຫຍດຫຼາຍທີ່ຈະຮູ້ເພີ່ມເຕີມກ່ຽວກັບມັນທັງຫມົດ, ແລະມ່ວນຄືກັນ!
ມີສອງສາມອັນທີ່ເປັນປະໂຫຍດທີ່ຈະຮູ້ກ່ຽວກັບທັນທີ. ເຈົ້າຈະບໍ່ຄິດວ່າພວກເຮົາແມ່ນ
ການນໍາໃຊ້ຫ້ອງສະຫມຸດໃດໆໃນທຸກເວລາ, ແຕ່ 'M' ຈະສະແດງໃຫ້ເຫັນວ່າໂມດູນໃດໃນປະຈຸບັນ
loaded, ແລະຈໍານວນສະບັບຂອງເຂົາເຈົ້າ, ໃນຂະນະທີ່ 'm'ຈະສະແດງໃຫ້ເຫັນວິທີການ, ແລະ 'S' ສະແດງໃຫ້ເຫັນທັງຫມົດ
subroutines (ໂດຍຮູບແບບ) ດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້. 'V'ແລະ'X'ສະແດງຕົວແປໃນໂຄງການໂດຍ
ຂອບເຂດຂອງຊຸດແລະສາມາດຖືກຈໍາກັດໂດຍຮູບແບບ.
DB<2>S str
dumpvar::stringify
ເຄັ່ງຄັດ::bits
ເຂັ້ມງວດ::ນໍາເຂົ້າ
ເຂັ້ມງວດ::unimport
ການນໍາໃຊ້ 'X' ແລະພີ່ນ້ອງຮຽກຮ້ອງໃຫ້ທ່ານບໍ່ໃຊ້ຕົວລະບຸປະເພດ ($@%), ພຽງແຕ່ 'ຊື່':
DM<3>X ~err
FileHandle(stderr) => fileno(2)
ຈົ່ງຈື່ໄວ້ວ່າພວກເຮົາຢູ່ໃນໂຄງການນ້ອຍໆຂອງພວກເຮົາທີ່ມີບັນຫາ, ພວກເຮົາຄວນຈະເບິ່ງວ່າພວກເຮົາຢູ່ໃສ,
ແລະຂໍ້ມູນຂອງພວກເຮົາມີລັກສະນະແນວໃດ. ກ່ອນອື່ນຫມົດໃຫ້ເບິ່ງລະຫັດບາງຢ່າງຢູ່ໃນຕໍາແຫນ່ງໃນປັດຈຸບັນຂອງພວກເຮົາ
(ເສັ້ນທໍາອິດຂອງລະຫັດໃນກໍລະນີນີ້), ຜ່ານ 'v':
DB<4> v
1 #!/usr/bin/perl
2: ໃຊ້ຢ່າງເຂັ້ມງວດ;
3
4==> $key ຂອງຂ້ອຍ = 'ຍິນດີຕ້ອນຮັບ';
5: %data ຂອງຂ້ອຍ = (
6 'ນີ້' => qw(ນັ້ນ),
7 'tom' => qw(ແລະ jerry),
8 'ຍິນດີຕ້ອນຮັບ' => q(ສະບາຍດີໂລກ),
9 'zip' => q(ຍິນດີຕ້ອນຮັບ),
10 );
ຢູ່ແຖວທີ 4 ແມ່ນຕົວຊີ້ທີ່ເປັນປະໂຫຍດ, ເຊິ່ງບອກທ່ານວ່າຕອນນີ້ເຈົ້າຢູ່ໃສ. ເພື່ອເບິ່ງເພີ່ມເຕີມ
ລະຫັດ, ພິມ 'v' ອີກເທື່ອຫນຶ່ງ:
DB<4> v
8 'ຍິນດີຕ້ອນຮັບ' => q(ສະບາຍດີໂລກ),
9 'zip' => q(ຍິນດີຕ້ອນຮັບ),
10 );
11: my @data = ລະຫັດ %data;
12: ພິມ "ຕົກລົງທັງໝົດ\n" ຖ້າ grep($key, keys %data);
13: ພິມ "$data{$key}\n";
14: ພິມ "ແລ້ວໆ: '$data{$key}'\n";
15: ອອກ;
ແລະຖ້າທ່ານຕ້ອງການລາຍຊື່ເສັ້ນ 5 ອີກເທື່ອຫນຶ່ງ, ພິມ 'l 5', (ຫມາຍເຫດຊ່ອງ):
DB<4> l 5
5: %data ຂອງຂ້ອຍ = (
ໃນກໍລະນີນີ້, ບໍ່ມີຫຼາຍທີ່ຈະເບິ່ງ, ແຕ່ແນ່ນອນວ່າໂດຍປົກກະຕິມີຫນ້າຂອງສິ່ງທີ່ຈະ
ຍ່າງຜ່ານ, ແລະ 'l' ສາມາດເປັນປະໂຫຍດຫຼາຍ. ເພື່ອຣີເຊັດມຸມມອງຂອງທ່ານເປັນແຖວທີ່ພວກເຮົາກຳລັງຈະໄປ
execute, type a lone period '.':
DB<5> .
main::./data_a:4): my $key = 'ຍິນດີຕ້ອນຮັບ';
ເສັ້ນທີ່ສະແດງແມ່ນເສັ້ນທີ່ກໍາລັງຈະຖືກປະຕິບັດ ຕໍ່ໄປ, ມັນຍັງບໍ່ໄດ້ເກີດຂຶ້ນເທື່ອ. ດັ່ງນັ້ນ
ໃນຂະນະທີ່ພວກເຮົາສາມາດພິມຕົວແປດ້ວຍຕົວອັກສອນ 'p', ໃນຈຸດນີ້ທັງຫມົດທີ່ພວກເຮົາຈະໄດ້ຮັບແມ່ນຫວ່າງເປົ່າ
(ບໍ່ໄດ້ກໍານົດ) ຄ່າກັບຄືນ. ສິ່ງທີ່ພວກເຮົາຕ້ອງເຮັດຄືການກ້າວຜ່ານການປະຕິບັດຕໍ່ໄປ
ຖະແຫຼງການທີ່ມີ 's':
DB<6> s
ຫຼັກ::./data_a:5): %data ຂອງຂ້ອຍ = (
ຫຼັກ::./data_a:6): 'ນີ້' => qw(ນັ້ນ),
ຫຼັກ::./data_a:7): 'tom' => qw(ແລະ jerry),
ຫຼັກ::./data_a:8): 'ຍິນດີຕ້ອນຮັບ' => q(ສະບາຍດີໂລກ),
ຫຼັກ::./data_a:9): 'zip' => q(ຍິນດີຕ້ອນຮັບ),
ຕົ້ນຕໍ::./data_a:10): );
ຕອນນີ້ພວກເຮົາສາມາດເບິ່ງຕົວແປທຳອິດ ($key) ໄດ້:
DB<7> p $key
ຍິນດີຕ້ອນຮັບ
ເສັ້ນ 13 ແມ່ນບ່ອນທີ່ການດໍາເນີນການ, ສະນັ້ນໃຫ້ພວກເຮົາສືບຕໍ່ລົງໄປທີ່ນັ້ນໂດຍຜ່ານຕົວອັກສອນ 'c', ທີ່
ໂດຍວິທີທາງການ, ແຊກຈຸດແບ່ງ 'ຄັ້ງດຽວ' ຢູ່ໃນແຖວທີ່ໃຫ້ ຫຼື ປົກກະຕິຍ່ອຍ:
DB<8> ຄ 13
ທັງຫມົດ OK
main::./data_a:13): ພິມ "$data{$key}\n";
ພວກເຮົາໄດ້ຜ່ານການກວດສອບຂອງພວກເຮົາ (ບ່ອນທີ່ 'OK ທັງຫມົດ' ໄດ້ຖືກພິມອອກ) ແລະໄດ້ຢຸດເຊົາການກ່ອນທີ່ຈະໄດ້
ຊີ້ນຂອງວຽກງານຂອງພວກເຮົາ. ພວກເຮົາສາມາດພະຍາຍາມພິມອອກສອງສາມຕົວແປເພື່ອເບິ່ງວ່າແມ່ນຫຍັງ
ເກີດຂຶ້ນ:
DB<9> p $data{$key}
ບໍ່ຫຼາຍປານໃດ, ຂໍໃຫ້ເບິ່ງ hash ຂອງພວກເຮົາ:
DB<10> p %data
ສະບາຍດີ Worldziptomandwelcomejerrywelcomethisthat
DB<11> p ປຸ່ມ %data
ສະບາຍດີ Worldtomwelcomejerrythis
ດີ, ນີ້ບໍ່ແມ່ນເລື່ອງງ່າຍທີ່ຈະອ່ານ, ແລະການນໍາໃຊ້ຄູ່ມືທີ່ເປັນປະໂຫຍດ (h h), ໄດ້ 'x' ຄໍາສັ່ງ
ເບິ່ງຄືວ່າມີຄໍາຫມັ້ນສັນຍາ:
DB<12> x %data
0 'ສະບາຍດີໂລກ'
1 ຊິບ
2 'ທອມ'
3 'ແລະ'
4 ຍິນດີຕ້ອນຮັບ
5 undef
6 ແຈຣີ
7 ຍິນດີຕ້ອນຮັບ
8 ນີ້
9 'ນັ້ນ'
ນັ້ນບໍ່ໄດ້ຊ່ວຍຫຍັງຫຼາຍ, ມີການຕ້ອນຮັບສອງສາມຄົນຢູ່ໃນນັ້ນ, ແຕ່ບໍ່ມີການຊີ້ບອກວ່າອັນໃດເປັນກະແຈ,
ແລະທີ່ເປັນຄ່າ, ມັນເປັນພຽງແຕ່ dump array ທີ່ລະບຸໄວ້ແລະ, ໃນກໍລະນີນີ້, ບໍ່ແມ່ນໂດຍສະເພາະ
ເປັນປະໂຫຍດ. trick ທີ່ນີ້, ແມ່ນການນໍາໃຊ້ a ອ້າງອິງ ໂຄງສ້າງຂໍ້ມູນ:
DB<13> x \%data
0 Hash(0x8194bc4)
'ສະບາຍດີໂລກ' => 'zip'
'jerry' => 'ຍິນດີຕ້ອນຮັບ'
'ນີ້' => 'ນັ້ນ'
'ທອມ' => 'ແລະ'
'ຍິນດີຕ້ອນຮັບ' => undef
ການອ້າງອິງຖືກຖິ້ມຂີ້ເຫຍື້ອຢ່າງແທ້ຈິງແລະໃນທີ່ສຸດພວກເຮົາສາມາດເຫັນສິ່ງທີ່ພວກເຮົາກໍາລັງຈັດການກັບ. ການອ້າງອີງຂອງພວກເຮົາ
ຖືກຕ້ອງຢ່າງສົມບູນແຕ່ຜິດສໍາລັບຈຸດປະສົງຂອງພວກເຮົາ, ກັບ 'ແລະ jerry' ຖືກຖືເປັນ 2
ແຍກຄໍາສັບຕ່າງໆແທນທີ່ຈະເປັນປະໂຫຍກ, ດັ່ງນັ້ນຈຶ່ງຖິ້ມໂຄງສ້າງ hash ທີ່ເປັນຄູ່ເທົ່າທຽມກັນອອກຈາກ
ການຈັດວາງ.
ໄດ້ '-w' switch ຈະບອກພວກເຮົາກ່ຽວກັບເລື່ອງນີ້, ພວກເຮົາໃຊ້ມັນໃນຕອນເລີ່ມຕົ້ນ, ແລະຊ່ວຍປະຢັດພວກເຮົາ a
ບັນຫາຫຼາຍ:
> ຂໍ້ມູນ perl -w
ຈຳນວນຄີກຂອງອົງປະກອບໃນການມອບໝາຍ hash ຢູ່ ./data line 5.
ພວກເຮົາແກ້ໄຂຄໍາອ້າງອີງຂອງພວກເຮົາ: 'tom' => q (ແລະ jerry), ແລະດໍາເນີນການອີກເທື່ອຫນຶ່ງ, ໃນເວລານີ້ພວກເຮົາໄດ້ຮັບຄວາມຄາດຫວັງຂອງພວກເຮົາ.
ຜົນຜະລິດ:
> ຂໍ້ມູນ perl -w
ສະບາຍດີໂລກ
ໃນຂະນະທີ່ພວກເຮົາຢູ່ທີ່ນີ້, ຈົ່ງເບິ່ງທີ່ໃກ້ຊິດກັບ 'x'ຄໍາສັ່ງ, ມັນເປັນປະໂຫຍດແທ້ໆແລະຈະ
merrily dump ອອກການອ້າງອິງ nested, ວັດຖຸສໍາເລັດ, ວັດຖຸບາງສ່ວນ - ພຽງແຕ່ກ່ຽວກັບ
ສິ່ງໃດກໍ່ຕາມທີ່ເຈົ້າຖິ້ມມັນ:
ໃຫ້ພວກເຮົາສ້າງວັດຖຸໄວແລະ x-plode ມັນ, ທໍາອິດພວກເຮົາຈະເລີ່ມຕົ້ນການດີບັກ: ມັນຕ້ອງການບາງ
ຮູບແບບການປ້ອນຂໍ້ມູນຈາກ STDIN, ດັ່ງນັ້ນພວກເຮົາຈຶ່ງໃຫ້ມັນເປັນສິ່ງທີ່ບໍ່ເປັນສັນຍາ, ສູນ:
> perl -de 0
ຟື້ນຟູຕົວຈັບການຕາຍເລີ່ມຕົ້ນແລ້ວ.
ກຳລັງໂຫຼດ DB routines ຈາກ perl5db.pl ເວີຊັ່ນ 1.07
ຮອງຮັບບັນນາທິການໄດ້.
ປ້ອນ h ຫຼື 'hh' ສໍາລັບການຊ່ວຍເຫຼືອ, ຫຼື 'man perldebug' ສໍາລັບການຊ່ວຍເຫຼືອເພີ່ມເຕີມ.
ຫຼັກ::(-e:1): 0
ຕອນນີ້ສ້າງວັດຖຸທີ່ບິນຢູ່ເທິງສອງແຖວ (ສັງເກດ backslash):
DB<1> $obj = ພອນ({'unique_id'=>'123', 'attr'=> \
cont: {'col' => 'black', 'ສິ່ງຂອງ' => [qw(ອັນນີ້ເປັນຕົ້ນ)]}}, 'MY_class')
ແລະໃຫ້ເຮົາມາເບິ່ງກັນເລີຍ:
DB<2> x $obj
0 MY_class=Hash(0x828ad98)
'attr' => Hash(0x828ad68)
'col' => 'ສີດຳ'
'ສິ່ງຂອງ' => ວັນເສົາ(0x828abb8)
0 ນີ້
1 'ນັ້ນ'
2 'etc'
'unique_id' => 123
DB<3>
ມີປະໂຫຍດ, huh? ທ່ານສາມາດປະເມີນຜົນເກືອບທັງຫມົດໃນນັ້ນ, ແລະທົດລອງທີ່ມີ bits ຂອງລະຫັດຫຼື
regexes ຈົນກ່ວາງົວມາເຮືອນ:
DB<3> @data = qw(ນີ້ແມ່ນວ່າທິດສະດີຫນັງ atheism ອື່ນໆ scythe)
DB<4> p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
atheism
ຫນັງ
ອື່ນໆ
ມີດ
ໄດ້
ທິດສະດີ
saw -> 6
ຖ້າທ່ານຕ້ອງການເບິ່ງຄໍາສັ່ງ History, ພິມ 'H':
DB<5> H
4: p ' saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
3: @data = qw(ອັນນີ້ວ່າທິດສະດີໜັງທີ່ບໍ່ເຊື່ອໃນສາສະໜາອື່ນ scythe)
2: x $obj
1: $obj = ພອນ({'unique_id'=>'123', 'attr'=>
{'col' => 'ສີດຳ', 'ສິ່ງຂອງ' => [qw(ອັນນີ້ເປັນຕົ້ນ)]}}, 'MY_class')
DB<5>
ແລະຖ້າທ່ານຕ້ອງການເຮັດຊ້ໍາຄໍາສັ່ງໃດໆທີ່ຜ່ານມາ, ໃຫ້ໃຊ້ exclamation: '!':
DB<5> !4
p ' saw -> '.($cnt += ແຜນທີ່ {ພິມ "$_\n" } grep(/the/, sort @data))
atheism
ຫນັງ
ອື່ນໆ
ມີດ
ໄດ້
ທິດສະດີ
saw -> 12
ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການອ້າງອີງເບິ່ງ perlref ແລະ perlreftut
Stepping ໂດຍຜ່ານການ ລະຫັດ
ນີ້ແມ່ນໂຄງການທີ່ງ່າຍດາຍທີ່ຈະແປງລະຫວ່າງ Celsius ແລະ Fahrenheit, ມັນມີ a
ບັນຫາ:
#!/usr/bin/perl -w
ໃຊ້ຢ່າງເຄັ່ງຄັດ;
$arg ຂອງຂ້ອຍ = $ARGV[0] || '-c20';
ຖ້າ ($arg =~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
ຂອງຂ້ອຍ ($deg, $num) = ($1, $2);
ຂອງຂ້ອຍ ($in, $out) = ($num, $num);
ຖ້າ ($deg eq 'c') {
$deg = 'f';
$out = &c2f($num);
} else {
$deg = 'ຄ';
$out = &f2c($num);
}
$out = sprintf('%0.2f', $out);
$out =~ s/^((\-|\+)*\d+)\.0+$/$1/;
ພິມ "$out $deg\n";
} else {
ພິມ "ການນໍາໃຊ້: $0 -[c|f] num\n";
}
ອອກ;
ຍ່ອຍ f2c {
ຂອງຂ້ອຍ $f = shift;
$c ຂອງຂ້ອຍ = 5 * $f - 32 / 9;
ກັບຄືນ $c;
}
ຍ່ອຍ c2f {
$c ຂອງຂ້ອຍ = shift;
ຂອງຂ້ອຍ $f = 9 * $c / 5 + 32;
ກັບຄືນ $f;
}
ສໍາລັບເຫດຜົນບາງຢ່າງ, ການແປງ Fahrenheit ເປັນ Celsius ບໍ່ສາມາດກັບຄືນຜົນຜະລິດທີ່ຄາດໄວ້.
ນີ້ແມ່ນສິ່ງທີ່ມັນເຮັດ:
> temp -c0.72
33.30 f
> temp -f33.3
162.94 c
ບໍ່ສອດຄ່ອງຫຼາຍ! ພວກເຮົາຈະກໍານົດ breakpoint ໃນລະຫັດດ້ວຍຕົນເອງແລະດໍາເນີນການມັນພາຍໃຕ້ການ
debugger ເພື່ອເບິ່ງວ່າມີຫຍັງເກີດຂຶ້ນ. ຈຸດຢຸດແມ່ນທຸງ, ເຊິ່ງຕົວດີບັກຈະແລ່ນ
ໂດຍບໍ່ມີການຂັດຂວາງ, ເມື່ອມັນມາຮອດຈຸດຢຸດ, ມັນຈະຢຸດການປະຕິບັດແລະສະເຫນີ a
ກະຕຸ້ນໃຫ້ມີການໂຕ້ຕອບຕື່ມອີກ. ໃນການນໍາໃຊ້ປົກກະຕິ, ຄໍາສັ່ງ debugger ເຫຼົ່ານີ້ແມ່ນສົມບູນ
ບໍ່ສົນໃຈ, ແລະພວກເຂົາມີຄວາມປອດໄພ - ຖ້າ messy ເລັກນ້ອຍ, ໃຫ້ອອກຈາກລະຫັດການຜະລິດ.
ຂອງຂ້ອຍ ($in, $out) = ($num, $num);
$DB::single=2; #ໃສ່ແຖວ9!
ຖ້າ ($deg eq 'c')
...
> perl -d temp -f33.3
ຟື້ນຟູຕົວຈັບການຕາຍເລີ່ມຕົ້ນແລ້ວ.
ກຳລັງໂຫຼດ DB routines ຈາກ perl5db.pl ເວີຊັ່ນ 1.07
ຮອງຮັບບັນນາທິການໄດ້.
ປ້ອນ h ຫຼື 'hh' ສໍາລັບການຊ່ວຍເຫຼືອ, ຫຼື 'man perldebug' ສໍາລັບການຊ່ວຍເຫຼືອເພີ່ມເຕີມ.
ຕົ້ນຕໍ::(temp:4): $arg = $ARGV[0] || '-c100';
ພວກເຮົາພຽງແຕ່ສືບຕໍ່ລົງໄປຫາຈຸດຢຸດທີ່ກໍານົດໄວ້ກ່ອນຂອງພວກເຮົາດ້ວຍ 'c':
DB<1> ຄ
main::(temp:10): if ($deg eq 'c') {
ປະຕິບັດຕາມຄໍາສັ່ງ view ເພື່ອເບິ່ງວ່າພວກເຮົາຢູ່ໃສ:
DB<1> v
7: ຂອງຂ້ອຍ ($deg, $num) = ($1, $2);
8: my ($in, $out) = ($num, $num);
9: $DB::single=2;
10==> ຖ້າ ($deg eq 'c') {
11: $deg = 'f' ;
12: $out = &c2f($num);
13 } ອື່ນ {
14: $deg = 'ຄ';
15: $out = &f2c($num);
16 }
ແລະການພິມເພື່ອສະແດງຄ່າທີ່ພວກເຮົາກໍາລັງໃຊ້ໃນປັດຈຸບັນ:
DB<1> p $deg, $num
f33.3
ພວກເຮົາສາມາດວາງຈຸດແຕກແຍກອື່ນໃສ່ເສັ້ນໃດກໍໄດ້ທີ່ເລີ່ມຕົ້ນດ້ວຍຈໍ້າສອງເມັດ, ພວກເຮົາຈະໃຊ້ເສັ້ນ 17 ເປັນ
ນັ້ນຄືດັ່ງທີ່ພວກເຮົາອອກມາຈາກກິດຈະວັດຍ່ອຍ, ແລະພວກເຮົາຕ້ອງການຢຸດຊົ່ວຄາວຢູ່ທີ່ນັ້ນໃນພາຍຫຼັງ:
DB<2> b 17
ບໍ່ມີຄໍາຕິຊົມຈາກອັນນີ້, ແຕ່ເຈົ້າສາມາດເຫັນໄດ້ວ່າຈຸດແບ່ງຈຸດໃດຖືກຕັ້ງໂດຍການໃຊ້ລາຍຊື່
ຄໍາສັ່ງ 'L':
DB<3> L
ອຸນຫະພູມ:
17: ພິມ "$out $deg\n";
ແຕກຖ້າ (1)
ຈົ່ງຈື່ໄວ້ວ່າເພື່ອລຶບຈຸດຢຸດທີ່ທ່ານໃຊ້ 'B'.
ຕອນນີ້ພວກເຮົາຈະສືບຕໍ່ລົງໃນຕາຕະລາງຍ່ອຍຂອງພວກເຮົາ, ໃນເວລານີ້ແທນທີ່ຈະເປັນຕົວເລກ, ພວກເຮົາຈະ
ໃຊ້ຊື່ຍ່ອຍ, ຕາມດ້ວຍ 'v' ທີ່ຄຸ້ນເຄີຍໃນປັດຈຸບັນ:
DB<3> c f2c
main::f2c(temp:30): my $f = shift;
DB<4> v
24: ອອກ;
25
26 ຍ່ອຍ f2c {
27==> ຂອງຂ້ອຍ $f = shift;
28: $c ຂອງຂ້ອຍ = 5 * $f - 32 / 9;
29: ກັບຄືນ $c;
30 }
31
32 ຍ່ອຍ c2f {
33: my $c = shift;
ໃຫ້ສັງເກດວ່າຖ້າຫາກວ່າມີການໂທຫາ subroutine ລະຫວ່າງພວກເຮົາແລະສາຍ 29, ແລະພວກເຮົາຕ້ອງການ ດຽວ-
ຂັ້ນຕອນ ໂດຍຜ່ານມັນ, ພວກເຮົາສາມາດນໍາໃຊ້ 's'ຄໍາສັ່ງ, ແລະກ້າວຂ້າມມັນພວກເຮົາຈະໃຊ້'n'ທີ່
ຈະດໍາເນີນການຍ່ອຍ, ແຕ່ບໍ່ໄດ້ລົງເຂົ້າໄປໃນມັນສໍາລັບການກວດກາ. ໃນກໍລະນີດັ່ງກ່າວນີ້, ພວກເຮົາ
ພຽງແຕ່ສືບຕໍ່ລົງໄປຫາເສັ້ນ 29:
DB<4> ຄ 29
main::f2c(temp:29): return $c;
ແລະເບິ່ງມູນຄ່າກັບຄືນ:
DB<5> p $c
162.944444444444
ນີ້ບໍ່ແມ່ນຄໍາຕອບທີ່ຖືກຕ້ອງທັງຫມົດ, ແຕ່ຜົນລວມເບິ່ງຄືວ່າຖືກຕ້ອງ. ຂ້ອຍສົງໄສວ່າມັນແມ່ນຫຍັງ
ຈະເຮັດກັບຕົວປະຕິບັດການກ່ອນ? ພວກເຮົາຈະພະຍາຍາມສອງສາມຄວາມເປັນໄປໄດ້ອື່ນໆທີ່ມີຜົນລວມຂອງພວກເຮົາ:
DB<6> p (5 * $f - 32 / 9)
162.944444444444
DB<7> p 5 * $f - (32/9)
162.944444444444
DB<8> p (5*$f) - 32/9
162.944444444444
DB<9> p 5 * ($f - 32) / 9
0.722222222222221
:-) ນັ້ນຄືມັນຫຼາຍ! ຕົກລົງ, ຕອນນີ້ພວກເຮົາສາມາດກໍານົດຕົວແປການກັບຄືນຂອງພວກເຮົາແລະພວກເຮົາຈະກັບຄືນມາ
ຍ່ອຍດ້ວຍ 'r':
DB<10> $c = 5 * ($f - 32) / 9
DB<11> r
ຜົນຕອບແທນຂອງບໍລິບົດ scalar ຈາກຫຼັກ::f2c: 0.722222222222221
ເບິ່ງຄືວ່າດີ, ຂໍໃຫ້ສືບຕໍ່ໄປໃນຕອນທ້າຍຂອງ script:
DB<12> ຄ
0.72 c
ໂປຣແກຣມດີບັ໊ກຖືກປິດແລ້ວ. ໃຊ້ q ເພື່ອອອກ ຫຼື R ເພື່ອປິດເປີດໃໝ່,
ໃຊ້ O inhibit_exit ເພື່ອຫຼີກເວັ້ນການຢຸດຫຼັງຈາກປິດໂຄງການ,
hq, h R ຫຼື h O ເພື່ອຮັບຂໍ້ມູນເພີ່ມເຕີມ.
ການແກ້ໄຂຢ່າງວ່ອງໄວກັບເສັ້ນທີ່ກະທໍາຜິດ (ໃສ່ວົງເລັບທີ່ຂາດໄປ) ໃນໂຄງການຕົວຈິງ
ແລະພວກເຮົາສໍາເລັດ.
placeholder ສໍາລັບການ a, w, t, T
ການປະຕິບັດ, ເບິ່ງຕົວແປ, stack traces ແລະອື່ນໆ: ໃນບັນຊີລາຍຊື່ TODO.
a
w
t
T
REGULAR ການສະແດງອອກ
ເຄີຍຢາກຮູ້ວ່າ regex ມີລັກສະນະແນວໃດ? ທ່ານຈະຕ້ອງການ perl ລວບລວມກັບ
DEBUGGING ທຸງສຳລັບອັນນີ້:
> perl -Dr -e '/^pe(a)*rl$/i'
ການລວບລວມ REx `^pe(a)*rl$'
ຂະໜາດ 17 ອັນທຳອິດຢູ່ທີ່ 2
char ທີ່ຫາຍາກທີ່ສຸດ
ທີ່ 0
1: BOL(2)
2: EXACTF (4)
4: CURLYN[1] {0,32767}(14)
6: ສິ່ງທີ່ຄວນຮູ້(8)
8: EXACTF (0)
12: ໃນຂະນະທີ່(0)
13: ສິ່ງທີ່ຄວນຮູ້(14)
14: EXACTF (16)
16: EOL(17)
17: END(0)
floating `'$ ຢູ່ 4..2147483647 (ກຳລັງກວດສອບການລອຍຕົວ) stclass `EXACTF '
ສະມໍ (BOL) minlen 4
ຍົກເລີກການສະຫນັບສະຫນູນ $` $& $ '.
ກຳລັງປະຕິບັດ...
ປົດປ່ອຍ REx: `^pe(a)*rl$'
ເຈົ້າຢາກຮູ້ແທ້ໆບໍ? :-) ສໍາລັບລາຍລະອຽດ gory ເພີ່ມເຕີມກ່ຽວກັບການສະແດງອອກເປັນປົກກະຕິກັບ
ເຮັດວຽກ, ເບິ່ງ perlre, perlretut, ແລະການຖອດລະຫັດປ້າຍທີ່ລຶກລັບ (BOL ແລະ
CURLYN, ແລະອື່ນໆຂ້າງເທິງ), ເບິ່ງ perldebguts.
OUTPUT ເຄັດລັບການ
ເພື່ອໃຫ້ໄດ້ຮັບຜົນຜະລິດທັງຫມົດຈາກບັນທຶກຄວາມຜິດພາດຂອງທ່ານ, ແລະບໍ່ພາດຂໍ້ຄວາມໃດໆໂດຍຜ່ານການດໍາເນີນງານທີ່ເປັນປະໂຫຍດ
ລະບົບ buffering, ໃສ່ເສັ້ນເຊັ່ນນີ້, ໃນຕອນເລີ່ມຕົ້ນຂອງ script ຂອງທ່ານ:
$|=1;
ເພື່ອເບິ່ງຫາງຂອງ logfile ທີ່ມີການຂະຫຍາຍຕົວແບບເຄື່ອນໄຫວ, (ຈາກເສັ້ນຄໍາສັ່ງ):
tail -f $error_log
ການຫໍ່ສາຍໂທຕາຍທັງໝົດຢູ່ໃນແບບປົກກະຕິຂອງຕົວຈັດການສາມາດເປັນປະໂຫຍດທີ່ຈະເບິ່ງວິທີການ, ແລະຈາກບ່ອນໃດ,
ພວກເຂົາເຈົ້າກໍາລັງຖືກເອີ້ນ, perlvar ມີຂໍ້ມູນເພີ່ມເຕີມ:
BEGIN { $SIG{__DIE__} = ຍ່ອຍ { ຕ້ອງການ Carp; Carp::confess(@_) } }
ເຕັກນິກທີ່ເປັນປະໂຫຍດຕ່າງໆສໍາລັບການປ່ຽນເສັ້ນທາງຂອງ STDOUT ແລະ STDERR filehandles ແມ່ນ
ອະທິບາຍໃນ perlopentut ແລະ perlfaq8.
CGI
ພຽງແຕ່ເປັນຄໍາແນະນໍາຢ່າງວ່ອງໄວທີ່ນີ້ສໍາລັບການທັງຫມົດທີ່ໂຄງການ CGI ຜູ້ທີ່ບໍ່ສາມາດຄິດອອກວິທີການຢູ່ໃນໂລກ
ໃຫ້ຜ່ານໄປວ່າ 'ລໍຖ້າການປ້ອນຂໍ້ມູນ' ເຕືອນ, ເມື່ອແລ່ນສະຄິບ CGI ຂອງພວກເຂົາຈາກຄໍາສັ່ງ -
ເສັ້ນ, ພະຍາຍາມບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:
> perl -d my_cgi.pl -nodebug
ແນ່ນອນ CGI ແລະ perlfaq9 ຈະບອກທ່ານເພີ່ມເຕີມ.
GUIs
ການໂຕ້ຕອບເສັ້ນຄໍາສັ່ງແມ່ນປະສົມປະສານຢ່າງແຫນ້ນຫນາກັບ an emacs ການຂະຫຍາຍແລະມີ vi
ການໂຕ້ຕອບເຊັ່ນດຽວກັນ.
ທ່ານບໍ່ຈໍາເປັນຕ້ອງເຮັດທັງຫມົດນີ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ, ເຖິງແມ່ນວ່າ, ມີທາງເລືອກ GUI ຈໍານວນຫນ້ອຍອອກ
ຢູ່ທີ່ນັ້ນ. ສິ່ງທີ່ດີກ່ຽວກັບການເຫຼົ່ານີ້ແມ່ນທ່ານສາມາດໂບກຫນູຜ່ານຕົວແປແລະ dump ຂອງ
ຂໍ້ມູນຂອງມັນຈະປາກົດຢູ່ໃນປ່ອງຢ້ຽມທີ່ເຫມາະສົມ, ຫຼືໃນປູມເປົ້າປະກອບ, ບໍ່ມີຄວາມເມື່ອຍຫຼາຍ
ການພິມ 'x $varname' :-)
ໂດຍສະເພາະມີການລ່າສັດປະມານດັ່ງຕໍ່ໄປນີ້:
ptkdb wrapper ອີງໃສ່ perlTK ສໍາລັບຕົວດີບັກໃນຕົວ
ddd ຂໍ້ມູນການສະແດງຜົນດີບັກ
PerlDevKit ແລະ PerlBuilder ແມ່ນ NT ສະເພາະ
NB. (ຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບສິ່ງເຫຼົ່ານີ້ ແລະອັນອື່ນໆຈະໄດ້ຮັບການຍົກຍ້ອງ).
ບົດສະຫຼຸບ
ພວກເຮົາໄດ້ເຫັນວິທີການຊຸກຍູ້ການປະຕິບັດການຂຽນລະຫັດທີ່ດີກັບ ການນໍາໃຊ້ ຢ່າງເຄັ່ງຄັດ ແລະ -w. ພວກເຮົາສາມາດດໍາເນີນການໄດ້
perl debugger perl -d ຊື່ສະຄຣິບ ເພື່ອກວດກາຂໍ້ມູນຂອງທ່ານຈາກພາຍໃນ perl debugger ກັບ
ໄດ້ p ແລະ x ຄໍາສັ່ງ. ທ່ານສາມາດຍ່າງຜ່ານລະຫັດຂອງທ່ານ, ກໍານົດຈຸດຢຸດດ້ວຍ b ແລະຂັ້ນຕອນ
ໂດຍຜ່ານລະຫັດທີ່ມີ s or n, ສືບຕໍ່ກັບ c ແລະກັບຄືນຈາກການຍ່ອຍທີ່ມີ r. ຍຸຕິທຳ
ສິ່ງທີ່ intuitive ໃນເວລາທີ່ທ່ານລົງໄປຫາມັນ.
ແນ່ນອນ, ມີຫຼາຍສິ່ງຫຼາຍຢ່າງເພື່ອຊອກຮູ້ກ່ຽວກັບ, ມັນໄດ້ຂູດພື້ນຜິວ. ໄດ້
ວິທີທີ່ດີທີ່ສຸດທີ່ຈະຮຽນຮູ້ເພີ່ມເຕີມແມ່ນການໃຊ້ perldoc ເພື່ອຊອກຫາເພີ່ມເຕີມກ່ຽວກັບພາສາ, ອ່ານ
ການຊ່ວຍເຫຼືອອອນໄລນ໌ (perldebug ອາດຈະເປັນບ່ອນຕໍ່ໄປທີ່ຈະໄປ), ແລະແນ່ນອນ, ການທົດລອງ.
ໃຊ້ perldebtut ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
