perldebtut - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

perldebtut - പേൾ ഡീബഗ്ഗിംഗ് ട്യൂട്ടോറിയൽ

വിവരണം

പേൾ ഡീബഗ്ഗറിന്റെ ഉപയോഗത്തിൽ ഒരു (വളരെ) ഭാരം കുറഞ്ഞ ആമുഖവും അതിനുള്ള ഒരു പോയിന്ററും
perl പ്രോഗ്രാമുകൾ ഡീബഗ്ഗിംഗ് ചെയ്യുന്ന വിഷയത്തിൽ നിലവിലുള്ള, ആഴത്തിലുള്ള വിവരങ്ങളുടെ ഉറവിടങ്ങൾ.

ഒന്നും അറിയാത്തവരായി തോന്നുന്ന അസാധാരണമായ ഒരു കൂട്ടം ആളുകൾ അവിടെയുണ്ട്
അവർ എല്ലാ ദിവസവും ഭാഷ ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, perl ഡീബഗ്ഗർ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച്. ഇത് അവർക്കുള്ളതാണ്.

ഉപയോഗം കണിശമായ

ഒന്നാമതായി, നിങ്ങളുടെ ജീവിതം കൂടുതൽ ലളിതമാക്കാൻ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന ചില കാര്യങ്ങളുണ്ട്
ഡീബഗ്ഗർ ഉപയോഗിക്കാതെ, perl പ്രോഗ്രാമുകൾ ഡീബഗ്ഗുചെയ്യുമ്പോൾ. ലേക്ക്
ഒരു പ്രശ്നമുള്ള "ഹലോ" എന്ന് പേരിട്ടിരിക്കുന്ന ഒരു ലളിതമായ സ്ക്രിപ്റ്റ് ഇവിടെയുണ്ട്:

#!/usr/bin/perl

$var1 = 'ഹലോ വേൾഡ്'; # എപ്പോഴും അത് ചെയ്യാൻ ആഗ്രഹിക്കുന്നു :-)
$var2 = "$varl\n";

$var2 പ്രിന്റ് ചെയ്യുക;
പുറത്ത്;

ഇത് കംപൈൽ ചെയ്യുകയും സന്തോഷത്തോടെ പ്രവർത്തിക്കുകയും ചെയ്യുമ്പോൾ, ഒരുപക്ഷേ അത് പ്രതീക്ഷിച്ചത് ചെയ്യില്ല, അതായത്
"ഹലോ വേൾഡ്\n" പ്രിന്റ് ചെയ്യുന്നില്ല; മറുവശത്ത് അത് കൃത്യമായി ചെയ്യും
ചെയ്യാൻ പറഞ്ഞു, കംപ്യൂട്ടറുകൾ അൽപ്പം ആ വഴിക്ക് ചായ്വുള്ളതാണ്. അതായത്, അത് ഒരു പുതിയ ലൈൻ പ്രിന്റ് ചെയ്യും
പ്രതീകം, കൂടാതെ ഒരു ശൂന്യമായ വര പോലെ തോന്നുന്നത് നിങ്ങൾക്ക് ലഭിക്കും. 2 വേരിയബിളുകൾ ഉള്ളതായി തോന്നുന്നു
എപ്പോൾ (അക്ഷരത്തെറ്റ് കാരണം) ശരിക്കും 3 ഉണ്ട്:

$var1 = 'ഹലോ വേൾഡ്';
$varl = undef;
$var2 = "\n";

ഇത്തരത്തിലുള്ള പ്രശ്‌നം കണ്ടെത്തുന്നതിന്, ഓരോ വേരിയബിളും ഉപയോഗിക്കുന്നതിന് മുമ്പ് പ്രഖ്യാപിക്കാൻ നമുക്ക് നിർബന്ധിക്കാം
കർശനമായ മൊഡ്യൂളിലേക്ക് വലിക്കുക, 'കണിശമായത് ഉപയോഗിക്കുക;' തിരക്കഥയുടെ ആദ്യ വരിക്ക് ശേഷം.

ഇപ്പോൾ നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കുമ്പോൾ, 3 പ്രഖ്യാപിക്കാത്ത വേരിയബിളുകളെക്കുറിച്ച് perl പരാതിപ്പെടുന്നു, ഞങ്ങൾക്ക് നാല് പിശകുകൾ ലഭിക്കും
സന്ദേശങ്ങൾ കാരണം ഒരു വേരിയബിൾ രണ്ടുതവണ പരാമർശിച്ചിരിക്കുന്നു:

"$var1" എന്ന ആഗോള ചിഹ്നത്തിന് ./t1 ലൈൻ 4-ൽ വ്യക്തമായ പാക്കേജ് പേര് ആവശ്യമാണ്.
"$var2" എന്ന ആഗോള ചിഹ്നത്തിന് ./t1 ലൈൻ 5-ൽ വ്യക്തമായ പാക്കേജ് പേര് ആവശ്യമാണ്.
"$varl" എന്ന ആഗോള ചിഹ്നത്തിന് ./t1 വരി 5-ൽ വ്യക്തമായ പാക്കേജ് പേര് ആവശ്യമാണ്.
"$var2" എന്ന ആഗോള ചിഹ്നത്തിന് ./t1 ലൈൻ 7-ൽ വ്യക്തമായ പാക്കേജ് പേര് ആവശ്യമാണ്.
സമാഹാരത്തിലെ പിശകുകൾ കാരണം ./ഹലോയുടെ നിർവ്വഹണം നിർത്തലാക്കി.

ലവ്വർലി! ഇത് പരിഹരിക്കാൻ ഞങ്ങൾ എല്ലാ വേരിയബിളുകളും വ്യക്തമായി പ്രഖ്യാപിക്കുന്നു, ഇപ്പോൾ നമ്മുടെ സ്ക്രിപ്റ്റ് കാണപ്പെടുന്നു
ഇതുപോലെ:

#!/usr/bin/perl
കർശനമായി ഉപയോഗിക്കുക;

എന്റെ $var1 = 'ഹലോ വേൾഡ്';
എന്റെ $varl = undef;
എന്റെ $var2 = "$varl\n";

$var2 പ്രിന്റ് ചെയ്യുക;
പുറത്ത്;

അത് വീണ്ടും പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുന്നതിന് മുമ്പ് ഞങ്ങൾ ഒരു വാക്യഘടന പരിശോധന നടത്തുന്നു (എല്ലായ്‌പ്പോഴും ഒരു നല്ല ആശയം):

> perl -c ഹലോ
ഹലോ വാക്യഘടന ശരി

ഇപ്പോൾ നമ്മൾ ഇത് പ്രവർത്തിപ്പിക്കുമ്പോൾ, നമുക്ക് "\n" ഇപ്പോഴും ലഭിക്കും, പക്ഷേ കുറഞ്ഞത് എന്തുകൊണ്ടാണെന്ന് നമുക്കറിയാം. ഇത് കിട്ടുന്നേയുള്ളൂ
കംപൈൽ ചെയ്യാനുള്ള സ്‌ക്രിപ്റ്റ് '$varl' ('l' എന്ന അക്ഷരത്തോടുകൂടിയ) വേരിയബിൾ തുറന്നുകാട്ടി, ലളിതമായി
$varl എന്നതിനെ $var1 ആക്കി മാറ്റുന്നത് പ്രശ്നം പരിഹരിക്കുന്നു.

നോക്കുന്നു at ഡാറ്റ ഒപ്പം -w ഒപ്പം v

ശരി, എന്നാൽ നിങ്ങളുടെ ഡാറ്റ ശരിക്കും കാണണമെങ്കിൽ, ആ ഡൈനാമിക് വേരിയബിളിൽ എന്താണ് ഉള്ളത്,
ഉപയോഗിക്കുന്നതിന് തൊട്ടുമുമ്പ്?

#!/usr/bin/perl
കർശനമായി ഉപയോഗിക്കുക;

എന്റെ $കീ = 'സ്വാഗതം';
എന്റെ %ഡാറ്റ = (
'ഇത്' => qw(അത്),
'ടോം' => qw(ആൻഡ് ജെറി),
'സ്വാഗതം' => q(ഹലോ വേൾഡ്),
'zip' => q(സ്വാഗതം),
);
എന്റെ @ഡാറ്റ = കീകൾ %ഡാറ്റ;

"$data{$key}\n" പ്രിന്റ് ചെയ്യുക;
പുറത്ത്;

ശരിയാണെന്ന് തോന്നുന്നു, വാക്യഘടന പരിശോധനയിലൂടെ (perl -c സ്ക്രിപ്റ്റ് നെയിം) ഞങ്ങൾ അത് പ്രവർത്തിപ്പിക്കുന്നു
ഞങ്ങൾക്ക് വീണ്ടും ഒരു ശൂന്യമായ വരിയാണ് ലഭിക്കുന്നത്! ഹും.

ഇവിടെയുള്ള ഒരു സാധാരണ ഡീബഗ്ഗിംഗ് സമീപനം, കുറച്ച് പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റുകൾ ഉദാരമായി വിതറുക എന്നതാണ്,
ഞങ്ങളുടെ ഡാറ്റ പ്രിന്റ് ഔട്ട് ചെയ്യുന്നതിന് തൊട്ടുമുമ്പ് ഒരു ചെക്ക് ചേർക്കാൻ, മറ്റൊന്ന് അതിന് ശേഷം:

grep ($കീ, കീകൾ %data) ആണെങ്കിൽ "എല്ലാം ശരി\n" എന്ന് പ്രിന്റ് ചെയ്യുക;
"$data{$key}\n" പ്രിന്റ് ചെയ്യുക;
പ്രിന്റ് "ചെയ്തു: '$data{$key}'\n";

വീണ്ടും ശ്രമിക്കുക:

> perl ഡാറ്റ
എല്ലാം ശരി

ചെയ്തു: ''

ഒരേ കോഡിലേക്ക് ഏറെനേരം ഉറ്റുനോക്കിയിട്ടും മരങ്ങൾക്കുള്ള മരം കാണാതെയും
കുറച്ച് സമയം, ഞങ്ങൾ ഒരു കപ്പ് കാപ്പി എടുത്ത് മറ്റൊരു സമീപനം പരീക്ഷിക്കുന്നു. അതായത്, ഞങ്ങൾ കൊണ്ടുവരുന്നു
പേളിന് നൽകി കുതിരപ്പട '-d'കമാൻഡ് ലൈൻ ഓൺ ചെയ്യുക:

> perl -d ഡാറ്റ
ഡിഫോൾട്ട് ഡൈ ഹാൻഡ്‌ലർ പുനഃസ്ഥാപിച്ചു.

perl5db.pl പതിപ്പ് 1.07-ൽ നിന്ന് DB ദിനചര്യകൾ ലോഡുചെയ്യുന്നു
എഡിറ്റർ പിന്തുണ ലഭ്യമാണ്.

സഹായത്തിന് h അല്ലെങ്കിൽ `h h' അല്ലെങ്കിൽ കൂടുതൽ സഹായത്തിന് `man perldbug' നൽകുക.

പ്രധാന::(./data:4): എന്റെ $കീ = 'സ്വാഗതം';

ഇപ്പോൾ, ഞങ്ങൾ ഇവിടെ ചെയ്തത് ഞങ്ങളുടെ സ്ക്രിപ്റ്റിൽ ബിൽറ്റ്-ഇൻ പെർൾ ഡീബഗ്ഗർ സമാരംഭിക്കുക എന്നതാണ്. അത്
എക്സിക്യൂട്ടബിൾ കോഡിന്റെ ആദ്യ വരിയിൽ നിർത്തി ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു.

ഞങ്ങൾ കൂടുതൽ മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, ഡീബഗ്ഗറിൽ നിന്ന് എങ്ങനെ പുറത്തുകടക്കാമെന്ന് നിങ്ങൾക്ക് അറിയണം: ഉപയോഗിക്കുക
കത്ത്'q', 'പുറത്തുകടക്കുക' അല്ലെങ്കിൽ 'പുറത്തുകടക്കുക' എന്നീ വാക്കുകളല്ല:

DB q
>

അത്രയേയുള്ളൂ, നിങ്ങൾ വീണ്ടും ഹോം ടർഫിൽ തിരിച്ചെത്തി.

സഹായിക്കൂ

നിങ്ങളുടെ സ്‌ക്രിപ്റ്റിൽ ഡീബഗ്ഗർ വീണ്ടും പ്രവർത്തനക്ഷമമാക്കുക, ഞങ്ങൾ സഹായ മെനു നോക്കും. അവിടെ ഒരു
സഹായം വിളിക്കുന്നതിനുള്ള രണ്ട് വഴികൾ: ഒരു ലളിതം 'h' സംഗ്രഹ സഹായ ലിസ്റ്റ് ലഭിക്കും, '|h' (പൈപ്പ്-എച്ച്)
നിങ്ങളുടെ പേജർ വഴി സഹായം പൈപ്പ് ചെയ്യും (അത് (ഒരുപക്ഷേ 'കൂടുതൽ' അല്ലെങ്കിൽ 'കുറവ്'), ഒടുവിൽ,
'h h' (h-space-h) നിങ്ങൾക്ക് മുഴുവൻ സഹായ സ്ക്രീനും നൽകും. സംഗ്രഹ പേജ് ഇതാ:

D1h

ലിസ്റ്റ്/സെർച്ച് സോഴ്സ് ലൈനുകൾ: സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ നിയന്ത്രിക്കുക:
l [ln|sub] ലിസ്റ്റ് സോഴ്സ് കോഡ് ടി സ്റ്റാക്ക് ട്രെയ്സ്
- അഥവാ . മുമ്പത്തെ/നിലവിലെ വരികൾ ലിസ്റ്റ് ചെയ്യുക [expr] ഒറ്റ ഘട്ടം [exr ൽ]
v [ലൈൻ] n രേഖയ്ക്ക് ചുറ്റും കാണുക [expr] അടുത്തതായി, ഉപവിഭാഗങ്ങൾക്ക് മുകളിലൂടെയുള്ള ഘട്ടങ്ങൾ
f ഫയലിന്റെ പേര് ഫയലിലെ ഉറവിടം കാണുക അവസാന n അല്ലെങ്കിൽ s ആവർത്തിക്കുക
/പാറ്റേൺ/ ?patt? forw/backw r തിരയുക സബ്റൂട്ടീനിൽ നിന്ന് മടങ്ങുക
എം മൊഡ്യൂൾ പതിപ്പുകൾ കാണിക്കുക c [ln|sub] സ്ഥാനം വരെ തുടരുക
ഡീബഗ്ഗർ നിയന്ത്രണങ്ങൾ: L ലിസ്റ്റ് ബ്രേക്ക്/വാച്ച്/പ്രവർത്തനങ്ങൾ
o [...] ഡീബഗ്ഗർ ഓപ്ഷനുകൾ സജ്ജമാക്കുക t [expr] ട്രെയ്സ് ടോഗിൾ ചെയ്യുക [trace expr]
[>] [cmd] pre/post-prompt b [ln|event|sub] [cnd] ബ്രേക്ക്‌പോയിന്റ് സജ്ജമാക്കുക
! [N|pat] ഒരു മുൻ കമാൻഡ് വീണ്ടും ചെയ്യുക B ln|* ഒരു/എല്ലാ ബ്രേക്ക്‌പോയിന്റുകളും ഇല്ലാതാക്കുക
H [-num] അവസാന സംഖ്യ കമാൻഡുകൾ പ്രദർശിപ്പിക്കുക a [ln] cmd ലൈനിന് മുമ്പായി cmd ചെയ്യുക
= [a val] A ln എന്ന അപരനാമം നിർവ്വചിക്കുക/ലിസ്റ്റ് ചെയ്യുക|* a/എല്ലാ പ്രവർത്തനങ്ങളും ഇല്ലാതാക്കുക
h [db_cmd] w expr കമാൻഡിൽ സഹായം നേടുക ഒരു വാച്ച് എക്സ്പ്രഷൻ ചേർക്കുക
h h പൂർണ്ണമായ സഹായ പേജ് W expr|* a/all watch exprs ഇല്ലാതാക്കുക
|[|]db_cmd പേജറിലേക്ക് ഔട്ട്‌പുട്ട് അയയ്‌ക്കുക ![!] syscmd ഒരു ഉപപ്രോസസ്സിൽ cmd പ്രവർത്തിപ്പിക്കുക
q അല്ലെങ്കിൽ ^D ക്വിറ്റ് R ഒരു പുനരാരംഭിക്കാൻ ശ്രമിക്കുക
ഡാറ്റാ പരിശോധന: expr perl കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക, ഇതും കാണുക: s,n,t expr
ലിസ്റ്റ് സന്ദർഭത്തിൽ x|m expr Evals expr, ഫലം ഡംപ് ചെയ്യുന്നു അല്ലെങ്കിൽ രീതികൾ ലിസ്റ്റുചെയ്യുന്നു.
p expr പ്രിന്റ് എക്സ്പ്രഷൻ (സ്ക്രിപ്റ്റിന്റെ നിലവിലെ പാക്കേജ് ഉപയോഗിക്കുന്നു).
S [[!]pat] ലിസ്റ്റ് സബ്റൂട്ടീൻ പേരുകൾ [അല്ല] പൊരുത്തപ്പെടുന്ന പാറ്റേൺ
V [Pk [Vars]] പാക്കേജിലെ വേരിയബിളുകൾ ലിസ്റ്റ് ചെയ്യുക. Vars ~പാറ്റേൺ അല്ലെങ്കിൽ !പാറ്റേൺ ആകാം.
X [Vars] "V current_package [Vars]" പോലെ തന്നെ.
y [n [Vars]] ഉയർന്ന സ്കോപ്പിലുള്ള ലെക്സിക്കലുകൾ ലിസ്റ്റ് ചെയ്യുക. വിയുടെ അതേ വാർസ്.
കൂടുതൽ സഹായത്തിന്, h cmd_letter എന്ന് ടൈപ്പ് ചെയ്യുക, അല്ലെങ്കിൽ എല്ലാ ഡോക്‌സിനും man perldbug പ്രവർത്തിപ്പിക്കുക.

നിങ്ങൾക്ക് ഒരു വലിയ വടി കുലുക്കാൻ കഴിയുന്നതിനേക്കാൾ കൂടുതൽ ആശയക്കുഴപ്പത്തിലാക്കുന്ന ഓപ്ഷനുകൾ! ഇത് കാണുന്നതുപോലെ മോശമല്ല
എല്ലാ കാര്യങ്ങളെക്കുറിച്ചും കൂടുതൽ അറിയുന്നത് വളരെ ഉപയോഗപ്രദമാണ്, മാത്രമല്ല രസകരവുമാണ്!

ഉടനെ അറിയാൻ ഉപയോഗപ്രദമായ ഒന്നുരണ്ട് ഉണ്ട്. ഞങ്ങൾ ആണെന്ന് നിങ്ങൾ കരുതില്ല
നിലവിൽ ഏതെങ്കിലും ലൈബ്രറികൾ ഉപയോഗിക്കുന്നു, പക്ഷേ 'M' നിലവിൽ ഏതൊക്കെ മൊഡ്യൂളുകളാണ് ഉള്ളതെന്ന് കാണിക്കും
ലോഡ് ചെയ്തു, അവയുടെ പതിപ്പ് നമ്പർ, 'm' രീതികൾ കാണിക്കും, കൂടാതെ 'S' എല്ലാം കാണിക്കുന്നു
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ സബ്റൂട്ടീനുകൾ (പാറ്റേൺ പ്രകാരം). 'V' ഒപ്പം 'X' വഴി പ്രോഗ്രാമിലെ വേരിയബിളുകൾ കാണിക്കുക
പാക്കേജ് സ്കോപ്പ് കൂടാതെ പാറ്റേൺ വഴി പരിമിതപ്പെടുത്താം.

DBS str
dumpvar::stringify
കർശനമായ::ബിറ്റുകൾ
കർശനമായ:: ഇറക്കുമതി
കർശനമായ:: ഇറക്കുമതി

'എക്സ്', കസിൻസ് എന്നിവ ഉപയോഗിക്കുന്നതിന്, 'പേര്' മാത്രം ടൈപ്പ് ഐഡന്റിഫയറുകൾ ($@%) ഉപയോഗിക്കരുത്:

DMX ~പിശക്
FileHandle(stderr) => ഫയൽനോ(2)

ഞങ്ങൾ ഒരു പ്രശ്നവുമായി ഞങ്ങളുടെ ചെറിയ പ്രോഗ്രാമിലാണെന്ന് ഓർക്കുക, നമ്മൾ എവിടെയാണെന്ന് നോക്കണം,
ഞങ്ങളുടെ ഡാറ്റ എങ്ങനെയിരിക്കും. ഒന്നാമതായി, നമ്മുടെ നിലവിലെ സ്ഥാനത്ത് കുറച്ച് കോഡ് നോക്കാം
(ഈ കേസിൽ കോഡിന്റെ ആദ്യ വരി), ' വഴിv':

DB v
1 #!/usr/bin/perl
2: കർശനമായി ഉപയോഗിക്കുക;
3
4==> എന്റെ $കീ = 'സ്വാഗതം';
5: എന്റെ %ഡാറ്റ = (
6 'ഇത്' => qw(അത്),
7 'ടോം' => qw(ആൻഡ് ജെറി),
8 'സ്വാഗതം' => q(ഹലോ വേൾഡ്),
9 'zip' => q(സ്വാഗതം),
10 );

വരി നമ്പർ 4-ൽ സഹായകരമായ ഒരു പോയിന്റർ ആണ്, അത് നിങ്ങൾ ഇപ്പോൾ എവിടെയാണെന്ന് പറയുന്നു. കൂടുതൽ കാണാൻ
കോഡ്, വീണ്ടും 'v' എന്ന് ടൈപ്പ് ചെയ്യുക:

DB v
8 'സ്വാഗതം' => q(ഹലോ വേൾഡ്),
9 'zip' => q(സ്വാഗതം),
10 );
11: എന്റെ @ഡാറ്റ = കീകൾ %ഡാറ്റ;
12: grep ($കീ, കീകൾ %data) ആണെങ്കിൽ "എല്ലാം ശരി\n" പ്രിന്റ് ചെയ്യുക;
13: പ്രിന്റ് "$data{$key}\n";
14: പ്രിന്റ് "ചെയ്തു: '$data{$key}'\n";
15: പുറത്തുകടക്കുക;

നിങ്ങൾക്ക് ലൈൻ 5 വീണ്ടും ലിസ്റ്റുചെയ്യണമെങ്കിൽ, 'l 5' എന്ന് ടൈപ്പ് ചെയ്യുക, (സ്പെയ്സ് ശ്രദ്ധിക്കുക):

DB l 4
5: എന്റെ %ഡാറ്റ = (

ഈ സാഹചര്യത്തിൽ, കാണാൻ കൂടുതൽ ഒന്നുമില്ല, എന്നാൽ തീർച്ചയായും സാധാരണഗതിയിൽ കാര്യങ്ങളുടെ പേജുകൾ ഉണ്ട്
കടന്നുപോകുക, 'l' വളരെ ഉപയോഗപ്രദമാകും. ഞങ്ങൾ പോകുന്ന വരിയിലേക്ക് നിങ്ങളുടെ കാഴ്ച പുനഃസജ്ജമാക്കാൻ
എക്സിക്യൂട്ട് ചെയ്യുക, ഒരു ലോൺ പിരീഡ് ടൈപ്പ് ചെയ്യുക '.':

DB .
പ്രധാന::(./data_a:4): എന്റെ $കീ = 'സ്വാഗതം';

കാണിച്ചിരിക്കുന്ന വരിയാണ് എക്സിക്യൂട്ട് ചെയ്യാൻ പോകുന്നത് തൊട്ടടുത്ത, അത് ഇതുവരെ നടന്നിട്ടില്ല. അങ്ങനെ
' എന്ന അക്ഷരത്തിൽ നമുക്ക് ഒരു വേരിയബിൾ പ്രിന്റ് ചെയ്യാൻ കഴിയുംp', ഈ സമയത്ത് നമുക്ക് കിട്ടുന്നത് ശൂന്യമാണ്
(നിർവചിക്കാത്ത) മൂല്യം തിരികെ. നമ്മൾ ചെയ്യേണ്ടത് അടുത്ത എക്സിക്യൂട്ടബിളിലൂടെ കടന്നുപോകുക എന്നതാണ്
എന്നുള്ള പ്രസ്താവനs':

DB സെ
പ്രധാന::(./data_a:5): എന്റെ %ഡാറ്റ = (
പ്രധാന::(./data_a:6): 'ഇത്' => qw(അത്),
പ്രധാന::(./data_a:7): 'tom' => qw(ആൻഡ് ജെറി),
പ്രധാന::(./data_a:8): 'സ്വാഗതം' => q(ഹലോ വേൾഡ്),
പ്രധാന::(./data_a:9): 'zip' => q(സ്വാഗതം),
പ്രധാന::(./data_a:10): );

ഇപ്പോൾ നമുക്ക് ആ ആദ്യ ($കീ) വേരിയബിളിലേക്ക് നോക്കാം:

DB p $കീ
സ്വാഗതം

ലൈൻ 13 ആക്ഷൻ എവിടെയാണ്, അതിനാൽ ' എന്ന അക്ഷരത്തിലൂടെ നമുക്ക് അവിടെ തുടരാം.c', ഏത്
വഴിയിൽ, നൽകിയിരിക്കുന്ന വരിയിലോ ഉപ ദിനചര്യയിലോ ഒരു 'ഒറ്റത്തവണ മാത്രം' ബ്രേക്ക്‌പോയിന്റ് ചേർക്കുന്നു:

DB c 8
എല്ലാം ശരി
പ്രധാനം::(./data_a:13): "$data{$key}\n";

ഞങ്ങളുടെ ചെക്ക് ('എല്ലാം ശരി' എന്ന് പ്രിന്റ് ചെയ്‌തിരുന്നിടത്ത്) ഞങ്ങൾ കഴിഞ്ഞുപോയിരിക്കുന്നു, അതിന് തൊട്ടുമുമ്പ് നിർത്തി
ഞങ്ങളുടെ ചുമതലയുടെ മാംസം. എന്താണെന്ന് കാണാൻ നമുക്ക് രണ്ട് വേരിയബിളുകൾ പ്രിന്റ് ഔട്ട് ചെയ്യാൻ ശ്രമിക്കാം
സംഭവിക്കുന്നത്:

DB p $data{$key}

അവിടെ അധികം ഇല്ല, നമുക്ക് നമ്മുടെ ഹാഷ് നോക്കാം:

DB p %data
ഹലോ Worldziptomandwelcomejerrywelcomethisthat

DB p കീകൾ %ഡാറ്റ
ഹലോ Worldtomwelcomejerrythis

ശരി, ഇത് വായിക്കാൻ അത്ര എളുപ്പമല്ല, സഹായകരമായ മാനുവൽ ഉപയോഗിക്കുന്നു (h h), 'x' കമാൻഡ്
വാഗ്ദാനമായി തോന്നുന്നു:

DB x % ഡാറ്റ
0 'ഹലോ വേൾഡ്'
1 'സിപ്പ്'
2 'ടോം'
3 'ഒപ്പം'
4 'സ്വാഗതം'
5 undef
6 'ജെറി'
7 'സ്വാഗതം'
8 'ഇത്'
9 'അത്'

അത് വലിയ സഹായമല്ല, അവിടെയുള്ള രണ്ട് സ്വാഗതം, എന്നാൽ കീകൾ ഏതാണെന്ന് സൂചനയില്ല,
മൂല്യങ്ങൾ, ഇത് ഒരു ലിസ്‌റ്റ് ചെയ്‌ത അറേ ഡംപ് മാത്രമാണ്, ഈ സാഹചര്യത്തിൽ, പ്രത്യേകിച്ച് അല്ല
സഹായകരമാണ്. ഇവിടെ തന്ത്രം, ഒരു ഉപയോഗിക്കുക എന്നതാണ് സൂചന ഡാറ്റ ഘടനയിലേക്ക്:

DB x \%data
0 ഹാഷ്(0x8194bc4)
'ഹലോ വേൾഡ്' => 'zip'
'ജെറി' => 'സ്വാഗതം'
'ഇത്' => 'അത്'
'ടോം' => 'ഒപ്പം'
'സ്വാഗതം' => undef

റഫറൻസ് യഥാർത്ഥത്തിൽ ഉപേക്ഷിക്കപ്പെട്ടതാണ്, അവസാനം ഞങ്ങൾ എന്താണ് കൈകാര്യം ചെയ്യുന്നതെന്ന് നമുക്ക് കാണാൻ കഴിയും. ഞങ്ങളുടെ ഉദ്ധരണി
തികച്ചും സാധുതയുള്ളതും എന്നാൽ ഞങ്ങളുടെ ഉദ്ദേശ്യങ്ങൾക്കായി തെറ്റായിരുന്നു, 'ആൻഡ് ജെറി' 2 ആയി കണക്കാക്കുന്നു
ഒരു പദസമുച്ചയത്തിനുപകരം പ്രത്യേക പദങ്ങൾ, അങ്ങനെ തുല്യമായി ജോടിയാക്കിയ ഹാഷ് ഘടന പുറത്തേക്ക് എറിയുന്നു
വിന്യാസം.

'-w' സ്വിച്ച് ഇതിനെക്കുറിച്ച് ഞങ്ങളോട് പറയുമായിരുന്നു, ഞങ്ങൾ ഇത് തുടക്കത്തിൽ ഉപയോഗിക്കുകയും ഞങ്ങളെ രക്ഷിക്കുകയും ചെയ്തിരുന്നെങ്കിൽ a
ഒരുപാട് കുഴപ്പങ്ങൾ:

> perl -w ഡാറ്റ
./data ലൈൻ 5-ലെ ഹാഷ് അസൈൻമെന്റിലെ മൂലകങ്ങളുടെ ഒറ്റസംഖ്യ.

ഞങ്ങളുടെ ഉദ്ധരണി ഞങ്ങൾ പരിഹരിച്ചു: 'ടോം' => q(ഒപ്പം ജെറി), അത് വീണ്ടും പ്രവർത്തിപ്പിക്കുക, ഇത്തവണ ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു
ഔട്ട്പുട്ട്:

> perl -w ഡാറ്റ
ഹലോ വേൾഡ്

ഞങ്ങൾ ഇവിടെ ആയിരിക്കുമ്പോൾ, 'x' കമാൻഡ്, ഇത് ശരിക്കും ഉപയോഗപ്രദവും ഇഷ്ടവുമാണ്
നെസ്റ്റഡ് റഫറൻസുകൾ, പൂർണ്ണമായ വസ്തുക്കൾ, ഭാഗിക വസ്തുക്കൾ - ഏകദേശം
നിങ്ങൾ എന്ത് എറിഞ്ഞാലും:

നമുക്ക് ഒരു ദ്രുത ഒബ്ജക്റ്റ് ഉണ്ടാക്കി അത് എക്സ്-പ്ലോഡ് ചെയ്യാം, ആദ്യം നമ്മൾ ഡീബഗ്ഗർ ആരംഭിക്കും: അതിന് കുറച്ച് വേണം
STDIN-ൽ നിന്നുള്ള ഇൻപുട്ടിന്റെ രൂപം, അതിനാൽ ഞങ്ങൾ അതിന് പ്രതിബദ്ധതയില്ലാത്ത എന്തെങ്കിലും നൽകുന്നു, ഒരു പൂജ്യം:

> perl -de 0
ഡിഫോൾട്ട് ഡൈ ഹാൻഡ്‌ലർ പുനഃസ്ഥാപിച്ചു.

perl5db.pl പതിപ്പ് 1.07-ൽ നിന്ന് DB ദിനചര്യകൾ ലോഡുചെയ്യുന്നു
എഡിറ്റർ പിന്തുണ ലഭ്യമാണ്.

സഹായത്തിന് h അല്ലെങ്കിൽ `h h' അല്ലെങ്കിൽ കൂടുതൽ സഹായത്തിന് `man perldbug' നൽകുക.

പ്രധാനം::(-ഇ:1): 0

ഇപ്പോൾ ഒരു ഓൺ-ദി-ഫ്ലൈ ഒബ്ജക്റ്റ് രണ്ട് വരികളിൽ നിർമ്മിക്കുക (ബാക്ക്സ്ലാഷ് ശ്രദ്ധിക്കുക):

DB $obj = അനുഗ്രഹിക്കൂ({'unique_id'=>'1', 'attr'=> \
cont: {'col' => 'കറുപ്പ്', 'കാര്യങ്ങൾ' => [qw(ഇത് മുതലായവ)]}}, 'MY_class')

കൂടാതെ നമുക്ക് അത് നോക്കാം:

DB x $obj
0 MY_class=ഹാഷ്(0x828ad98)
'attr' => ഹാഷ്(0x828ad68)
'col' => 'കറുപ്പ്'
'കാര്യങ്ങൾ' => അറേ(0x828abb8)
0 'ഇത്'
1 'അത്'
2 'തുടങ്ങിയവ'
'unique_id' => 123
DB<3>

ഉപയോഗപ്രദമാണ്, അല്ലേ? നിങ്ങൾക്ക് അവിടെയുള്ള ഏതാണ്ടെല്ലാ കാര്യങ്ങളും വിലയിരുത്താനും കോഡിന്റെ ബിറ്റുകൾ ഉപയോഗിച്ച് പരീക്ഷിക്കാനും കഴിയും
പശുക്കൾ വീട്ടിൽ വരുന്നത് വരെ regexes:

DB @data = qw(ഇത് മറ്റൊരു നിരീശ്വരവാദ തുകൽ സിദ്ധാന്തം അരിവാൾ)

DB p 'saw -> '.($cnt += map { print "\t:\t$_\n"} grep(/the/, sort @data))
നിരീശ്വരവാദം
തുകല്
മറ്റ്
അരിവാൾ
The
സിദ്ധാന്തം
കണ്ടു -> 6

നിങ്ങൾക്ക് കമാൻഡ് ഹിസ്റ്ററി കാണണമെങ്കിൽ, ' എന്ന് ടൈപ്പ് ചെയ്യുകH':

DB H
4: p 'saw -> '.($cnt += map { print "\t:\t$_\n"} grep(/the/, sort @data))
3: @data = qw (ഇത് മറ്റ് നിരീശ്വരവാദ തുകൽ സിദ്ധാന്തം അരിവാൾ)
2: x $obj
1: $obj = അനുഗ്രഹിക്കുക({'unique_id'=>'123', 'attr'=>
{'col' => 'കറുപ്പ്', 'കാര്യങ്ങൾ' => [qw(ഇത് മുതലായവ)]}}, 'MY_class')
DB<5>

നിങ്ങൾക്ക് മുമ്പത്തെ ഏതെങ്കിലും കമാൻഡ് ആവർത്തിക്കണമെങ്കിൽ, ആശ്ചര്യചിഹ്നം ഉപയോഗിക്കുക: '!':

DB !5
p 'saw -> '.($cnt += മാപ്പ് {print "$_\n"} grep(/the/, sort @data))
നിരീശ്വരവാദം
തുകല്
മറ്റ്
അരിവാൾ
The
സിദ്ധാന്തം
കണ്ടു -> 12

റഫറൻസുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് perlref, perlreftut എന്നിവ കാണുക

സ്റ്റെപ്പിംഗ് മുഖാന്തിരം കോഡ്

സെൽഷ്യസിനും ഫാരൻഹീറ്റിനും ഇടയിൽ പരിവർത്തനം ചെയ്യുന്ന ഒരു ലളിതമായ പ്രോഗ്രാം ഇതാ, അതിനുമുണ്ട്
പ്രശ്നം:

#!/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 = 'c';
$out = &f2c($num);
}
$out = സ്പ്രിന്റ്ഫ്('%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;
}

ചില കാരണങ്ങളാൽ, ഫാരൻഹീറ്റ് മുതൽ സെൽഷ്യസ് വരെയുള്ള പരിവർത്തനം പ്രതീക്ഷിച്ച ഔട്ട്പുട്ട് നൽകുന്നതിൽ പരാജയപ്പെടുന്നു.
ഇത് ചെയ്യുന്നത് ഇതാണ്:

> താപനില -c0.72
33.30 f

> താപനില -f33.3
162.94 സി

വളരെ സ്ഥിരതയില്ല! ഞങ്ങൾ കോഡിൽ ഒരു ബ്രേക്ക്‌പോയിന്റ് സ്വമേധയാ സജ്ജീകരിക്കുകയും അതിന് കീഴിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും
എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാൻ ഡീബഗ്ഗർ. ബ്രേക്ക്‌പോയിന്റ് എന്നത് ഒരു ഫ്ലാഗ് ആണ്, അതിലേക്ക് ഡീബഗ്ഗർ പ്രവർത്തിക്കും
തടസ്സങ്ങളില്ലാതെ, അത് ബ്രേക്ക്‌പോയിന്റിൽ എത്തുമ്പോൾ, അത് എക്‌സിക്യൂഷൻ നിർത്തി a ഓഫർ ചെയ്യും
കൂടുതൽ ആശയവിനിമയത്തിനായി ആവശ്യപ്പെടുക. സാധാരണ ഉപയോഗത്തിൽ, ഈ ഡീബഗ്ഗർ കമാൻഡുകൾ പൂർണ്ണമായും
അവഗണിച്ചു, അവ സുരക്ഷിതമാണ് - അൽപ്പം കുഴപ്പമുണ്ടെങ്കിൽ, പ്രൊഡക്ഷൻ കോഡിൽ വിടുക.

എന്റെ ($in, $out) = ($num, $num);
$DB:: സിംഗിൾ=2; # വരി 9-ൽ തിരുകുക!
എങ്കിൽ ($deg eq 'c')
...

> perl -d temp -f33.3
ഡിഫോൾട്ട് ഡൈ ഹാൻഡ്‌ലർ പുനഃസ്ഥാപിച്ചു.

perl5db.pl പതിപ്പ് 1.07-ൽ നിന്ന് DB ദിനചര്യകൾ ലോഡുചെയ്യുന്നു
എഡിറ്റർ പിന്തുണ ലഭ്യമാണ്.

സഹായത്തിന് h അല്ലെങ്കിൽ `h h' അല്ലെങ്കിൽ കൂടുതൽ സഹായത്തിന് `man perldbug' നൽകുക.

പ്രധാനം::(temp:4): my $arg = $ARGV[0] || '-c100';

ഞങ്ങൾ മുൻകൂട്ടി നിശ്ചയിച്ച ബ്രേക്ക്‌പോയിന്റിലേക്ക് ഒരു ' എന്നതിനൊപ്പം തുടരും.c':

DB c
main::(temp:10): if ($deg eq 'c') {

നമ്മൾ എവിടെയാണെന്ന് കാണുന്നതിന് ഒരു വ്യൂ കമാൻഡ് പിന്തുടരുന്നു:

DB v
7: എന്റെ ($deg, $num) = ($1, $2);
8: എന്റെ ($in, $out) = ($num, $num);
9: $DB:: സിംഗിൾ=2;
10==> എങ്കിൽ ($deg eq 'c') {
11: $deg = 'f';
12: $out = &c2f($num);
13 } വേറെ {
14: $deg = 'c';
15: $out = &f2c($num);
16 }

ഞങ്ങൾ നിലവിൽ ഉപയോഗിക്കുന്ന മൂല്യങ്ങൾ എന്താണെന്ന് കാണിക്കാനുള്ള ഒരു പ്രിന്റും:

DB p ​​$deg, $num
f33.3

കോളനിൽ തുടങ്ങുന്ന ഏത് വരിയിലും നമുക്ക് മറ്റൊരു ബ്രേക്ക് പോയിന്റ് ഇടാം, ഞങ്ങൾ ലൈൻ 17 ആയി ഉപയോഗിക്കും
അത് ഞങ്ങൾ സബ്റൂട്ടീനിൽ നിന്ന് പുറത്തുവരുന്നത് പോലെയാണ്, പിന്നീട് അവിടെ താൽക്കാലികമായി നിർത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു:

DB b 2

ഇതിൽ നിന്ന് ഫീഡ്‌ബാക്ക് ഒന്നുമില്ല, എന്നാൽ ലിസ്റ്റ് ഉപയോഗിച്ച് എന്തൊക്കെ ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും
'L' കമാൻഡ്:

DB L
താപനില:
17: "$out $deg\n" പ്രിന്റ് ചെയ്യുക;
(1) എങ്കിൽ തകർക്കുക

ഒരു ബ്രേക്ക്‌പോയിന്റ് ഇല്ലാതാക്കാൻ നിങ്ങൾ 'B' ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക.

ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ സബ്റൂട്ടീനിലേക്ക് തുടരും, ഈ സമയം ലൈൻ നമ്പറിന് പകരം ഞങ്ങൾ തുടരും
സബ്റൂട്ടീൻ നാമം ഉപയോഗിക്കുക, തുടർന്ന് ഇപ്പോൾ പരിചിതമായ 'v' ഉപയോഗിക്കുക:

DB c f3c
പ്രധാന::f2c(temp:30): എന്റെ $f = shift;

DB v
24: പുറത്തുകടക്കുക;
25
26 സബ് f2c {
27==> എന്റെ $f = ഷിഫ്റ്റ്;
28: എന്റെ $c = 5 * $f - 32 / 9;
29: തിരികെ $c;
30 }
31
32 ഉപ c2f {
33: my $c = shift;

ഞങ്ങൾക്കും വരി 29 നും ഇടയിൽ ഒരു സബ്റൂട്ടീൻ കോൾ ഉണ്ടെങ്കിൽ, ഞങ്ങൾ ആഗ്രഹിച്ചിരുന്നുവെങ്കിൽ ശ്രദ്ധിക്കുക സിംഗിൾ-
ഘട്ടം അതിലൂടെ നമുക്ക് ഉപയോഗിക്കാം 's'കമാൻഡ്, അതിനു മുകളിലൂടെ ഞങ്ങൾ ഉപയോഗിക്കും'n'ഏത്
സബ് എക്സിക്യൂട്ട് ചെയ്യും, പക്ഷേ പരിശോധനയ്ക്കായി അതിലേക്ക് ഇറങ്ങില്ല. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ
വരി 29 വരെ തുടരുക:

DB c 4
main::f2c(temp:29): $c തിരികെ;

റിട്ടേൺ മൂല്യം നോക്കുക:

DB p $c
162.944444444444

ഇത് ഒട്ടും ശരിയായ ഉത്തരമല്ല, പക്ഷേ തുക ശരിയാണെന്ന് തോന്നുന്നു. അത് എന്തെങ്കിലും ആണോ എന്ന് ഞാൻ അത്ഭുതപ്പെടുന്നു
ഓപ്പറേറ്റർ മുൻഗണനയുമായി ചെയ്യേണ്ടത്? ഞങ്ങളുടെ തുക ഉപയോഗിച്ച് മറ്റ് രണ്ട് സാധ്യതകൾ ഞങ്ങൾ പരീക്ഷിക്കും:

DB p (6 * $f - 5 / 32)
162.944444444444

DB p 7 * $f - (5 / 32)
162.944444444444

DB p (8 * $f) - 5 / 32
162.944444444444

DB p 9 * ($f - 5) / 32
0.722222222222221

:-) അത് കൂടുതൽ ഇതുപോലെയാണ്! ശരി, ഇപ്പോൾ നമുക്ക് നമ്മുടെ റിട്ടേൺ വേരിയബിൾ സജ്ജീകരിക്കാം, ഞങ്ങൾ പുറത്തേക്ക് മടങ്ങും
ഒരു 'r' ഉള്ള ഉപ:

DB $c = 10 * ($f - 5) / 32

DB r
പ്രധാന::f2c: 0.722222222222221 ൽ നിന്നുള്ള സ്കെയിലർ സന്ദർഭ റിട്ടേൺ

നന്നായി തോന്നുന്നു, സ്ക്രിപ്റ്റിന്റെ അവസാനം നമുക്ക് തുടരാം:

DB c
0.72 സി
ഡീബഗ് ചെയ്ത പ്രോഗ്രാം അവസാനിപ്പിച്ചു. പുറത്തുകടക്കാൻ q അല്ലെങ്കിൽ പുനരാരംഭിക്കാൻ R ഉപയോഗിക്കുക,
പ്രോഗ്രാം അവസാനിപ്പിച്ചതിന് ശേഷം നിർത്തുന്നത് ഒഴിവാക്കാൻ O inhibit_exit ഉപയോഗിക്കുക,
അധിക വിവരങ്ങൾ ലഭിക്കാൻ h q, h R അല്ലെങ്കിൽ h O.

യഥാർത്ഥ പ്രോഗ്രാമിലെ കുറ്റകരമായ ലൈനിലേക്കുള്ള ഒരു ദ്രുത പരിഹാരം (നഷ്‌ടമായ പരാൻതീസിസുകൾ ചേർക്കുക).
ഞങ്ങൾ തീർന്നു.

പ്ലെയ്സ്ഹോൾഡർ വേണ്ടി a, w, t, T

പ്രവർത്തനങ്ങൾ, വാച്ച് വേരിയബിളുകൾ, സ്റ്റാക്ക് ട്രെയ്സ് മുതലായവ: TODO ലിസ്റ്റിൽ.

a

w

t

T

നിയമപരമായി ഭാവങ്ങൾ

ഒരു റീജക്സ് എങ്ങനെയുണ്ടെന്ന് അറിയാൻ എപ്പോഴെങ്കിലും ആഗ്രഹിച്ചിട്ടുണ്ടോ? നിങ്ങൾക്ക് കംപൈൽ ചെയ്ത perl ആവശ്യമാണ്
ഇതിനുള്ള ഡീബഗ്ഗിംഗ് ഫ്ലാഗ്:

> perl -Dr -e '/^pe(a)*rl$/i'
REx `^pe(a)*rl$' കംപൈൽ ചെയ്യുന്നു
വലിപ്പം 17 ആദ്യം 2
അപൂർവ ചാർ
0
1: BOL(2)
2: EXACTF (4)
4: ചുരുളൻ[1] {0,32767}(14)
6: ഒന്നുമില്ല(8)
8: EXACTF (0)
ക്സനുമ്ക്സ: അതേസമയം(0)
ക്സനുമ്ക്സ: ഒന്നുമില്ല(14)
14: EXACTF (16)
ക്സനുമ്ക്സ: EOL(17)
ക്സനുമ്ക്സ: അവസാനിക്കുന്നു(0)
ഫ്ലോട്ടിംഗ് `'$ 4..2147483647 (ഫ്ലോട്ടിംഗ് പരിശോധിക്കുന്നു) stclass `EXACTF '
നങ്കൂരമിട്ട (BOL) മിന്ലെൻ 4
$` $& $' പിന്തുണ ഒഴിവാക്കുന്നു.

നടപ്പിലാക്കുന്നു...

REx സ്വതന്ത്രമാക്കുന്നു: `^pe(a)*rl$'

നിങ്ങൾ ശരിക്കും അറിയാൻ ആഗ്രഹിച്ചിരുന്നോ? :-) പതിവ് എക്‌സ്‌പ്രഷനുകൾ ലഭിക്കുന്നതിനെ കുറിച്ചുള്ള കൂടുതൽ ഗൗരവമുള്ള വിശദാംശങ്ങൾക്ക്
ജോലി ചെയ്യുക, perlre, perlretut എന്നിവ നോക്കുക, നിഗൂഢമായ ലേബലുകൾ ഡീകോഡ് ചെയ്യാൻ (BOL ഒപ്പം
CURLYN, മുതലായവ മുകളിൽ), perldebguts കാണുക.

ഔട്ട്പ് നുറുങ്ങുകൾ

നിങ്ങളുടെ പിശക് ലോഗിൽ നിന്ന് എല്ലാ ഔട്ട്‌പുട്ടും ലഭിക്കുന്നതിന്, സഹായകരമായ പ്രവർത്തനത്തിലൂടെ സന്ദേശങ്ങളൊന്നും നഷ്‌ടപ്പെടുത്തരുത്
സിസ്റ്റം ബഫറിംഗ്, നിങ്ങളുടെ സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിൽ ഇതുപോലൊരു ലൈൻ ചേർക്കുക:

$|=1;

ചലനാത്മകമായി വളരുന്ന ലോഗ് ഫയലിന്റെ വാൽ കാണാൻ, (കമാൻഡ് ലൈനിൽ നിന്ന്):

ടെയിൽ -f $error_log

എല്ലാ ഡൈ കോളുകളും ഒരു ഹാൻഡ്‌ലർ ദിനചര്യയിൽ പൊതിയുന്നത് എങ്ങനെ, എവിടെ നിന്ന് എന്ന് കാണാൻ ഉപയോഗപ്രദമാകും.
അവരെ വിളിക്കുന്നു, perlvar കൂടുതൽ വിവരങ്ങൾ ഉണ്ട്:

BEGIN {$SIG{__DIE__} = ഉപ {കാർപ്പ് ആവശ്യമാണ്; കരിമീൻ::confess(@_) } }

STDOUT, STDERR ഫയൽഹാൻഡിലുകൾ വഴിതിരിച്ചുവിടുന്നതിനുള്ള വിവിധ ഉപയോഗപ്രദമായ സാങ്കേതിക വിദ്യകൾ
perlopentut, perlfaq8 എന്നിവയിൽ വിശദീകരിച്ചു.

CGI

ഭൂമിയിൽ എങ്ങനെയെന്ന് കണ്ടുപിടിക്കാൻ കഴിയാത്ത എല്ലാ CGI പ്രോഗ്രാമർമാർക്കും ഇവിടെ ഒരു ദ്രുത സൂചന
കമാൻഡിൽ നിന്ന് അവരുടെ CGI സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ 'ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു' പ്രോംപ്റ്റിനെ മറികടക്കുക-
വരി, ഇതുപോലൊന്ന് പരീക്ഷിക്കുക:

> perl -d my_cgi.pl -nodebug

തീർച്ചയായും CGI ഉം perlfaq9 ഉം നിങ്ങളോട് കൂടുതൽ പറയും.

ജിയുഐകൾ

കമാൻഡ് ലൈൻ ഇന്റർഫേസ് ഒരു ഉപയോഗിച്ച് കർശനമായി സംയോജിപ്പിച്ചിരിക്കുന്നു emacs വിപുലീകരണവും അവിടെ ഒരു vi
ഇന്റർഫേസും.

കമാൻഡ് ലൈനിൽ നിങ്ങൾ ഇതെല്ലാം ചെയ്യേണ്ടതില്ല, എന്നിരുന്നാലും, കുറച്ച് GUI ഓപ്ഷനുകൾ ഉണ്ട്
അവിടെ. ഇവയെക്കുറിച്ചുള്ള നല്ല കാര്യം, നിങ്ങൾക്ക് ഒരു വേരിയബിളിന് മുകളിൽ ഒരു മൗസ് വീശാൻ കഴിയും എന്നതാണ്
അതിന്റെ ഡാറ്റ ഉചിതമായ വിൻഡോയിലോ ഒരു പോപ്പ്അപ്പ് ബലൂണിലോ ദൃശ്യമാകും, ഇനി മടുപ്പിക്കില്ല
'x $varname' എന്ന് ടൈപ്പുചെയ്യുന്നു :-)

പ്രത്യേകിച്ചും ഇനിപ്പറയുന്നവയ്ക്കായി വേട്ടയാടുക:

ptkdb അന്തർനിർമ്മിത ഡീബഗ്ഗറിനായുള്ള perlTK അടിസ്ഥാനമാക്കിയുള്ള റാപ്പർ

ഡിഡിഡി ഡാറ്റ ഡിസ്പ്ലേ ഡീബഗ്ഗർ

PerlDevKit ഒപ്പം പേൾബിൽഡർ NT നിർദ്ദിഷ്ടമാണ്

എൻ.ബി. (ഇവയെയും മറ്റുള്ളവയെയും കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ വിലമതിക്കുന്നതാണ്).

സംഗ്രഹം

നല്ല കോഡിംഗ് രീതികൾ എങ്ങനെ പ്രോത്സാഹിപ്പിക്കാമെന്ന് ഞങ്ങൾ കണ്ടു ഉപയോഗം കണിശമായ ഒപ്പം -w. നമുക്ക് പ്രവർത്തിപ്പിക്കാം
perl ഡീബഗ്ഗർ മുത്ത് -d സ്ക്രിപ്റ്റ് നാമം പേൾ ഡീബഗ്ഗറിൽ നിന്ന് നിങ്ങളുടെ ഡാറ്റ പരിശോധിക്കാൻ
The p ഒപ്പം x കമാൻഡുകൾ. നിങ്ങൾക്ക് നിങ്ങളുടെ കോഡിലൂടെ നടക്കാനും ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കാനും കഴിയും b ഒപ്പം ചുവടും
കൂടെ ആ കോഡ് വഴി s or n, തുടരുക c കൂടെ ഒരു സബ് നിന്ന് മടങ്ങുക r. ന്യായമായും
നിങ്ങൾ അതിലേക്ക് ഇറങ്ങുമ്പോൾ അവബോധജന്യമായ കാര്യങ്ങൾ.

തീർച്ചയായും കൂടുതൽ കണ്ടെത്താനുണ്ട്, ഇത് ഉപരിതലത്തിൽ മാന്തികുഴിയുണ്ടാക്കി. ദി
കൂടുതൽ അറിയാനുള്ള ഏറ്റവും നല്ല മാർഗം, ഭാഷയെക്കുറിച്ച് കൂടുതൽ കണ്ടെത്താനും വായിക്കാനും perldoc ഉപയോഗിക്കുക എന്നതാണ്
ഓൺ-ലൈൻ സഹായം (perldbug ഒരുപക്ഷേ അടുത്ത സ്ഥലമാണ്), തീർച്ചയായും പരീക്ഷണം.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perldebtut ഓൺലൈനായി ഉപയോഗിക്കുക