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

പട്ടിക:

NAME

perlsyn - പേൾ വാക്യഘടന

വിവരണം

ഒരു പേൾ പ്രോഗ്രാമിൽ നിന്ന് പ്രവർത്തിക്കുന്ന പ്രഖ്യാപനങ്ങളുടെയും പ്രസ്താവനകളുടെയും ഒരു ശ്രേണി അടങ്ങിയിരിക്കുന്നു
മുകളിൽ നിന്ന് താഴേക്ക്. ലൂപ്പുകൾ, സബ്റൂട്ടീനുകൾ, മറ്റ് നിയന്ത്രണ ഘടനകൾ എന്നിവ നിങ്ങളെ കുതിക്കാൻ അനുവദിക്കുന്നു
കോഡിനുള്ളിൽ ചുറ്റും.

പേൾ എ സ്വതന്ത്ര രൂപം ഭാഷ: നിങ്ങൾക്ക് ഇഷ്ടമുള്ള രീതിയിൽ ഫോർമാറ്റ് ചെയ്യാനും ഇൻഡന്റ് ചെയ്യാനും കഴിയും. വൈറ്റ് സ്പേസ്
പ്രധാനമായും പൈത്തൺ പോലുള്ള ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി ടോക്കണുകൾ വേർതിരിക്കാൻ ഇത് സഹായിക്കുന്നു
വാക്യഘടനയുടെ ഭാഗം, അല്ലെങ്കിൽ ഫോർട്രാൻ അത് അഭൌതികമാണ്.

പേളിന്റെ പല വാക്യഘടന ഘടകങ്ങളും ഓപ്ഷണൽ. നിങ്ങൾ ഇടാൻ ആവശ്യപ്പെടുന്നതിനുപകരം
ഓരോ ഫംഗ്‌ഷൻ കോളിനും ചുറ്റുമുള്ള പരാൻതീസിസുകളും ഓരോ വേരിയബിളും പ്രഖ്യാപിക്കുക, നിങ്ങൾക്ക് പലപ്പോഴും ഉപേക്ഷിക്കാം
അത്തരം വ്യക്തമായ ഘടകങ്ങൾ ഓഫാണ്, നിങ്ങൾ എന്താണ് ഉദ്ദേശിച്ചതെന്ന് Perl മനസ്സിലാക്കും. എന്നാണ് ഇത് അറിയപ്പെടുന്നത് Do
എന്ത് I മാധവൻ, ചുരുക്കത്തിൽ DWIM. ഇത് പ്രോഗ്രാമർമാരെ ആകാൻ അനുവദിക്കുന്നു അലസമായ ഒരു ശൈലിയിൽ കോഡ് ചെയ്യാനും
അവർ സുഖപ്രദമായ കൂടെ.

പേൾ കടമെടുക്കുന്നു സിന്റാക്സ് കൂടാതെ നിരവധി ഭാഷകളിൽ നിന്നുള്ള ആശയങ്ങൾ: awk, sed, C, Bourne Shell,
സ്മോൾടോക്ക്, ലിസ്പ്, ഇംഗ്ലീഷ് പോലും. മറ്റ് ഭാഷകൾ പേളിൽ നിന്ന് വാക്യഘടന കടമെടുത്തിട്ടുണ്ട്,
പ്രത്യേകിച്ച് അതിന്റെ പതിവ് എക്സ്റ്റൻഷനുകൾ. അതിനാൽ നിങ്ങൾ മറ്റൊന്നിൽ പ്രോഗ്രാം ചെയ്തിട്ടുണ്ടെങ്കിൽ
ഭാഷയിൽ നിങ്ങൾക്ക് പരിചിതമായ ഭാഗങ്ങൾ Perl-ൽ കാണാം. അവ പലപ്പോഴും ഒരേപോലെ പ്രവർത്തിക്കുന്നു, പക്ഷേ പെർൽട്രാപ്പ് കാണുക
അവ എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾക്ക്.

പ്രഖ്യാപനങ്ങൾ
നിങ്ങൾ Perl-ൽ പ്രഖ്യാപിക്കേണ്ട കാര്യങ്ങൾ റിപ്പോർട്ട് ഫോർമാറ്റുകളും സബ്റൂട്ടീനുകളും (ഒപ്പം
ചിലപ്പോൾ സബ്റൂട്ടീനുകൾ പോലുമില്ല). ഒരു സ്കെയിലർ വേരിയബിൾ നിർവചിക്കാത്ത മൂല്യം ("undef") കൈവശം വയ്ക്കുന്നു.
അതിന് ഒരു നിർവ്വചിച്ച മൂല്യം നൽകുന്നതുവരെ, അത് "undef" അല്ലാതെ മറ്റെന്തെങ്കിലും ആണ്. എപ്പോൾ
ഒരു സംഖ്യയായി ഉപയോഗിക്കുന്നു, "undef" 0 ആയി കണക്കാക്കുന്നു; ഒരു സ്ട്രിംഗായി ഉപയോഗിക്കുമ്പോൾ, അത് ആയി കണക്കാക്കുന്നു
ശൂന്യമായ സ്ട്രിംഗ്, ""; അസൈൻ ചെയ്യാത്ത ഒരു റഫറൻസായി ഉപയോഗിക്കുമ്പോൾ, അത് പരിഗണിക്കും
ഒരു പിശക് പോലെ. നിങ്ങൾ മുന്നറിയിപ്പുകൾ പ്രവർത്തനക്ഷമമാക്കുകയാണെങ്കിൽ, ഒരു അൺഇനിഷ്യലൈസ്ഡ് മൂല്യത്തെക്കുറിച്ച് നിങ്ങളെ അറിയിക്കും
നിങ്ങൾ "undef" എന്നത് ഒരു സ്ട്രിംഗോ അക്കമോ ആയി കണക്കാക്കുമ്പോഴെല്ലാം. നന്നായി, സാധാരണയായി. ബൂളിയൻ സന്ദർഭങ്ങൾ,
അതുപോലെ:

എങ്കിൽ ($a) {}

മുന്നറിയിപ്പുകളിൽ നിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു (കാരണം അവർ നിർവചിക്കുന്നതിനുപകരം സത്യത്തെ ശ്രദ്ധിക്കുന്നു).
നിർവചിക്കാത്ത വേരിയബിളുകളിൽ പ്രവർത്തിക്കുന്ന "++", "--", "+=", "-=", ".=" തുടങ്ങിയ ഓപ്പറേറ്റർമാർ
അതുപോലെ:

undef $a;
$a++;

ഇത്തരം മുന്നറിയിപ്പുകളിൽ നിന്ന് എപ്പോഴും ഒഴിവാണ്.

ഒരു പ്രസ്താവനയ്ക്ക് കഴിയുന്ന എവിടെയും ഒരു പ്രഖ്യാപനം നടത്താം, പക്ഷേ അത് നടപ്പിലാക്കുന്നതിൽ യാതൊരു സ്വാധീനവുമില്ല
പ്രസ്‌താവനകളുടെ പ്രാഥമിക ക്രമം: പ്രഖ്യാപനങ്ങളെല്ലാം സമാഹരിക്കുന്ന സമയത്ത് പ്രാബല്യത്തിൽ വരും. എല്ലാം
പ്രഖ്യാപനങ്ങൾ സാധാരണയായി സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിലോ അവസാനത്തിലോ ഇടുന്നു. എന്നിരുന്നാലും, എങ്കിൽ
നിങ്ങൾ "my()", "state()" അല്ലെങ്കിൽ
"നമ്മുടെ()", നിങ്ങളുടെ ഫോർമാറ്റ് അല്ലെങ്കിൽ സബ്റൂട്ടീൻ നിർവചനം സമാനമാണെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്
ആ സ്വകാര്യ വേരിയബിളുകൾ ആക്‌സസ് ചെയ്യാൻ കഴിയുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ എന്റെ സ്കോപ്പ് ബ്ലോക്ക് ചെയ്യുക.

ഒരു സബ്റൂട്ടീൻ പ്രഖ്യാപിക്കുന്നത് ഒരു ലിസ്റ്റ് ഓപ്പറേറ്റർ പോലെ ഒരു സബ്റൂട്ടീൻ പേര് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു
ആ പോയിന്റ് മുതൽ പ്രോഗ്രാമിൽ മുന്നോട്ട്. നിർവ്വചിക്കാതെ തന്നെ നിങ്ങൾക്ക് ഒരു സബ്റൂട്ടീൻ പ്രഖ്യാപിക്കാം
"ഉപ നാമം" പറഞ്ഞുകൊണ്ട്, ഇങ്ങനെ:

ഉപ മൈനേം;
$മീ = എന്റെ പേര് $0 അല്ലെങ്കിൽ മരിക്കുക "എന്റെ പേര് ലഭിക്കില്ല";

അത്തരത്തിലുള്ള ഒരു നഗ്നമായ പ്രഖ്യാപനം ഫംഗ്‌ഷനെ ഒരു ലിസ്റ്റ് ഓപ്പറേറ്ററായി പ്രഖ്യാപിക്കുന്നു, അല്ലാതെ ഒരു ഏകീകൃതമല്ല
ഓപ്പറേറ്റർ, അതിനാൽ നിങ്ങൾ പരാൻതീസിസുകൾ (അല്ലെങ്കിൽ "||" എന്നതിന് പകരം "അല്ലെങ്കിൽ") ഉപയോഗിക്കാൻ ശ്രദ്ധിക്കണം.
"||" ലിസ്റ്റ് ഓപ്പറേറ്റർമാർക്ക് ശേഷം ഉപയോഗിക്കാനാകാത്തവിധം ഓപ്പറേറ്റർ വളരെ കർശനമായി ബന്ധിപ്പിക്കുന്നു; അത് അവസാനത്തിന്റെ ഭാഗമാകുന്നു
ഘടകം. ലിസ്റ്റ് ഓപ്പറേറ്റർ ആർഗ്യുമെന്റുകൾക്ക് ചുറ്റും നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും പരാൻതീസിസുകൾ ഉപയോഗിക്കാം
ഒരു ഫംഗ്‌ഷൻ കോൾ പോലെ പെരുമാറുന്ന ഒന്നിലേക്ക് തിരികെ ലിസ്റ്റ് ഓപ്പറേറ്റർ. പകരമായി,
സബ്‌റൂട്ടീനെ ഒരു അനാറി ഓപ്പറേറ്ററാക്കി മാറ്റാൻ നിങ്ങൾക്ക് "($)" പ്രോട്ടോടൈപ്പ് ഉപയോഗിക്കാം:

ഉപ മൈനേം ($);
$മീ = എന്റെ പേര് $0 || മരിക്കുക "എന്റെ പേര് ലഭിക്കില്ല";

അത് ഇപ്പോൾ നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് പോലെ പാഴ്‌സ് ചെയ്യുന്നു, പക്ഷേ നിങ്ങൾ ഇപ്പോഴും ഉപയോഗിക്കുന്നത് ശീലമാക്കേണ്ടതുണ്ട്
ആ സാഹചര്യത്തിൽ പരാൻതീസിസ്. പ്രോട്ടോടൈപ്പുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, perlsub കാണുക.

സബ്റൂട്ടീൻസ് ഡിക്ലറേഷനുകൾ "ആവശ്യമാണ്" എന്ന പ്രസ്താവനയോ അല്ലെങ്കിൽ രണ്ടും ലോഡ് ചെയ്യുകയോ ചെയ്യാം
കൂടാതെ "ഉപയോഗം" എന്ന പ്രസ്താവനയോടെ നിങ്ങളുടെ നെയിംസ്‌പെയ്‌സിലേക്ക് ഇമ്പോർട്ടുചെയ്‌തു. ഇതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് perlmod കാണുക.

ഒരു സ്റ്റേറ്റ്‌മെന്റ് സീക്വൻസിൽ ലെക്സിക്കലി-സ്കോപ്പ്ഡ് വേരിയബിളുകളുടെ ഡിക്ലറേഷനുകൾ അടങ്ങിയിരിക്കാം, പക്ഷേ വേറിട്ട്
ഒരു വേരിയബിൾ നാമം പ്രഖ്യാപിക്കുന്നതിൽ നിന്ന്, പ്രഖ്യാപനം ഒരു സാധാരണ പ്രസ്താവന പോലെ പ്രവർത്തിക്കുന്നു
ഒരു സാധാരണ പ്രസ്താവന പോലെയുള്ള പ്രസ്താവനകളുടെ ക്രമത്തിൽ വിശദീകരിച്ചു. അത്
യഥാർത്ഥത്തിൽ ഇതിന് കംപൈൽ-ടൈം, റൺ-ടൈം ഇഫക്റ്റുകൾ ഉണ്ട് എന്നാണ് അർത്ഥമാക്കുന്നത്.

അഭിപ്രായങ്ങള്
വരിയുടെ അവസാനം വരെ "#" പ്രതീകത്തിൽ നിന്നുള്ള വാചകം ഒരു അഭിപ്രായമാണ്, അത് അവഗണിക്കപ്പെടും.
ഒഴിവാക്കലുകളിൽ "#" ഒരു സ്‌ട്രിംഗിനുള്ളിലോ സാധാരണ എക്‌സ്‌പ്രഷനിലോ ഉൾപ്പെടുന്നു.

ലഘുവായ പ്രസ്താവനകൾ
ഒരേയൊരു ലളിതമായ പ്രസ്താവന അതിന്റെ പാർശ്വഫലങ്ങളെ വിലയിരുത്തിയ ഒരു പദപ്രയോഗമാണ്. ഓരോ
ലളിതമായ പ്രസ്താവന ഒരു അർദ്ധവിരാമം ഉപയോഗിച്ച് അവസാനിപ്പിക്കണം, അത് അവസാന പ്രസ്താവനയല്ലെങ്കിൽ
ഒരു ബ്ലോക്ക്, ഈ സാഹചര്യത്തിൽ അർദ്ധവിരാമം ഓപ്ഷണൽ ആണ്. എന്നാൽ എന്തായാലും അർദ്ധവിരാമം ഇടുക
ബ്ലോക്ക് ഒന്നിലധികം വരികൾ എടുക്കുന്നു, കാരണം നിങ്ങൾക്ക് ഒടുവിൽ മറ്റൊരു വരി ചേർക്കാം. അതല്ല
"eval {}", "sub {}", "do {}" എന്നിങ്ങനെയുള്ള ഓപ്പറേറ്റർമാരുണ്ട് നോക്കൂ സംയുക്തം പോലെ
പ്രസ്‌താവനകൾ, പക്ഷേ അതല്ല--അവ ഒരു പദപ്രയോഗത്തിലെ നിബന്ധനകൾ മാത്രമാണ്--അതിനാൽ ഒരു സ്പഷ്ടമായത് ആവശ്യമാണ്
ഒരു പ്രസ്താവനയിലെ അവസാന ഇനമായി ഉപയോഗിക്കുമ്പോൾ അവസാനിപ്പിക്കൽ.

സത്യം ഒപ്പം അസത്യം
നമ്പർ 0, സ്ട്രിംഗുകൾ '0', "", ശൂന്യമായ ലിസ്റ്റ് "()", "undef" എന്നിവയെല്ലാം a-ൽ തെറ്റാണ്
ബൂളിയൻ സന്ദർഭം. മറ്റെല്ലാ മൂല്യങ്ങളും ശരിയാണ്. ഒരു യഥാർത്ഥ മൂല്യത്തിന്റെ നിഷേധം "!" അല്ലെങ്കിൽ അല്ല"
ഒരു പ്രത്യേക തെറ്റായ മൂല്യം നൽകുന്നു. ഒരു സ്ട്രിംഗ് ആയി വിലയിരുത്തുമ്പോൾ അതിനെ "" ആയി കണക്കാക്കുന്നു, എന്നാൽ a ആയി
നമ്പർ, ഇത് 0 ആയി കണക്കാക്കുന്നു. ശരിയോ തെറ്റോ നൽകുന്ന മിക്ക Perl ഓപ്പറേറ്റർമാരും ഇത് പ്രവർത്തിക്കുന്നു
വഴി.

പ്രസ്താവന മോഡിഫയറുകൾ
ഏത് ലളിതമായ പ്രസ്താവനയും ഓപ്ഷണലായി പിന്തുടരാം സിംഗിൾ മോഡിഫയർ, തൊട്ടുമുമ്പ്
അർദ്ധവിരാമം അവസാനിപ്പിക്കുന്നു (അല്ലെങ്കിൽ ബ്ലോക്ക് അവസാനം). സാധ്യമായ മോഡിഫയറുകൾ ഇവയാണ്:

EXPR ആണെങ്കിൽ
EXPR അല്ലാതെ
EXPR ആയിരിക്കുമ്പോൾ
EXPR വരെ
ലിസ്റ്റിനായി
ലിസ്റ്റിൽ എത്തുക
EXPR ചെയ്യുമ്പോൾ

മോഡിഫയറിന് താഴെയുള്ള "EXPR" എന്നത് "അവസ്ഥ" എന്ന് വിളിക്കപ്പെടുന്നു. അതിന്റെ സത്യം അല്ലെങ്കിൽ
മോഡിഫയർ എങ്ങനെ പെരുമാറുമെന്ന് കള്ളം നിർണ്ണയിക്കുന്നു.

"if" ഒരിക്കൽ പ്രസ്താവന നടപ്പിലാക്കുന്നു if വ്യവസ്ഥ ശരിയാണെങ്കിൽ മാത്രം. "അല്ലാതെ" എന്നത്
വിപരീതമായി, അത് പ്രസ്താവന നടപ്പിലാക്കുന്നു അല്ലാതെ വ്യവസ്ഥ ശരിയാണ് (അതായത്, എങ്കിൽ
വ്യവസ്ഥ തെറ്റാണ്).

$ear >= 10 നീളമാണെങ്കിൽ "Basset hounds got long ear" എന്ന് പ്രിന്റ് ചെയ്യുക;
$is_raining അല്ലാതെ go_outside() and play();

"ഫോർ(ഓരോ)" മോഡിഫയർ ഒരു ആവർത്തനമാണ്: ഇത് ഓരോ ഇനത്തിനും ഒരിക്കൽ പ്രസ്താവന നടപ്പിലാക്കുന്നു.
ലിസ്റ്റ് (ഓരോ ഇനത്തിനും $_ എന്ന അപരനാമത്തിൽ).

qw (ലോക ഡോളി നഴ്‌സ്) എന്നതിന് "ഹലോ $_!\n" എന്ന് പ്രിന്റ് ചെയ്യുക;

"അതേസമയം" പ്രസ്താവന ആവർത്തിക്കുന്നു സമയത്ത് വ്യവസ്ഥ സത്യമാണ്. "വരെ" വിപരീതമായി പ്രവർത്തിക്കുന്നു, അത്
പ്രസ്താവന ആവർത്തിക്കുന്നു വരുവോളം വ്യവസ്ഥ ശരിയാണ് (അല്ലെങ്കിൽ വ്യവസ്ഥ തെറ്റാണെങ്കിൽ):

# ഇവ രണ്ടും 0 മുതൽ 10 വരെ കണക്കാക്കുന്നു.
$i ++ പ്രിന്റ് ചെയ്യുമ്പോൾ $i <= 10;
$j > 10 വരെ $j++ പ്രിന്റ് ചെയ്യുക;

"വേൽ", "അതുവരെ" മോഡിഫയറുകൾക്ക് സാധാരണ ""വെയിൽ" ലൂപ്പ്" സെമാന്റിക്സ് ഉണ്ട് (സോപാധികം
ആദ്യം വിലയിരുത്തിയത്), "do"-BLOCK-ലേക്ക് (അല്ലെങ്കിൽ Perl4 "do"-SUBROUTINE-ലേക്ക് പ്രയോഗിക്കുമ്പോൾ ഒഴികെ
പ്രസ്താവന), ഈ സാഹചര്യത്തിൽ, സോപാധിക മൂല്യനിർണ്ണയം നടത്തുന്നതിന് മുമ്പ് ബ്ലോക്ക് ഒരിക്കൽ നിർവ്വഹിക്കുന്നു.

നിങ്ങൾക്ക് ഇതുപോലുള്ള ലൂപ്പുകൾ എഴുതാൻ കഴിയും:

ചെയ്യുക {
$ലൈൻ = ;
...
!നിർവചിക്കപ്പെട്ടത്($ലൈൻ) || $line eq ".\n"

perlfunc-ൽ "do" കാണുക. പിന്നീട് വിവരിച്ചിരിക്കുന്ന ലൂപ്പ് കൺട്രോൾ സ്റ്റേറ്റ്‌മെന്റുകൾ ചെയ്യും എന്നതും ശ്രദ്ധിക്കുക ചെയ്യില്ല
ഈ നിർമ്മാണത്തിൽ പ്രവർത്തിക്കുക, കാരണം മോഡിഫയറുകൾ ലൂപ്പ് ലേബലുകൾ എടുക്കുന്നില്ല. ക്ഷമിക്കണം. നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും കഴിയും
അതിനുള്ളിൽ മറ്റൊരു ബ്ലോക്ക് ഇടുക ("അടുത്തത്" എന്നതിന്) അല്ലെങ്കിൽ അതിന് ചുറ്റും ("അവസാനത്തിന്") അങ്ങനെ ചെയ്യുക
കാര്യം. "അടുത്തത്" എന്നതിന്, ബ്രേസുകൾ ഇരട്ടിയാക്കിയാൽ മതി:

ചെയ്യുക {{
അടുത്തത് $x == $y ആണെങ്കിൽ;
# ഇവിടെ എന്തെങ്കിലും ചെയ്യൂ
}} $x++ > $z വരെ;

"അവസാനം" എന്നതിന്, നിങ്ങൾ കൂടുതൽ വിശദമായി പറയേണ്ടതുണ്ട്:

ലൂപ്പ്: {
ചെയ്യുക {
$x = $y**2 ആണെങ്കിൽ അവസാനമായി;
# ഇവിടെ എന്തെങ്കിലും ചെയ്യൂ
} അതേസമയം $x++ <= $z;
}

ശ്രദ്ധിക്കുക: ഒരു സ്റ്റേറ്റ്മെന്റ് മോഡിഫയർ ഉപയോഗിച്ച് പരിഷ്കരിച്ച "എന്റെ", "സ്റ്റേറ്റ്" അല്ലെങ്കിൽ "ഞങ്ങളുടെ" സ്വഭാവം
സോപാധിക അല്ലെങ്കിൽ ലൂപ്പ് നിർമ്മാണം (ഉദാഹരണത്തിന്, "my $x if ...") ആണ് വ്യക്തമല്ല. ന്റെ മൂല്യം
"my" വേരിയബിൾ "undef" ആയിരിക്കാം, മുമ്പ് നിയുക്തമാക്കിയ ഏതെങ്കിലും മൂല്യം അല്ലെങ്കിൽ ഒരുപക്ഷേ മറ്റെന്തെങ്കിലും
വേറെ. അതിൽ ആശ്രയിക്കരുത്. perl-ന്റെ ഭാവി പതിപ്പുകൾ ഇതിൽ നിന്ന് വ്യത്യസ്തമായ എന്തെങ്കിലും ചെയ്തേക്കാം
perl-ന്റെ പതിപ്പ് നിങ്ങൾ പരീക്ഷിച്ചുനോക്കൂ. ഇതാ ഡ്രാഗണുകൾ.

Perl 5.14-ൽ ആദ്യമായി പ്രത്യക്ഷപ്പെട്ട ഒരു പരീക്ഷണാത്മക സവിശേഷതയാണ് "എപ്പോൾ" മോഡിഫയർ. ഉപയോഗിക്കാൻ
അതിൽ, നിങ്ങൾ "ഉപയോഗ v5.14" പ്രഖ്യാപനം ഉൾപ്പെടുത്തണം. (സാങ്കേതികമായി, ഇതിന് മാത്രമേ ആവശ്യമുള്ളൂ
"സ്വിച്ച്" ഫീച്ചർ, എന്നാൽ അതിന്റെ ആ വശം 5.14-ന് മുമ്പ് ലഭ്യമായിരുന്നില്ല.) ഓപ്പറേറ്റീവ് മാത്രം
ഒരു "ഫോറച്ച്" ലൂപ്പിൽ നിന്നോ "നൽകിയിരിക്കുന്ന" ബ്ലോക്കിൽ നിന്നോ, അത് പ്രസ്താവന നടപ്പിലാക്കുകയാണെങ്കിൽ മാത്രം
സ്മാർട്ട് മാച്ച് "$_ ~~ എക്സ്പിആർ" സത്യമാണ്. പ്രസ്‌താവന നിർവ്വഹിക്കുകയാണെങ്കിൽ, അതിന് ശേഷം "അടുത്തത്"
ഒരു "ഫോറച്ച്" ഉള്ളിൽ നിന്നും "നൽകിയ" ഉള്ളിൽ നിന്ന് "ബ്രേക്ക്".

നിലവിലെ നടപ്പാക്കലിന് കീഴിൽ, "എപ്പോൾ" എന്നതിൽ എവിടെയും "ഫോറച്ച്" ലൂപ്പ് ആകാം
മോഡിഫയറിന്റെ ഡൈനാമിക് സ്കോപ്പ്, എന്നാൽ "നൽകിയ" ബ്ലോക്കിന്റെ ലെക്സിക്കൽ സ്കോപ്പിനുള്ളിൽ ആയിരിക്കണം. ഈ
ഭാവിയിലെ റിലീസിൽ നിയന്ത്രിതമായ ഇളവുകൾ ഉണ്ടായേക്കാം. താഴെയുള്ള "പ്രസ്താവനകൾ മാറുക" കാണുക.

കോമ്പൗണ്ട് പ്രസ്താവനകൾ
പേളിൽ, ഒരു സ്കോപ്പ് നിർവചിക്കുന്ന പ്രസ്താവനകളുടെ ഒരു ശ്രേണിയെ ഒരു ബ്ലോക്ക് എന്ന് വിളിക്കുന്നു. ചിലപ്പോൾ എ
ബ്ലോക്ക് അത് അടങ്ങിയിരിക്കുന്ന ഫയലിൽ നിന്ന് വേർതിരിച്ചിരിക്കുന്നു (ആവശ്യമായ ഫയലിന്റെ കാര്യത്തിൽ, അല്ലെങ്കിൽ
പ്രോഗ്രാം മൊത്തത്തിൽ), ചിലപ്പോൾ ഒരു ബ്ലോക്ക് ഒരു സ്ട്രിംഗിന്റെ പരിധിയിൽ നിന്ന് വേർതിരിച്ചിരിക്കുന്നു (ഇൽ
ഒരു എവൽ കേസ്).

എന്നാൽ സാധാരണയായി, ഒരു ബ്ലോക്കിനെ ചുരുണ്ട ബ്രാക്കറ്റുകളാൽ വേർതിരിച്ചിരിക്കുന്നു, ഇത് ബ്രേസുകൾ എന്നും അറിയപ്പെടുന്നു. ഞങ്ങൾ വിളിക്കും
ഈ വാക്യഘടന ഒരു ബ്ലോക്ക് നിർമ്മിക്കുന്നു.

ഒഴുക്ക് നിയന്ത്രിക്കാൻ ഇനിപ്പറയുന്ന സംയുക്ത പ്രസ്താവനകൾ ഉപയോഗിക്കാം:

എങ്കിൽ (എക്സ്പിആർ) തടയുക
എങ്കിൽ (എക്‌സ്‌പിആർ) തടയുക, മറ്റുള്ളവ തടയുക
എങ്കിൽ (എക്സ്പിആർ) ബ്ലോക്ക് എൽസിഫ് (എക്സ്പിആർ) ബ്ലോക്ക് ...
എങ്കിൽ (എക്‌സ്‌പിആർ) എൽസിഫ് (എക്‌സ്‌പിആർ) ബ്ലോക്ക് ചെയ്യുക ... അല്ലെങ്കിൽ ബ്ലോക്ക് ചെയ്യുക

(എക്സ്പിആർ) തടയുന്നില്ലെങ്കിൽ
(എക്‌സ്‌പിആർ) തടയുന്നില്ലെങ്കിൽ, തടയുക
(എക്‌സ്‌പിആർ) എൽസിഫ് (എക്‌സ്‌പിആർ) ബ്ലോക്ക് ചെയ്‌തില്ലെങ്കിൽ ...
(എക്‌സ്‌പിആർ) എൽസിഫ് (എക്‌സ്‌പിആർ) ബ്ലോക്ക് ചെയ്‌തില്ലെങ്കിൽ ... അല്ലെങ്കിൽ തടയുക

നൽകിയിരിക്കുന്നത് (എക്സ്പിആർ) ബ്ലോക്ക്

(എക്സ്പിആർ) തടയുമ്പോൾ ലേബൽ
LABEL അതേസമയം (EXPR) BLOCK BLOCK തുടരുക

(എക്‌സ്‌പിആർ) തടയുന്നത് വരെ ലേബൽ
(EXPR) BLOCK വരെ LABEL BLOCK തുടരുക

(EXPR; EXPR; EXPR) BLOCK എന്നതിനായുള്ള LABEL
VAR (LIST) BLOCK നുള്ള ലേബൽ
VAR (LIST) BLOCK നുള്ള LABEL BLOCK തുടരുക

LABEL foreach (EXPR; EXPR; EXPR) ബ്ലോക്ക്
VAR (ലിസ്റ്റ്) തടയാൻ ലേബൽ
LABEL foreach VAR (LIST) BLOCK BLOCK തുടരുക

ലേബൽ ബ്ലോക്ക്
LABEL BLOCK BLOCK തുടരുക

ഫേസ് ബ്ലോക്ക്

പരീക്ഷണാത്മക "നൽകിയ" പ്രസ്താവനയാണ് അല്ല ഓട്ടോമാറ്റിയ്ക്കായി പ്രാപ്തമാക്കി; "പ്രസ്താവനകൾ മാറുക" കാണുക
അത് എങ്ങനെ ചെയ്യണമെന്ന് ചുവടെയുണ്ട്, കൂടാതെ അറ്റൻഡർ മുന്നറിയിപ്പ് നൽകുന്നു.

C, Pascal എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി, പേളിൽ ഇവയെല്ലാം നിർവചിച്ചിരിക്കുന്നത് BLOCK-കളുടെ അടിസ്ഥാനത്തിലാണ്, പ്രസ്താവനകളല്ല.
ചുരുണ്ട ബ്രാക്കറ്റുകൾ എന്നാണ് ഇതിനർത്ഥം ആവശ്യമാണ്--തൂങ്ങിക്കിടക്കുന്ന പ്രസ്താവനകൾ അനുവദനീയമല്ല. നിങ്ങൾ എങ്കിൽ
ചുരുണ്ട ബ്രാക്കറ്റുകളില്ലാതെ സോപാധികമായി എഴുതാൻ ആഗ്രഹിക്കുന്നു, അത് ചെയ്യാൻ മറ്റ് നിരവധി മാർഗങ്ങളുണ്ട്.
ഇനിപ്പറയുന്നവയെല്ലാം ഒരേ കാര്യം ചെയ്യുന്നു:

എങ്കിൽ (!തുറക്കുക(FOO)) { മരിക്കുക "$FOO തുറക്കാൻ കഴിയില്ല: $!" }
മരിക്കുക "$FOO: $ തുറക്കാൻ കഴിയില്ല!" തുറന്നില്ലെങ്കിൽ (FOO);
തുറക്കുക(FOO) || മരിക്കുക "$FOO: $ തുറക്കാൻ കഴിയില്ല!";
തുറക്കുക (FOO) ? () : മരിക്കുക "$FOO: $ തുറക്കാൻ കഴിയില്ല!";
# അൽപ്പം വിചിത്രമായത്, അവസാനത്തേത്

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

എക്‌സ്‌പ്രഷൻ സത്യമായിരിക്കുന്നിടത്തോളം "വേൽ" സ്റ്റേറ്റ്‌മെന്റ് ബ്ലോക്ക് എക്‌സിക്യൂട്ട് ചെയ്യുന്നു. "വരെ"
എക്‌സ്‌പ്രഷൻ തെറ്റായിരിക്കുന്നിടത്തോളം സ്റ്റേറ്റ്‌മെന്റ് ബ്ലോക്ക് എക്‌സിക്യൂട്ട് ചെയ്യുന്നു. LABEL ഓപ്ഷണൽ ആണ്,
ഉണ്ടെങ്കിൽ, ഒരു ഐഡന്റിഫയറും തുടർന്ന് കോളണും അടങ്ങിയിരിക്കുന്നു. LABEL തിരിച്ചറിയുന്നു
"അടുത്തത്", "അവസാനം", "വീണ്ടും ചെയ്യുക" എന്നീ ലൂപ്പ് നിയന്ത്രണ പ്രസ്താവനകൾക്കായുള്ള ലൂപ്പ്. LABEL ഒഴിവാക്കിയാൽ,
ലൂപ്പ് കൺട്രോൾ സ്റ്റേറ്റ്‌മെന്റ് ഏറ്റവും ഉള്ളിലുള്ള ലൂപ്പിനെ സൂചിപ്പിക്കുന്നു. ഇതിൽ ഉൾപ്പെട്ടേക്കാം
LABEL കണ്ടെത്തുന്നതിന് റൺ ടൈമിൽ നിങ്ങളുടെ കോൾ-സ്റ്റാക്ക് ചലനാത്മകമായി നോക്കുന്നു. അത്ര നിരാശ
നിങ്ങൾ "ഉപയോഗ മുന്നറിയിപ്പ്" പ്രാഗ്മ അല്ലെങ്കിൽ ദി ഉപയോഗിക്കുകയാണെങ്കിൽ പെരുമാറ്റം ഒരു മുന്നറിയിപ്പ് ട്രിഗർ ചെയ്യുന്നു -w ഫ്ലാഗ്.

ഒരു "തുടരുക" ബ്ലോക്ക് ഉണ്ടെങ്കിൽ, സോപാധികമായതിന് തൊട്ടുമുമ്പ് അത് എല്ലായ്പ്പോഴും നടപ്പിലാക്കും.
വീണ്ടും വിലയിരുത്തണം. അങ്ങനെ ചെയ്യുമ്പോൾ പോലും, ഒരു ലൂപ്പ് വേരിയബിൾ വർദ്ധിപ്പിക്കാൻ ഇത് ഉപയോഗിക്കാം
"അടുത്ത" പ്രസ്താവനയിലൂടെ ലൂപ്പ് തുടർന്നു.

"BEGIN", "END", "INIT" പോലുള്ള ഒരു കംപൈലേഷൻ ഫേസ് കീവേഡിന് മുമ്പായി ഒരു ബ്ലോക്ക് വരുമ്പോൾ
"പരിശോധിക്കുക", അല്ലെങ്കിൽ "UNITCHECK", തുടർന്ന് ബ്ലോക്ക് പ്രവർത്തിക്കുന്നത് അനുബന്ധ ഘട്ടത്തിൽ മാത്രം
വധശിക്ഷ. കൂടുതൽ വിവരങ്ങൾക്ക് perlmod കാണുക.

പുതിയ തരത്തിലുള്ള സംയുക്തങ്ങൾ നിർവചിക്കുന്നതിനായി എക്സ്റ്റൻഷൻ മൊഡ്യൂളുകൾക്ക് പേൾ പാർസറിലേക്ക് ഹുക്ക് ചെയ്യാനും കഴിയും
പ്രസ്താവനകൾ. വിപുലീകരണം തിരിച്ചറിയുന്ന ഒരു കീവേഡ് ഉപയോഗിച്ചാണ് ഇവ അവതരിപ്പിക്കുന്നത്
കീവേഡിന് ശേഷമുള്ള വാക്യഘടന പൂർണ്ണമായും വിപുലീകരണത്താൽ നിർവചിക്കപ്പെടുന്നു. നിങ്ങൾ ഒരു ആണെങ്കിൽ
നടപ്പിലാക്കുന്നയാൾ, മെക്കാനിസത്തിനായി പെർലാപിയിലെ "PL_keyword_plugin" കാണുക. നിങ്ങൾ അങ്ങനെയാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ
ഒരു മൊഡ്യൂൾ, അത് നിർവചിക്കുന്ന വാക്യഘടനയുടെ വിശദാംശങ്ങൾക്കായി മൊഡ്യൂളിന്റെ ഡോക്യുമെന്റേഷൻ കാണുക.

ലൂപ്പ് നിയന്ത്രണ
"അടുത്ത" കമാൻഡ് ലൂപ്പിന്റെ അടുത്ത ആവർത്തനം ആരംഭിക്കുന്നു:

ലൈൻ: സമയത്ത് ( ) {
അടുത്ത LINE എങ്കിൽ /^#/; # അഭിപ്രായങ്ങൾ നിരസിക്കുക
...
}

"അവസാന" കമാൻഡ് സംശയാസ്പദമായ ലൂപ്പിൽ നിന്ന് ഉടൻ പുറത്തുകടക്കുന്നു. "തുടരുക" ബ്ലോക്ക്, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ,
നടപ്പിലാക്കിയിട്ടില്ല:

ലൈൻ: സമയത്ത് ( ) {
അവസാന വരി /^$/ എങ്കിൽ; ഹെഡ്ഡർ ഉപയോഗിച്ച് പൂർത്തിയാക്കുമ്പോൾ # പുറത്തുകടക്കുക
...
}

"redo" കമാൻഡ് വീണ്ടും സോപാധിക മൂല്യനിർണ്ണയം നടത്താതെ ലൂപ്പ് ബ്ലോക്ക് പുനരാരംഭിക്കുന്നു. ദി
എന്തെങ്കിലും ഉണ്ടെങ്കിൽ "തുടരുക" തടയുക അല്ല വധിച്ചു. ഈ കമാൻഡ് സാധാരണയായി പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുന്നു
ഇൻപുട്ട് ചെയ്തതിനെക്കുറിച്ച് സ്വയം കള്ളം പറയാൻ ആഗ്രഹിക്കുന്നു.

ഉദാഹരണത്തിന്, ഒരു ഫയൽ പ്രോസസ്സ് ചെയ്യുമ്പോൾ /etc/termcap. നിങ്ങളുടെ ഇൻപുട്ട് ലൈനുകൾ അവസാനിക്കുകയാണെങ്കിൽ
തുടർച്ചയെ സൂചിപ്പിക്കാൻ ബാക്ക്‌സ്ലാഷുകൾ, നിങ്ങൾ മുന്നോട്ട് പോയി അടുത്ത റെക്കോർഡ് നേടണം.

അതേസമയം (<>) {
ചോമ്പ്;
എങ്കിൽ (s/\\$//) {
$_ .= <>;
eof() ഒഴികെ വീണ്ടും ചെയ്യുക;
}
# ഇപ്പോൾ പ്രോസസ്സ് ചെയ്യുക $_
}

കൂടുതൽ വ്യക്തമായി എഴുതിയ പതിപ്പിനുള്ള പേൾ ചുരുക്കെഴുത്താണ്:

വരി: അതേസമയം (നിർവചിച്ചിരിക്കുന്നത്($ലൈൻ = )) {
ചോമ്പ് ($ ലൈൻ);
എങ്കിൽ ($ലൈൻ =~ സെ/\\$//) {
$ലൈൻ .= ;
eof() അല്ലാതെ LINE വീണ്ടും ചെയ്യുക; # eof (ARGV) അല്ല!
}
# ഇപ്പോൾ $line പ്രോസസ്സ് ചെയ്യുക
}

മുകളിലെ കോഡിൽ ഒരു "തുടരുക" ബ്ലോക്ക് ഉണ്ടെങ്കിൽ, അത് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുമെന്ന് ശ്രദ്ധിക്കുക
റീജക്‌സ് നിരസിച്ച വരികളിൽ (റെഡോ തുടരുന്ന ബ്ലോക്ക് ഒഴിവാക്കുന്നതിനാൽ). ഒരു തുടർച്ചയായ ബ്ലോക്ക്
ലൈൻ കൗണ്ടറുകൾ പുനഃസജ്ജമാക്കാൻ അല്ലെങ്കിൽ "m?pat?" ഒറ്റത്തവണ മത്സരങ്ങൾ:

# പ്രചോദനം :1,$g/fred/s//WILMA/
അതേസമയം (<>) {
m?(ഫ്രെഡ്)? && s//WILMA $1 WILMA/;
m?(ബാർണി)? && s//BETTY $1 BETTY/;
m?(ഹോമർ)? && s//MARGE $1 MARGE/;
} തുടരുക {
പ്രിന്റ് "$ARGV $.: $_";
eof ആണെങ്കിൽ ARGV അടയ്ക്കുക; # റീസെറ്റ് $.
eof എങ്കിൽ പുനഃസജ്ജമാക്കുക; # റീസെറ്റ് ?പാറ്റ്?
}

"വേൽ" എന്ന വാക്കിന് പകരം "വരെ" എന്ന വാക്ക് വന്നാൽ, പരീക്ഷയുടെ അർത്ഥം വിപരീതമാണ്.
എന്നാൽ ആദ്യ ആവർത്തനത്തിന് മുമ്പ് സോപാധികം ഇപ്പോഴും പരീക്ഷിക്കപ്പെടുന്നു.

ലൂപ്പ് കൺട്രോൾ സ്റ്റേറ്റ്‌മെന്റുകൾ "if" അല്ലെങ്കിൽ "അല്ലാതെ" പ്രവർത്തിക്കില്ല, കാരണം അവ ലൂപ്പുകളല്ല. നിങ്ങൾ
എന്നിരുന്നാലും, അവയെ അത്തരത്തിലുള്ളതാക്കാൻ ബ്രേസുകൾ ഇരട്ടിയാക്കാനാകും.

എങ്കിൽ (/പാറ്റേൺ/) {{
അവസാനമെങ്കിൽ /ഫ്രെഡ്/;
അടുത്തത് /barney/; # "അവസാനം" എന്നതിന് സമാനമായ പ്രഭാവം,
# എന്നാൽ അതുപോലെ രേഖപ്പെടുത്തുന്നില്ല
# ഇവിടെ എന്തെങ്കിലും ചെയ്യൂ
}}

ഒരു ബ്ലോക്ക് ഒരു തവണ എക്സിക്യൂട്ട് ചെയ്യുന്ന ഒരു ലൂപ്പായി പ്രവർത്തിക്കുന്നു എന്നതാണ് ഇതിന് കാരണം, കാണുക
"അടിസ്ഥാന ബ്ലോക്കുകൾ".

Perl 4-ൽ ലഭ്യമായ "അപ്പോൾ/ഇഫ് BLOCK BLOCK" എന്ന ഫോം ഇനി ലഭ്യമല്ല. മാറ്റിസ്ഥാപിക്കുക
"ഇഫ് (ബ്ലോക്ക് ചെയ്യുക)" എന്നതിലൂടെ "ബ്ലോക്ക് ചെയ്താൽ" എന്നതിന്റെ ഏതെങ്കിലും സംഭവം.

വേണ്ടി ലൂപ്പുകൾ
Perl's C-style "for" ലൂപ്പ് അനുബന്ധ "while" ലൂപ്പ് പോലെ പ്രവർത്തിക്കുന്നു; അതിനർത്ഥം ഇത്:

($i = 1; $i <10; $i++) {
...
}

ഇതുതന്നെയാണ്:

$i = 1;
അതേസമയം ($i < 10) {
...
} തുടരുക {
$ ഞാൻ ++;
}

ഒരു ചെറിയ വ്യത്യാസമുണ്ട്: ഇനീഷ്യലൈസേഷനിൽ വേരിയബിളുകൾ "my" എന്ന് പ്രഖ്യാപിച്ചാൽ
"ഫോർ" എന്ന വിഭാഗത്തിൽ, ആ വേരിയബിളുകളുടെ ലെക്സിക്കൽ സ്കോപ്പ് കൃത്യമായി "ഫോർ" ലൂപ്പാണ് (ദി
ലൂപ്പിന്റെയും നിയന്ത്രണ വിഭാഗങ്ങളുടെയും ബോഡി).

ഒരു പ്രത്യേക സന്ദർഭമെന്ന നിലയിൽ, "ഫോർ" ലൂപ്പിലെ (അല്ലെങ്കിൽ അനുബന്ധ "വെയിൽ" ലൂപ്പിലെ ടെസ്റ്റ് ആണെങ്കിൽ
ശൂന്യമാണ്, അത് സത്യമായി കണക്കാക്കുന്നു. അതായത് രണ്ടും

വേണ്ടി (;;) {
...
}

ഒപ്പം

അതേസമയം () {
...
}

അനന്തമായ ലൂപ്പുകളായി കണക്കാക്കുന്നു.

സാധാരണ അറേ ഇൻഡക്സ് ലൂപ്പിംഗിന് പുറമെ, "ഫോർ" എന്നതിന് മറ്റ് പല രസകരമായ കാര്യങ്ങൾക്കും കടം കൊടുക്കാൻ കഴിയും
അപേക്ഷകൾ. നിങ്ങൾ വ്യക്തമായി പരീക്ഷിച്ചാൽ നിങ്ങൾ നേരിടുന്ന പ്രശ്‌നം ഒഴിവാക്കുന്ന ഒന്ന് ഇതാ
ഒരു ഇന്ററാക്റ്റീവ് ഫയൽ ഡിസ്ക്രിപ്റ്ററിലെ ഫയലിന്റെ എൻഡ്-ഓഫ്-ഫയൽ നിങ്ങളുടെ പ്രോഗ്രാം ഹാംഗ് ആയി കാണപ്പെടുന്നു.

$on_a_tty = -t STDIN && -t STDOUT;
സബ് പ്രോംപ്റ്റ് { പ്രിന്റ് "അതെ?" എങ്കിൽ $on_a_tty }
(പ്രോംപ്റ്റ്(); ; പ്രോംപ്റ്റ്() ) {
# എന്തെങ്കിലും ചെയ്യൂ
}

"റെഡ്‌ലൈൻ" (അല്ലെങ്കിൽ ഓപ്പറേറ്റർ ഫോം, " ") ഒരു "ഫോർ" ലൂപ്പിന്റെ സോപാധികം
ഇനിപ്പറയുന്നവയുടെ ചുരുക്കെഴുത്ത്. ഈ സ്വഭാവം ഒരു "വേള" ലൂപ്പ് സോപാധികമാണ്.

ഇതിനായി (പ്രോംപ്റ്റ്(); നിർവചിച്ച ($_ = ); പ്രോംപ്റ്റ്() ) {
# എന്തെങ്കിലും ചെയ്യൂ
}

ഫോറെച്ച് ലൂപ്പുകൾ
"ഫോറച്ച്" ലൂപ്പ് ഒരു സാധാരണ ലിസ്റ്റ് മൂല്യത്തിന് മുകളിൽ ആവർത്തിക്കുകയും സ്കെയിലർ വേരിയബിൾ VAR-നെ സജ്ജമാക്കുകയും ചെയ്യുന്നു
പട്ടികയിലെ ഓരോ ഘടകങ്ങളും ക്രമത്തിൽ ആകുക. വേരിയബിളിന് മുമ്പായി "my" എന്ന കീവേഡ് ഉണ്ടെങ്കിൽ,
പിന്നീട് അത് ലെക്സിക്കലി സ്കോപ്പ് ചെയ്യപ്പെടുന്നു, അതിനാൽ ലൂപ്പിനുള്ളിൽ മാത്രമേ അത് ദൃശ്യമാകൂ. അല്ലെങ്കിൽ,
വേരിയബിൾ ലൂപ്പിലേക്ക് പരോക്ഷമായി ലോക്കൽ ആണ് കൂടാതെ പുറത്തുകടക്കുമ്പോൾ അതിന്റെ പഴയ മൂല്യം വീണ്ടെടുക്കുന്നു
ലൂപ്പ്. വേരിയബിൾ മുമ്പ് "my" ഉപയോഗിച്ചാണ് പ്രഖ്യാപിച്ചതെങ്കിൽ, പകരം ആ വേരിയബിൾ ഉപയോഗിക്കുന്നു
ആഗോളമായത്, പക്ഷേ അത് ഇപ്പോഴും ലൂപ്പിലേക്ക് പ്രാദേശികവൽക്കരിച്ചിരിക്കുന്നു. ഈ പരോക്ഷമായ പ്രാദേശികവൽക്കരണം സംഭവിക്കുന്നു
മാത്രം ഒരു "ഫോർച്ച്" ലൂപ്പിൽ.

"foreach" കീവേഡ് യഥാർത്ഥത്തിൽ "for" കീവേഡിന്റെ പര്യായമാണ്, അതിനാൽ നിങ്ങൾക്ക് ഒന്നുകിൽ ഉപയോഗിക്കാം.
VAR ഒഴിവാക്കിയാൽ, ഓരോ മൂല്യത്തിലും $_ സജ്ജീകരിക്കും.

LIST-ന്റെ ഏതെങ്കിലും ഘടകം ഒരു മൂല്യമാണെങ്കിൽ, ലൂപ്പിനുള്ളിലെ VAR പരിഷ്‌ക്കരിച്ച് നിങ്ങൾക്ക് അത് പരിഷ്‌ക്കരിക്കാനാകും.
നേരെമറിച്ച്, ലിസ്‌റ്റിന്റെ ഏതെങ്കിലും ഘടകം ഒരു മൂല്യമല്ലെങ്കിൽ, ആ ഘടകം പരിഷ്‌ക്കരിക്കുന്നതിനുള്ള ഏതൊരു ശ്രമവും
പരാജയപ്പെടും. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, "ഫോറച്ച്" ലൂപ്പ് ഇൻഡക്സ് വേരിയബിൾ ഒരു അപരനാമമാണ്
നിങ്ങൾ ലൂപ്പ് ചെയ്യുന്ന ലിസ്റ്റിലെ ഓരോ ഇനവും.

LIST-ന്റെ ഏതെങ്കിലും ഭാഗം ഒരു അറേ ആണെങ്കിൽ, നിങ്ങൾ ചേർക്കുകയോ നീക്കം ചെയ്യുകയോ ചെയ്താൽ "foreach" വളരെ ആശയക്കുഴപ്പത്തിലാകും.
ലൂപ്പ് ബോഡിക്കുള്ളിലെ ഘടകങ്ങൾ, ഉദാഹരണത്തിന് "സ്പ്ലൈസ്". അതുകൊണ്ട് അത് ചെയ്യരുത്.

VAR ഒരു ടൈഡ് അല്ലെങ്കിൽ മറ്റ് പ്രത്യേക വേരിയബിൾ ആണെങ്കിൽ "foreach" ഒരുപക്ഷേ നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് ചെയ്യില്ല.
അതും ചെയ്യരുത്.

Perl 5.22 മുതൽ, ഈ ലൂപ്പിന് ഒരു വേരിയബിൾ സ്വീകരിക്കുന്ന ഒരു പരീക്ഷണ വേരിയന്റ് ഉണ്ട്.
VAR-നുള്ള ഒരു ബാക്ക്സ്ലാഷ് മുമ്പ്, ഈ സാഹചര്യത്തിൽ ലിസ്റ്റിലെ ഇനങ്ങൾ റഫറൻസുകളായിരിക്കണം.
ബാക്ക്‌സ്ലാഷ് ചെയ്ത വേരിയബിൾ ലിസ്റ്റിലെ ഓരോ റഫറൻസ് ഇനത്തിനും ഒരു അപരനാമമായി മാറും
ശരിയായ തരത്തിലുള്ളതായിരിക്കണം. ഈ സാഹചര്യത്തിൽ വേരിയബിൾ ഒരു സ്കെയിലർ ആയിരിക്കണമെന്നില്ല, കൂടാതെ
ബാക്ക്‌സ്ലാഷിനെ തുടർന്ന് "എന്റെ" ആയിരിക്കാം. ഈ ഫോം ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ "refaliasing" പ്രവർത്തനക്ഷമമാക്കണം
"ഉപയോഗ ഫീച്ചർ" വഴിയുള്ള ഫീച്ചർ. (സവിശേഷത കാണുക. perlref-ൽ "റഫറൻസുകളിലേക്ക് അസൈൻ ചെയ്യൽ" എന്നതും കാണുക.)

ഉദാഹരണങ്ങൾ:

(@ary) {s/foo/bar/} എന്നതിനായി

എന്റെ $elem (@elements) {
$elem *= 2;
}

$count (റിവേഴ്സ്(1..10), "BOOM") {
പ്രിന്റ് $count, "\n";
ഉറക്കം(1);
}

(1..15) { പ്രിന്റ് "മെറി ക്രിസ്തുമസ്\n"; }

$item (വിഭജനം(/:[\\\n:]*/, $ENV{TERMCAP})
പ്രിന്റ് "ഇനം: $item\n";
}

"refaliasing" എന്ന സവിശേഷത ഉപയോഗിക്കുക;
മുന്നറിയിപ്പുകളൊന്നുമില്ല "പരീക്ഷണാത്മകം::refaliasing";
ഫോറെച്ച് \my %hash (@array_of_hash_references) {
# ഓരോ %ഹാഷിലും എന്തെങ്കിലും ചെയ്യുക
}

ഒരു സി പ്രോഗ്രാമർ പേളിൽ ഒരു പ്രത്യേക അൽഗോരിതം കോഡ് അപ്പ് ചെയ്യുന്നതെങ്ങനെയെന്നത് ഇതാ:

(എന്റെ $i = 0; $i < @ary1; $i++) {
(എന്റെ $j = 0; $j < @ary2; $j++) {
എങ്കിൽ ($ary1[$i] > $ary2[$j]) {
അവസാനത്തെ; # പുറത്തേക്ക് പോകാൻ കഴിയില്ല :-(
}
$ary1[$i] += $ary2[$j];
}
# ഇവിടെയാണ് എന്നെ അവസാനമായി കൊണ്ടുപോകുന്നത്
}

അതേസമയം, ഭാഷാശൈലിയിൽ കൂടുതൽ സൗകര്യപ്രദമായ ഒരു പേൾ പ്രോഗ്രാമർ അത് എങ്ങനെ ചെയ്യുമെന്നത് ഇതാ:

പുറം: എന്റെ $wid (@ary1) {
അകം: എന്റെ $ജെറ്റിന് (@ary2) {
$wid > $jet ആണെങ്കിൽ അടുത്ത OUTER;
$wid += $jet;
}
}

ഇത് എത്ര എളുപ്പമാണെന്ന് നോക്കൂ? ഇത് വൃത്തിയുള്ളതും സുരക്ഷിതവും വേഗതയേറിയതുമാണ്. ഇത് കൂടുതൽ വൃത്തിയുള്ളതാണ്, കാരണം അത്
ശബ്ദം കുറവ്. ഇത് സുരക്ഷിതമാണ്, കാരണം ആന്തരികവും ബാഹ്യവുമായ ലൂപ്പുകൾക്കിടയിൽ കോഡ് പിന്നീട് ചേർത്താൽ
ഓൺ, പുതിയ കോഡ് ആകസ്മികമായി എക്സിക്യൂട്ട് ചെയ്യില്ല. "അടുത്തത്" മറ്റൊന്ന് വ്യക്തമായി ആവർത്തിക്കുന്നു
കേവലം ഉള്ളിലുള്ളത് അവസാനിപ്പിക്കുന്നതിനുപകരം ലൂപ്പ്. പേൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനാൽ ഇത് വേഗതയേറിയതാണ്
തത്തുല്യമായ "ഫോർ" ലൂപ്പിനെക്കാൾ വേഗത്തിൽ ഒരു "ഫോറച്ച്" പ്രസ്താവന.

"ഫോർ" ലൂപ്പിന് ഒരു റിട്ടേൺ മൂല്യമുണ്ടെന്ന് പെർസെപ്റ്റീവ് പേൾ ഹാക്കർമാർ ശ്രദ്ധിച്ചിരിക്കാം
ഈ മൂല്യം ഒരു "do" ബ്ലോക്കിൽ ലൂപ്പ് പൊതിഞ്ഞ് പിടിച്ചെടുക്കാൻ കഴിയും. ഇതിനുള്ള പ്രതിഫലം
കണ്ടെത്തൽ ഈ മുൻകരുതൽ ഉപദേശമാണ്: "ഫോർ" ലൂപ്പിന്റെ റിട്ടേൺ മൂല്യം വ്യക്തമാക്കിയിട്ടില്ല
അറിയിപ്പില്ലാതെ മാറ്റാം. അതിൽ ആശ്രയിക്കരുത്.

അടിസ്ഥാനപരമായ ബ്ലോക്കുകൾ
ഒരു ബ്ലോക്ക് സ്വയം (ലേബൽ ചെയ്തതോ അല്ലാത്തതോ) എക്സിക്യൂട്ട് ചെയ്യുന്ന ഒരു ലൂപ്പിന് അർത്ഥപരമായി തുല്യമാണ്
ഒരിക്കല്. അതിനാൽ നിങ്ങൾക്ക് അതിലെ ഏതെങ്കിലും ലൂപ്പ് കൺട്രോൾ സ്റ്റേറ്റ്‌മെന്റുകൾ ഉപേക്ഷിക്കാനോ പുനരാരംഭിക്കാനോ ഉപയോഗിക്കാം
തടയുക. (ഇത് ശ്രദ്ധിക്കുക ചെയ്യില്ല "eval{}", "sub{}" എന്നിവയിൽ ശരിയാണ് അല്ലെങ്കിൽ ജനകീയ വിശ്വാസത്തിന് വിരുദ്ധമാണ്
"do{}" ബ്ലോക്കുകൾ, ഏത് ചെയ്യുന്നു ചെയ്യില്ല ലൂപ്പുകളായി കണക്കാക്കുക.) "തുടരുക" ബ്ലോക്ക് ഓപ്ഷണലാണ്.

കേസ് ഘടനകളെ അനുകരിക്കാൻ BLOCK നിർമ്മാണം ഉപയോഗിക്കാം.

സ്വിച്ച്: {
എങ്കിൽ (/^abc/) {$abc = 1; അവസാന സ്വിച്ച്; }
എങ്കിൽ (/^def/) {$def = 1; അവസാന സ്വിച്ച്; }
എങ്കിൽ (/^xyz/) {$xyz = 1; അവസാന സ്വിച്ച്; }
$ഒന്നുമില്ല = 1;
}

ഒരു ടോപ്പിക്കലൈസറും സ്വിച്ചും സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന "ഫോറച്ച്" ലൂപ്പും നിങ്ങൾ കണ്ടെത്തും:

സ്വിച്ച്:
വേണ്ടി ($var) {
എങ്കിൽ (/^abc/) {$abc = 1; അവസാന സ്വിച്ച്; }
എങ്കിൽ (/^def/) {$def = 1; അവസാന സ്വിച്ച്; }
എങ്കിൽ (/^xyz/) {$xyz = 1; അവസാന സ്വിച്ച്; }
$ഒന്നുമില്ല = 1;
}

Perl-ന്റെ പഴയ പതിപ്പുകൾ ഇല്ലാതിരുന്നതിനാൽ ഇത്തരം നിർമ്മാണങ്ങൾ പതിവായി ഉപയോഗിക്കാറുണ്ട്
ഔദ്യോഗിക "സ്വിച്ച്" പ്രസ്താവന, കൂടാതെ പുതിയ പതിപ്പ് ഉടൻ തന്നെ താഴെ വിവരിച്ചിരിക്കുന്നതിനാലും
പരീക്ഷണാത്മകമായി തുടരുകയും ചിലപ്പോൾ ആശയക്കുഴപ്പമുണ്ടാക്കുകയും ചെയ്യും.

മാറുക പ്രസ്താവനകൾ
Perl 5.10.1 (നന്നായി, 5.10.0, പക്ഷേ അത് ശരിയായി പ്രവർത്തിച്ചില്ല) മുതൽ ആരംഭിക്കുന്നു, നിങ്ങൾക്ക് പറയാം

"സ്വിച്ച്" എന്ന സവിശേഷത ഉപയോഗിക്കുക;

ഒരു പരീക്ഷണാത്മക സ്വിച്ച് സവിശേഷത പ്രവർത്തനക്ഷമമാക്കാൻ. ഇത് ഒരു പഴയ പതിപ്പിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
Perl 6 നിർദ്ദേശം, എന്നാൽ ഇത് ഇപ്പോൾ Perl 6 നിർമ്മാണവുമായി സാമ്യമുള്ളതല്ല. നിങ്ങൾക്കും ലഭിക്കും
നിങ്ങളുടെ കോഡ് Perl-ന്റെ ഒരു പതിപ്പിന് കീഴിൽ പ്രവർത്തിക്കാൻ താൽപ്പര്യപ്പെടുന്നുവെന്ന് പ്രഖ്യാപിക്കുമ്പോഴെല്ലാം സവിശേഷത മാറുക
അതായത് 5.10 അല്ലെങ്കിൽ അതിനു ശേഷമുള്ള സമയം. ഉദാഹരണത്തിന്:

v5.14 ഉപയോഗിക്കുക;

"സ്വിച്ച്" ഫീച്ചറിന് കീഴിൽ, "കൊടുത്തത്", "എപ്പോൾ", എന്ന പരീക്ഷണാത്മക കീവേഡുകൾ പേൾ നേടുന്നു.
"default", "continue", "break". Perl 5.16 മുതൽ, ഒരാൾക്ക് സ്വിച്ച് പ്രിഫിക്സ് ചെയ്യാം
"ഉപയോഗ ഫീച്ചർ" പ്രസ്താവനയില്ലാതെ ഫീച്ചർ ആക്‌സസ് ചെയ്യാൻ "CORE::" ഉള്ള കീവേഡുകൾ. ദി
"കൊടുത്തത്", "എപ്പോൾ" എന്നീ കീവേഡുകൾ മറ്റ് ഭാഷകളിലെ "സ്വിച്ച്", "കേസ്" എന്നിവയ്ക്ക് സമാനമാണ്, അതിനാൽ
മുമ്പത്തെ വിഭാഗത്തിലെ കോഡ് ഇതായി മാറ്റിയെഴുതാം

v5.10.1 ഉപയോഗിക്കുക;
വേണ്ടി ($var) {
എപ്പോൾ (/^abc/) {$abc = 1 }
എപ്പോൾ (/^def/) {$def = 1 }
എപ്പോൾ (/^xyz/) {$xyz = 1}
ഡിഫോൾട്ട് {$nothing = 1}
}

ഒരു ടോപ്പിക്കലൈസർ സജ്ജമാക്കുന്നതിനുള്ള പരീക്ഷണാത്മകമല്ലാത്ത മാർഗമാണ് "ഫോറച്ച്". നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
വളരെ പരീക്ഷണാത്മകമായ "നൽകിയത്", അത് ഇങ്ങനെ എഴുതാം:

v5.10.1 ഉപയോഗിക്കുക;
നൽകിയത് ($var) {
എപ്പോൾ (/^abc/) {$abc = 1 }
എപ്പോൾ (/^def/) {$def = 1 }
എപ്പോൾ (/^xyz/) {$xyz = 1}
ഡിഫോൾട്ട് {$nothing = 1}
}

5.14 വരെ, അത് ഇങ്ങനെയും എഴുതാം:

v5.14 ഉപയോഗിക്കുക;
വേണ്ടി ($var) {
$abc = 1 എപ്പോൾ /^abc/;
$def = 1 എപ്പോൾ /^def/;
$xyz = 1 എപ്പോൾ /^xyz/;
ഡിഫോൾട്ട് {$nothing = 1}
}

അല്ലെങ്കിൽ ഇത് സുരക്ഷിതമായി കളിക്കാൻ നിങ്ങൾ ശ്രദ്ധിക്കുന്നില്ലെങ്കിൽ, ഇതുപോലെ:

v5.14 ഉപയോഗിക്കുക;
നൽകിയത് ($var) {
$abc = 1 എപ്പോൾ /^abc/;
$def = 1 എപ്പോൾ /^def/;
$xyz = 1 എപ്പോൾ /^xyz/;
ഡിഫോൾട്ട് {$nothing = 1}
}

"കൊടുത്തത്", "എപ്പോൾ" എന്നീ ആർഗ്യുമെന്റുകൾ സ്കെയിലർ സന്ദർഭത്തിലാണ്, കൂടാതെ "നൽകിയത്" $_ അസൈൻ ചെയ്യുന്നു
വേരിയബിൾ അതിന്റെ വിഷയ മൂല്യം.

കൃത്യമായി എന്താണ് എക്സ്പിആർ "എപ്പോൾ" എന്ന വാദം കൃത്യമായി വിവരിക്കാൻ പ്രയാസമാണ്, പക്ഷേ അതിൽ
പൊതുവായി, നിങ്ങൾ എന്താണ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നതെന്ന് ഊഹിക്കാൻ ശ്രമിക്കുന്നു. ചിലപ്പോൾ ഇത് "$_ ~~ ആയി വ്യാഖ്യാനിക്കപ്പെടുന്നു
എക്സ്പിആർ", ചിലപ്പോൾ അങ്ങനെയല്ല. a കൊണ്ട് പദാനുപദമായി അടയ്‌ക്കുമ്പോൾ അത് വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്നു
ഒരു "ഫോറച്ച്" ലൂപ്പിൽ ചലനാത്മകമായി ഘടിപ്പിച്ചിരിക്കുന്നതിനേക്കാൾ "നൽകിയ" ബ്ലോക്ക്. നിയമങ്ങളാണ്
ഇവിടെ വിവരിക്കാൻ മനസ്സിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്. "നൽകിയിരിക്കുന്ന പരീക്ഷണാത്മക വിശദാംശങ്ങൾ കാണുക
എപ്പോൾ" പിന്നീട്.

Perl 5.10 നും 5.16 നും ഇടയിൽ "കൊടുത്തത്" എങ്ങനെ നടപ്പിലാക്കി എന്നതിലെ നിർഭാഗ്യകരമായ ബഗ് കാരണം
ആ നടപ്പിലാക്കലുകൾ $_ ന്റെ പതിപ്പ് "നൽകിയിരിക്കുന്നത്" നിയന്ത്രിക്കുന്നത് ഒരു ലെക്സിക്കലി സ്കോപ്പ് മാത്രമാണ്
ഒറിജിനലിന്റെ പകർപ്പ്, ഒറിജിനലിന്റെ ചലനാത്മകമായി സ്‌കോപ്പ് ചെയ്‌ത അപരനാമമല്ല, അങ്ങനെയാണെങ്കിൽ
ഒരു "ഫോറച്ച്" അല്ലെങ്കിൽ ഒറിജിനലിനും നിലവിലുള്ളതുമായ പേൾ 6 ഭാഷാ സ്പെസിഫിക്കേഷനു കീഴിലായിരുന്നു.
ഈ ബഗ് Perl 5.18-ൽ പരിഹരിച്ചു. നിങ്ങൾക്ക് ശരിക്കും ഒരു ലെക്സിക്കൽ $_ വേണമെങ്കിൽ, അത് വ്യക്തമാക്കുക
വ്യക്തമായി, പക്ഷേ "എന്റെ $_" ഇപ്പോൾ ഒഴിവാക്കിയിരിക്കുന്നു, മുന്നറിയിപ്പുകൾ ഇല്ലെങ്കിൽ മുന്നറിയിപ്പ് നൽകും
അപ്രാപ്തമാക്കി:

നൽകിയത്(എന്റെ $_ = EXPR) {...}

നിങ്ങളുടെ കോഡ് ഇപ്പോഴും പഴയ പതിപ്പുകളിൽ പ്രവർത്തിക്കേണ്ടതുണ്ടെങ്കിൽ, നിങ്ങളുടെ ടോപ്പിക്കലൈസറിനായി "ഫോറച്ച്" എന്നതിൽ ഉറച്ചുനിൽക്കുക
നിങ്ങൾ അസന്തുഷ്ടനായിരിക്കും.

ഗോട്ടോ
ഹൃദയത്തിന്റെ തളർച്ചയ്ക്ക് വേണ്ടിയല്ലെങ്കിലും, പേൾ ഒരു "ഗോട്ടോ" പ്രസ്താവനയെ പിന്തുണയ്ക്കുന്നു. ഇതുണ്ട്
മൂന്ന് ഫോമുകൾ: "goto"-LABEL, "goto"-EXPR, "goto"-&NAME. ഒരു ലൂപ്പിന്റെ LABEL യഥാർത്ഥത്തിൽ അല്ല
ഒരു "ഗോട്ടോ" എന്നതിനുള്ള സാധുവായ ലക്ഷ്യം; അത് ലൂപ്പിന്റെ പേര് മാത്രമാണ്.

"goto"-LABEL ഫോം LABEL ഉപയോഗിച്ച് ലേബൽ ചെയ്‌തിരിക്കുന്ന സ്റ്റേറ്റ്‌മെന്റ് കണ്ടെത്തുകയും അവിടെ എക്‌സിക്യൂഷൻ പുനരാരംഭിക്കുകയും ചെയ്യുന്നു.
എ പോലെയുള്ള സമാരംഭം ആവശ്യമുള്ള ഒരു നിർമ്മാണത്തിലേക്കും പോകാൻ ഇത് ഉപയോഗിച്ചേക്കില്ല
സബ്റൂട്ടീൻ അല്ലെങ്കിൽ ഒരു "ഫോറച്ച്" ലൂപ്പ്. ഒരു നിർമ്മാണത്തിലേക്ക് പോകാനും ഇത് ഉപയോഗിക്കാൻ കഴിയില്ല
ഒപ്റ്റിമൈസ് ചെയ്തു. ഡൈനാമിക് സ്കോപ്പിനുള്ളിൽ മറ്റെവിടെയും പോകാൻ ഇത് ഉപയോഗിക്കാം,
സബ്റൂട്ടീനുകൾക്ക് പുറത്തുള്ളവ ഉൾപ്പെടെ, എന്നാൽ സാധാരണയായി മറ്റ് ചില നിർമ്മാണങ്ങൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്
"അവസാനം" അല്ലെങ്കിൽ "മരിക്കുക". പേളിന്റെ രചയിതാവിന് ഈ രീതിയിലുള്ള "ഗോട്ടോ" ഉപയോഗിക്കണമെന്ന് ഒരിക്കലും തോന്നിയിട്ടില്ല.
(Perl-ൽ, അതായത്--C മറ്റൊരു കാര്യം).

"goto"-EXPR ഫോം ഒരു ലേബൽ നാമം പ്രതീക്ഷിക്കുന്നു, അതിന്റെ വ്യാപ്തി ചലനാത്മകമായി പരിഹരിക്കപ്പെടും. ഈ
ഓരോ ഫോർട്രാനും കമ്പ്യൂട്ട് ചെയ്ത "ഗോട്ടോ"കൾ അനുവദിക്കുന്നു, എന്നാൽ നിങ്ങളാണെങ്കിൽ അത് ശുപാർശ ചെയ്യണമെന്നില്ല
പരിപാലനത്തിനായി ഒപ്റ്റിമൈസ് ചെയ്യുന്നു:

goto(("FOO", "BAR", "GLARCH")[$i]);

"goto"-&NAME ഫോം വളരെ മാന്ത്രികമാണ്, കൂടാതെ പേരിട്ടിരിക്കുന്ന സബ്റൂട്ടീനിലേക്കുള്ള ഒരു കോൾ പകരം വയ്ക്കുന്നു
നിലവിൽ പ്രവർത്തിക്കുന്ന സബ്റൂട്ടീനിനായി. "AUTOLOAD()" എന്ന സബ്റൂട്ടീനുകളാണ് ഇത് ഉപയോഗിക്കുന്നത്
മറ്റൊരു സബ്റൂട്ടീൻ ലോഡുചെയ്യുക, തുടർന്ന് മറ്റ് സബ്റൂട്ടീനെ വിളിച്ചതായി നടിക്കുക
ഒന്നാം സ്ഥാനം (നിലവിലെ സബ്റൂട്ടീനിലെ @_ എന്നതിലേക്കുള്ള മാറ്റങ്ങളൊഴികെ
മറ്റ് സബ്റൂട്ടീനിലേക്ക് പ്രചരിപ്പിച്ചു.) "ഗോട്ടോ" കഴിഞ്ഞാൽ, "കോളർ()" എന്നതിന് പോലും കഴിയില്ല
ഈ പതിവാണ് ആദ്യം വിളിച്ചതെന്ന് പറയാൻ.

ഇതുപോലുള്ള മിക്കവാറും എല്ലാ സാഹചര്യങ്ങളിലും, ഘടനാപരമായത് ഉപയോഗിക്കുന്നത് വളരെ മികച്ച ആശയമാണ്
ഒരു "ഗോട്ടോ" അവലംബിക്കുന്നതിനുപകരം "അടുത്തത്", "അവസാനം" അല്ലെങ്കിൽ "വീണ്ടും ചെയ്യുക" എന്നിവയുടെ ഫ്ലോ മെക്കാനിസങ്ങൾ നിയന്ത്രിക്കുക.
ചില ആപ്ലിക്കേഷനുകൾക്ക്, "eval{}" എന്നതിന്റെ ക്യാച്ച് ആൻഡ് ത്രോ ജോഡിയും മരിക്കും () ഒഴിവാക്കൽ
പ്രോസസ്സിംഗ് ഒരു വിവേകപൂർണ്ണമായ സമീപനം കൂടിയാണ്.

ദി എല്ലിപ്സിസ് പ്രസ്താവന
Perl 5.12 മുതൽ, ""..."" എന്ന കോഡിനുള്ള ഒരു പ്ലെയ്‌സ്‌ഹോൾഡറായി പേൾ ഒരു എലിപ്‌സിസ് സ്വീകരിക്കുന്നു.
നിങ്ങൾ ഇതുവരെ നടപ്പിലാക്കിയിട്ടില്ല. എലിപ്‌സിസിന്റെ ഈ രൂപം, നടപ്പിലാക്കാത്ത പ്രസ്താവന, വേണം
ബൈനറി ഫ്ലിപ്പ്-ഫ്ലോപ്പ് "..." ഓപ്പറേറ്ററുമായി തെറ്റിദ്ധരിക്കരുത്. ഒന്ന് ഒരു പ്രസ്താവനയാണ്
മറ്റൊരു ഓപ്പറേറ്റർ. (പേൾ സാധാരണയായി അവരെ ആശയക്കുഴപ്പത്തിലാക്കില്ല, കാരണം സാധാരണയായി പേളിന് പറയാൻ കഴിയും
അതിന് ഒരു ഓപ്പറേറ്റർ വേണോ അല്ലെങ്കിൽ ഒരു പ്രസ്താവന വേണോ, എന്നാൽ ഒഴിവാക്കലുകൾക്കായി താഴെ കാണുക.)

Perl 5.12 അല്ലെങ്കിൽ അതിനു ശേഷമുള്ള ഒരു എലിപ്സിസ് പ്രസ്താവന നേരിടുമ്പോൾ, അത് ഒരു പിശക് കൂടാതെ പാഴ്സ് ചെയ്യുന്നു,
എന്നാൽ നിങ്ങൾ യഥാർത്ഥത്തിൽ അത് എക്സിക്യൂട്ട് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, പേൾ ഒരു അപവാദം എറിയുന്നു
"നടപ്പിലാക്കാത്തത്" എന്ന വാചകം:

v5.12 ഉപയോഗിക്കുക;
ഉപ നടപ്പാക്കാത്തത് { ...}
eval { നടപ്പാക്കാത്തത്()};
എങ്കിൽ ($@ =~ /^ഇനിപ്ലിമെന്റ് ചെയ്യാത്തത് /) {
"ഞാൻ ഒരു എലിപ്സിസ് കണ്ടെത്തി!" എന്ന് പറയുക;
}

ഒരു സമ്പൂർണ്ണ പ്രസ്താവനയ്ക്കായി നിൽക്കാൻ നിങ്ങൾക്ക് എലിപ്റ്റിക്കൽ സ്റ്റേറ്റ്മെന്റ് മാത്രമേ ഉപയോഗിക്കാനാകൂ. ഇവ
എലിപ്സിസ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഉദാഹരണങ്ങൾ:

v5.12 ഉപയോഗിക്കുക;
{...}
സബ് ഫൂ {...}
...;
eval { ... };
ഉപ ചിലത് {
എന്റെ $self = shift;
...;
}
$x = ചെയ്യുക {
എന്റെ $n;
...;
"ഹുറേ!" എന്ന് പറയുക;
$n;
};

ദീർഘവൃത്താകൃതിയിലുള്ള പ്രസ്‌താവനയ്‌ക്ക് വലുതിന്റെ ഭാഗമായ ഒരു പദപ്രയോഗത്തിന് വേണ്ടി നിലകൊള്ളാൻ കഴിയില്ല
പ്രസ്താവന, കാരണം "..." എന്നത് ഫ്ലിപ്പ്-ഫ്ലോപ്പ് ഓപ്പറേറ്ററിന്റെ ത്രീ-ഡോട്ട് പതിപ്പ് കൂടിയാണ് (കാണുക
പെർലോപ്പിലെ "റേഞ്ച് ഓപ്പറേറ്റർമാർ").

എലിപ്സിസ് ഉപയോഗിക്കാനുള്ള ശ്രമങ്ങളുടെ ഈ ഉദാഹരണങ്ങൾ വാക്യഘടന പിശകുകളാണ്:

v5.12 ഉപയോഗിക്കുക;

പ്രിന്റ് ...;
തുറക്കുക (എന്റെ $fh, ">", "/dev/passwd") അല്ലെങ്കിൽ ...;
എങ്കിൽ ($condition && ... ) {"Howdy" എന്ന് പറയുക };

ഒരു തമ്മിലുള്ള വ്യത്യാസം പേളിന് പെട്ടെന്ന് പറയാൻ കഴിയാത്ത ചില സന്ദർഭങ്ങളുണ്ട്
ആവിഷ്കാരവും ഒരു പ്രസ്താവനയും. ഉദാഹരണത്തിന്, ഒരു ബ്ലോക്കിനും ഒരു അജ്ഞാത ഹാഷിനുമുള്ള വാക്യഘടന
പെർളിന് നൽകാൻ ബ്രേസുകളിൽ എന്തെങ്കിലും ഇല്ലെങ്കിൽ റഫറൻസ് കൺസ്‌ട്രക്‌ടർ ഒരുപോലെ കാണപ്പെടുന്നു
സൂചന. "{ ... }" ഒരു ബ്ലോക്ക് ആണെന്ന് പേൾ ഊഹിച്ചില്ലെങ്കിൽ എലിപ്സിസ് ഒരു വാക്യഘടന പിശകാണ്.
അങ്ങനെയെങ്കിൽ, "..." ഒരു ദീർഘവൃത്തമാണെന്ന് അത് കരുതുന്നില്ല, കാരണം അത് പ്രതീക്ഷിക്കുന്നു
ഒരു പ്രസ്താവനയ്ക്ക് പകരം പദപ്രയോഗം:

@transformed = മാപ്പ് {...} @input; # വാക്യഘടന പിശക്

നിങ്ങളുടെ ബ്ലോക്കിനുള്ളിൽ, നിങ്ങൾക്ക് ഒരു ";" ഉപയോഗിക്കാം ദീർഘവൃത്തത്തിന് മുമ്പ് "{ ... }" എന്നത് a
തടയുക, ഒരു ഹാഷ് റഫറൻസ് കൺസ്ട്രക്റ്റർ അല്ല. ഇപ്പോൾ എലിപ്സിസ് പ്രവർത്തിക്കുന്നു:

@രൂപാന്തരപ്പെട്ടു = മാപ്പ് {; ... } @ഇൻപുട്ട്; # ';' അവ്യക്തമാക്കുന്നു

കുറിപ്പ്: ചില ആളുകൾ ഈ ബിറ്റ് വിരാമചിഹ്നങ്ങളെ "യാഡ-യാഡ" അല്ലെങ്കിൽ
"ട്രിപ്പിൾ-ഡോട്ട്", എന്നാൽ അതിന്റെ യഥാർത്ഥ പേര് യഥാർത്ഥത്തിൽ ഒരു എലിപ്സിസ് ആണ്.

പോഡുകൾ: എംബഡുചെയ്ത വിവരണക്കുറിപ്പു്
സോഴ്സ് കോഡുമായി ഡോക്യുമെന്റേഷൻ മിക്സ് ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനം പേളിനുണ്ട്. അത് പ്രതീക്ഷിക്കുന്ന സമയത്ത്
ഒരു പുതിയ പ്രസ്താവനയുടെ ആരംഭം, കംപൈലർ ഒരു വരിയിൽ ആരംഭിക്കുന്ന ഒരു വരി കണ്ടുമുട്ടിയാൽ
തുല്യ ചിഹ്നവും ഇതുപോലെ ഒരു വാക്കും

=head1 ഇവിടെ പോഡുകൾ ഉണ്ടാകൂ!

തുടർന്ന് ആ ടെക്‌സ്‌റ്റും ബാക്കിയുള്ള എല്ലാ ടെക്‌സ്‌റ്റും മുകളിലേയ്‌ക്ക് ആരംഭിക്കുകയും ഒരു വരി ഉൾപ്പെടെ
"=കട്ട്" അവഗണിക്കപ്പെടും. ഇടയിലുള്ള വാചകത്തിന്റെ ഫോർമാറ്റ് perlpod-ൽ വിവരിച്ചിരിക്കുന്നു.

നിങ്ങളുടെ സോഴ്‌സ് കോഡും ഡോക്യുമെന്റേഷൻ ടെക്‌സ്‌റ്റും സ്വതന്ത്രമായി മിക്സ് ചെയ്യാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു

=ഇനം സ്നാസിൽ($)

സ്നാസിൽ() ഫംഗ്ഷൻ ഏറ്റവും ഗംഭീരമായി പ്രവർത്തിക്കും
നിങ്ങൾക്ക് സങ്കൽപ്പിക്കാൻ കഴിയുന്ന രൂപം, അല്ലാതെയും
സൈബർനെറ്റിക് പൈറോടെക്നിക്സ്.

= കംപൈലറിലേക്ക് വീണ്ടും വെട്ടിക്കുറയ്ക്കുക, ഈ പോഡ് സ്റ്റഫിന്റെ നഫ്!

ഉപ സ്നാസിൽ($) {
എന്റെ $ തിങ്ങി = shift;
.........
}

പോഡ് വിവർത്തകർ ഒരു പോഡ് നിർദ്ദേശത്തിൽ തുടങ്ങുന്ന ഖണ്ഡികകൾ മാത്രമേ നോക്കാവൂ എന്നത് ശ്രദ്ധിക്കുക
(ഇത് പാഴ്‌സിംഗ് എളുപ്പമാക്കുന്നു), അതേസമയം കംപൈലറിന് പോഡ് രക്ഷപ്പെടലുകൾക്കായി തിരയാൻ അറിയാം
ഒരു ഖണ്ഡികയുടെ മധ്യത്തിൽ പോലും. ഇതിനർത്ഥം ഇനിപ്പറയുന്ന രഹസ്യ കാര്യങ്ങൾ ആയിരിക്കും
കമ്പൈലറും വിവർത്തകരും അവഗണിച്ചു.

$a=3;
=രഹസ്യമായ കാര്യങ്ങൾ
മുന്നറിയിപ്പ് "POD അല്ലെങ്കിൽ CODE ഒന്നുമല്ല!?"
= വെട്ടിച്ചുരുക്കുക
"$a\n ലഭിച്ചു";

നിങ്ങൾ "മുന്നറിയിപ്പ്()" എന്നെന്നേക്കുമായി നീക്കം ചെയ്യപ്പെടുന്നതിനെ ആശ്രയിക്കേണ്ടതില്ല. എല്ലാ പോഡ് അല്ല
വിവർത്തകർ ഇക്കാര്യത്തിൽ നന്നായി പെരുമാറുന്നു, ഒരുപക്ഷേ കംപൈലർ പിക്കർ ആയി മാറിയേക്കാം.

കോഡിന്റെ ഒരു വിഭാഗം പെട്ടെന്ന് കമന്റ് ചെയ്യാൻ പോഡ് നിർദ്ദേശങ്ങളും ഉപയോഗിക്കാം.

പ്ലെയിൻ പഴയ അഭിപ്രായങ്ങള് (അല്ല!)
സി പ്രീപ്രൊസസ്സർ പോലെ തന്നെ പേളിന് ലൈൻ നിർദ്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. ഇത് ഉപയോഗിച്ച്, ഒരാൾക്ക് കഴിയും
പിശക് അല്ലെങ്കിൽ മുന്നറിയിപ്പ് സന്ദേശങ്ങളിൽ (പ്രത്യേകിച്ച്) ഫയൽനാമങ്ങളും ലൈൻ നമ്പറുകളും സംബന്ധിച്ച Perl-ന്റെ ആശയം നിയന്ത്രിക്കുക
"eval()") ഉപയോഗിച്ച് പ്രോസസ്സ് ചെയ്യുന്ന സ്ട്രിംഗുകൾക്ക്. ഈ മെക്കാനിസത്തിന്റെ വാക്യഘടന ഏതാണ്ട് ആണ്
മിക്ക സി പ്രീപ്രോസസറുകൾക്കും സമാനമാണ്: ഇത് സാധാരണ എക്സ്പ്രഷനുമായി പൊരുത്തപ്പെടുന്നു

# ഉദാഹരണം: '# ലൈൻ 42 "new_filename.plx"'
/^\# \s*
വരി \s+ (\d+) \s*
(?:\s("?)([^"]+)\g2)? \s*
$/x

$1 അടുത്ത വരിയുടെ ലൈൻ നമ്പറും $3 ഓപ്‌ഷണൽ ഫയൽനാമവുമാണ്
(ഉദ്ധരണികൾക്കൊപ്പം അല്ലെങ്കിൽ അല്ലാതെയും വ്യക്തമാക്കിയിരിക്കുന്നു). ഒരു വൈറ്റ്‌സ്‌പെയ്‌സും "#" എന്നതിന് മുമ്പായി ഉണ്ടാകില്ല എന്നത് ശ്രദ്ധിക്കുക
ആധുനിക സി പ്രീപ്രോസസറുകൾ.

ലൈൻ ഡയറക്‌ടീവിനൊപ്പം വ്യക്തമായ ഒരു ഗോച്ച ഉൾപ്പെടുത്തിയിട്ടുണ്ട്: ഡീബഗ്ഗറുകളും പ്രൊഫൈലറുകളും
തന്നിരിക്കുന്ന ഫയലിലെ ഒരു പ്രത്യേക ലൈൻ നമ്പറിൽ ദൃശ്യമാകുന്ന അവസാന സോഴ്സ് ലൈൻ മാത്രമേ കാണിക്കൂ.
നിങ്ങൾ ഡീബഗ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കോഡിൽ ലൈൻ നമ്പർ കൂട്ടിമുട്ടലുകൾ ഉണ്ടാകാതിരിക്കാൻ ശ്രദ്ധിക്കണം
പിന്നീട്.

നിങ്ങളുടെ കമാൻഡ് ഷെല്ലിൽ ടൈപ്പ് ചെയ്യാൻ കഴിയുന്ന ചില ഉദാഹരണങ്ങൾ ഇതാ:

% perl
# ലൈൻ 200 "bzzzt"
# മുമ്പത്തെ വരിയിലെ '#' ലൈനിലെ ആദ്യത്തെ പ്രതീകമായിരിക്കണം
മരിക്കുക 'ഫൂ';
__അവസാനിക്കുന്നു__
bzzzt ലൈൻ 201-ൽ foo.

% perl
# ലൈൻ 200 "bzzzt"
eval qq[\n#line 2001 ""\ndie 'foo']; $@ അച്ചടിക്കുക;
__അവസാനിക്കുന്നു__
foo at - line 2001.

% perl
eval qq[\n#line 200 "foo bar"\ndie 'foo']; $@ അച്ചടിക്കുക;
__അവസാനിക്കുന്നു__
foo at foo bar line 200.

% perl
# ലൈൻ 345 "ഗൂപ്പ്"
eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
$@ അച്ചടിക്കുക;
__അവസാനിക്കുന്നു__
ഗൂപ്പ് ലൈൻ 345-ൽ foo.

പരീക്ഷണാത്മക വിവരങ്ങൾ on നൽകപ്പെട്ട ഒപ്പം എപ്പോൾ
മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, "സ്വിച്ച്" സവിശേഷത വളരെ പരീക്ഷണാത്മകമായി കണക്കാക്കപ്പെടുന്നു; അത്
ചെറിയ അറിയിപ്പോടെ മാറ്റത്തിന് വിധേയമാണ്. പ്രത്യേകിച്ചും, "എപ്പോൾ" എന്നതിന് തന്ത്രപരമായ പെരുമാറ്റങ്ങളുണ്ട്
ഭാവിയിൽ കുറച്ചുകൂടി ബുദ്ധിമുട്ടുള്ളതായി മാറുമെന്ന് പ്രതീക്ഷിക്കുന്നു. അതിന്റെ വൈദ്യുതധാരയെ ആശ്രയിക്കരുത്
(തെറ്റായ) നടപ്പാക്കൽ. Perl 5.18 ന് മുമ്പ്, "നൽകിയ" ന് നിങ്ങൾ ചെയ്യേണ്ട തന്ത്രപരമായ പെരുമാറ്റങ്ങളും ഉണ്ടായിരുന്നു
നിങ്ങളുടെ കോഡ് Perl-ന്റെ പഴയ പതിപ്പുകളിൽ പ്രവർത്തിക്കേണ്ടതുണ്ടോ എന്ന് ഇപ്പോഴും സൂക്ഷിക്കുക.

"കൊടുത്തത്" എന്നതിന്റെ ദൈർഘ്യമേറിയ ഉദാഹരണം ഇതാ:

ഫീച്ചർ ഉപയോഗിക്കുക ":5.10";
നൽകിയത് ($foo) {
എപ്പോൾ (undef) {
'$foo is undefined' എന്ന് പറയുക;
}
എപ്പോൾ ("foo") {
'$foo എന്നത് "foo" എന്ന സ്ട്രിംഗ് ആണ്' എന്ന് പറയുക;
}
എപ്പോൾ ([1,3,5,7,9]) {
'$foo ഒരു ഒറ്റ അക്കമാണ്' എന്ന് പറയുക;
തുടരുക; # വീഴുക
}
എപ്പോൾ ($_ < 100) {
'$foo സംഖ്യാപരമായി 100-ൽ കുറവാണ്' എന്ന് പറയുക;
}
എപ്പോൾ (\&complicated_check) {
'$foo എന്നതിനായുള്ള സങ്കീർണ്ണമായ പരിശോധന ശരിയാണ്' എന്ന് പറയുക;
}
ഡിഫോൾട്ട് {
ഡൈ ക്യു ($foo ഉപയോഗിച്ച് എന്തുചെയ്യണമെന്ന് എനിക്കറിയില്ല);
}
}

Perl 5.18 ന് മുമ്പ്, "നൽകിയ (EXPR)" മൂല്യം നൽകിയിട്ടുണ്ട് എക്സ്പിആർ കേവലം ഒരു ലെക്സിക്കലി സ്കോപ്പിലേക്ക്
പകർത്തുക (!) $_ ന്റെ, ഡൈനാമിക് സ്കോപ്പ് അപരനാമം "ഫോറച്ച്" ചെയ്യുന്ന രീതിയല്ല. അത് ഉണ്ടാക്കി
ഇതുപോലെയാണ്

{എന്റെ $_ = EXPR ചെയ്യുക; ...}

വിജയകരമായ "എപ്പോൾ" അല്ലെങ്കിൽ ഒരു വഴി ബ്ലോക്ക് യാന്ത്രികമായി തകർന്നു എന്നതൊഴിച്ചാൽ
വ്യക്തമായ "ബ്രേക്ക്". കാരണം അത് ഒരു പകർപ്പ് മാത്രമായിരുന്നു, മാത്രമല്ല അത് നിഘണ്ടുവിൽ മാത്രമുള്ളതിനാൽ,
ചലനാത്മകമായി സ്‌കോപ്പ് ചെയ്‌തിട്ടില്ല, എയിൽ നിങ്ങൾ പരിചിതമായ കാര്യങ്ങൾ ഇത് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയില്ല
"ഫോറച്ച്" ലൂപ്പ്. പ്രത്യേകിച്ചും, അനിയന്ത്രിതമായ ഫംഗ്‌ഷൻ കോളുകൾ ആണെങ്കിൽ അത് പ്രവർത്തിക്കില്ല
ഫംഗ്‌ഷനുകൾ $_ ആക്‌സസ് ചെയ്യാൻ ശ്രമിച്ചേക്കാം. അതിനായി "ഫോറച്ച്" ഏറ്റവും മികച്ച സ്റ്റിക്ക്.

ചിലപ്പോഴൊക്കെ ബാധകമായേക്കാവുന്ന പരോക്ഷമായ സ്മാർട്ട് മാച്ചിംഗിൽ നിന്നാണ് മിക്ക ശക്തിയും വരുന്നത്. കൂടുതലും
സമയം, "എപ്പോൾ(EXPR)" എന്നത് $_ ന്റെ ഒരു വ്യക്തമായ സ്‌മാർട്ട് മാച്ചായി കണക്കാക്കുന്നു, അതായത് "$_ ~~ EXPR".
(സ്മാർട്ട് മാച്ചിംഗിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് പെർലോപ്പിലെ "സ്മാർട്ട്മാച്ച് ഓപ്പറേറ്റർ" കാണുക.) എന്നാൽ എപ്പോൾ
എക്സ്പിആർ ചുവടെ ലിസ്റ്റുചെയ്തിരിക്കുന്ന 10 അസാധാരണമായ കേസുകളിൽ (അല്ലെങ്കിൽ അവ പോലുള്ളവ) ഒന്നാണ്, ഇത് ഉപയോഗിക്കുന്നു
നേരിട്ട് ഒരു ബൂളിയൻ ആയി.

1. ഒരു ഉപയോക്തൃ-നിർവചിച്ച സബ്റൂട്ടീൻ കോൾ അല്ലെങ്കിൽ ഒരു രീതി അഭ്യർത്ഥന.

2. "/REGEX/", "$foo =~ /REGEX/" അല്ലെങ്കിൽ "$foo =~ രൂപത്തിലുള്ള ഒരു പതിവ് എക്സ്പ്രഷൻ പൊരുത്തം
EXPR". കൂടാതെ, "!/REGEX/", "$foo !~ രൂപത്തിലുള്ള ഒരു നിരാകരിച്ച റെഗുലർ എക്സ്പ്രഷൻ പൊരുത്തം
/REGEX/", അല്ലെങ്കിൽ "$foo !~ EXPR".

3. "EXPR ~~ EXPR" പോലെയുള്ള വ്യക്തമായ "~~" ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്ന ഒരു മികച്ച പൊരുത്തം.

ശ്രദ്ധിക്കുക: സ്ഥിരസ്ഥിതി കേസ് "$_ ~~ $c" ഉപയോഗിക്കുന്നതിനാൽ നിങ്ങൾക്ക് പലപ്പോഴും "$c ~~ $_" ഉപയോഗിക്കേണ്ടി വരും.
ഇത് പലപ്പോഴും നിങ്ങൾ ആഗ്രഹിക്കുന്നതിന് വിപരീതമാണ്.

4. "$_ < 10" അല്ലെങ്കിൽ "$x eq "abc"" പോലുള്ള ഒരു ബൂളിയൻ താരതമ്യ ഓപ്പറേറ്റർ. ബന്ധുവായ
ഇത് ബാധകമാകുന്ന ഓപ്പറേറ്റർമാർ ആറ് സംഖ്യാ താരതമ്യങ്ങളാണ് ("<", ">", "<=", ">=",
"==", കൂടാതെ "!="), കൂടാതെ ആറ് സ്ട്രിംഗ് താരതമ്യങ്ങളും ("lt", "gt", "le", "ge", "eq", കൂടാതെ
"ne").

5. "നിർവചിക്കപ്പെട്ട(...)", "നിലവിൽ(...)", "eof(...)" എന്നീ മൂന്ന് ബിൽറ്റിൻ ഫംഗ്ഷനുകളെങ്കിലും.
ഇവയെക്കുറിച്ചു ചിന്തിച്ചാൽ പിന്നീടൊരിക്കൽ നാം ഇവയിൽ കൂടുതൽ ചേർത്തേക്കാം.

6. "!(EXPR)" അല്ലെങ്കിൽ "അല്ല (EXPR)", അല്ലെങ്കിൽ ഒരു ലോജിക്കൽ എക്സ്ക്ലൂസീവ്-അല്ലെങ്കിൽ, ഒരു നിഷേധാത്മക പദപ്രയോഗം
"(EXPR1) xor (EXPR2)". ബിറ്റ്വൈസ് പതിപ്പുകൾ ("~", "^") ഉൾപ്പെടുത്തിയിട്ടില്ല.

7. ഒരു ഫയൽ ടെസ്റ്റ് ഓപ്പറേറ്റർ, കൃത്യമായി 4 ഒഴിവാക്കലുകൾ: "-s", "-M", "-A", "-C" എന്നിവ
ബൂളിയൻ മൂല്യങ്ങളല്ല, സംഖ്യാ മൂല്യങ്ങൾ നൽകുക. "-z" ഫയൽ ടെസ്റ്റ് ഓപ്പറേറ്റർ ഉൾപ്പെടുത്തിയിട്ടില്ല
ഒഴിവാക്കൽ പട്ടികയിൽ.

8. "..", "..." ഫ്ലിപ്പ്-ഫ്ലോപ്പ് ഓപ്പറേറ്റർമാർ. "..." ഫ്ലിപ്പ്-ഫ്ലോപ്പ് ഓപ്പറേറ്റർ ആണെന്നത് ശ്രദ്ധിക്കുക
ഇപ്പോൾ വിവരിച്ച "..." ദീർഘവൃത്താകൃതിയിലുള്ള പ്രസ്താവനയിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ്.

മുകളിലുള്ള 8 കേസുകളിൽ, EXPR ന്റെ മൂല്യം നേരിട്ട് ഒരു ബൂളിയൻ ആയി ഉപയോഗിക്കുന്നു, അതിനാൽ ഇല്ല
സ്മാർട്ട് മാച്ചിംഗ് പൂർത്തിയായി. "എപ്പോൾ" എന്നത് ഒരു സ്മാർട്ട് സ്‌മാർട്ട് മാച്ചായി നിങ്ങൾ ചിന്തിച്ചേക്കാം.

കൂടാതെ, ഉപയോഗിക്കണോ എന്ന് തീരുമാനിക്കാൻ ലോജിക്കൽ ഓപ്പറേറ്റർമാരുടെ ഓപ്പറണ്ടുകൾ പേൾ പരിശോധിക്കുന്നു.
ഓപ്പറണ്ടുകളിൽ മുകളിലുള്ള ടെസ്റ്റ് പ്രയോഗിച്ച് ഓരോന്നിനും സ്മാർട്ട് മാച്ചിംഗ്:

9. EXPR "EXPR1 && EXPR2" അല്ലെങ്കിൽ "EXPR1, EXPR2" ആണെങ്കിൽ, ടെസ്റ്റ് പ്രയോഗിക്കുന്നു ആവർത്തിച്ച് ലേക്ക്
EXPR1, EXPR2 എന്നിവയും. എങ്കിൽ മാത്രം രണ്ടും ഓപ്പറണ്ടുകളും ടെസ്റ്റിൽ വിജയിക്കുന്നു, ആവർത്തിച്ച്, ചെയ്യും
പദപ്രയോഗം ബൂളിയൻ ആയി കണക്കാക്കാം. അല്ലെങ്കിൽ, സ്മാർട്ട് മാച്ചിംഗ് ഉപയോഗിക്കുന്നു.

10. EXPR "EXPR1 || EXPR2", "EXPR1 // EXPR2", അല്ലെങ്കിൽ "EXPR1 അല്ലെങ്കിൽ EXPR2" ആണെങ്കിൽ, ടെസ്റ്റ്
പ്രയോഗിച്ചു ആവർത്തിച്ച് EXPR1-ലേക്ക് മാത്രം (അത് തന്നെ ഉയർന്ന മുൻ‌ഗണനയും ആയിരിക്കാം
ഓപ്പറേറ്റർ, ഉദാഹരണത്തിന്, അതിനാൽ മുമ്പത്തെ നിയമത്തിന് വിധേയമാണ്), EXPR2 ലേക്ക് അല്ല. EXPR1 ആണെങ്കിൽ
സ്‌മാർട്ട്‌മാച്ചിംഗ് ഉപയോഗിക്കുന്നതാണ്, പിന്നെ EXPR2-ൽ എന്ത് അടങ്ങിയിട്ടുണ്ടെങ്കിലും എക്‌സ്‌പിആർ2 അങ്ങനെ ചെയ്യുന്നു. പക്ഷേ
EXPR2 സ്മാർട്ട്‌മാച്ചിംഗ് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, രണ്ടാമത്തെ വാദം അങ്ങനെയാകില്ല
ഒന്നുകിൽ. ഇത് ഇപ്പോൾ വിവരിച്ച "&&" കേസിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ്, അതിനാൽ ശ്രദ്ധിക്കുക.

ഈ നിയമങ്ങൾ സങ്കീർണ്ണമാണ്, എന്നാൽ നിങ്ങൾ ആഗ്രഹിക്കുന്നത് അവർ ചെയ്യുക എന്നതാണ് ലക്ഷ്യം (നിങ്ങൾ ആണെങ്കിലും
എന്തുകൊണ്ടാണ് അവർ ഇത് ചെയ്യുന്നതെന്ന് മനസ്സിലാകുന്നില്ല). ഉദാഹരണത്തിന്:

എപ്പോൾ (/^\d+$/ && $_ < 75) { ...}

ഒരു ബൂളിയൻ പൊരുത്തമായി കണക്കാക്കും, കാരണം നിയമങ്ങൾ ഒരു regex പൊരുത്തം എന്നും an എന്നും പറയുന്നു
$_ എന്നതിലെ വ്യക്തമായ പരിശോധനയെ ബൂളിയൻ ആയി കണക്കാക്കും.

കൂടാതെ:

എപ്പോൾ ([qw(foo bar)] && /baz/) { ...}

സ്മാർട്ട് മാച്ചിംഗ് ഉപയോഗിക്കും കാരണം മാത്രം ഒന്ന് ഓപ്പറണ്ടുകൾ ഒരു ബൂളിയൻ ആണ്: മറ്റ് ഉപയോഗങ്ങൾ
സ്മാർട്ട് മാച്ചിംഗ്, അത് വിജയിക്കുന്നു.

കൂടുതൽ:

എപ്പോൾ ([qw(foo bar)] || /^baz/) { ...}

സ്മാർട്ട് മാച്ചിംഗ് ഉപയോഗിക്കും (ആദ്യ ഓപ്പറാൻറ് മാത്രമേ പരിഗണിക്കൂ), അതേസമയം

എപ്പോൾ (/^baz/ || [qw(foo bar)]) { ...}

രണ്ട് ഓപ്പറണ്ടുകളും ബൂളിയൻ ആയി കണക്കാക്കുന്നതിന് കാരണമാകുന്ന റീജക്‌സ് മാത്രം പരീക്ഷിക്കും. കാണുക
ഇതിന്, അപ്പോൾ, ഒരു അറേഫ് എല്ലായ്പ്പോഴും ഒരു യഥാർത്ഥ മൂല്യമാണ്, അത് അത് ഫലപ്രദമാക്കുന്നു
അനാവശ്യമായ. നല്ല ആശയമല്ല.

ടൗട്ടോലോഗസ് ബൂളിയൻ ഓപ്പറേറ്റർമാർ ഇപ്പോഴും ഒപ്റ്റിമൈസ് ചെയ്യാൻ പോകുന്നു. പ്രലോഭിപ്പിക്കരുത്
എഴുതുക

എപ്പോൾ ("ഫൂ" അല്ലെങ്കിൽ "ബാർ") { ...}

ഇത് "ഫൂ" ആയി ഒപ്റ്റിമൈസ് ചെയ്യും, അതിനാൽ "ബാർ" ഒരിക്കലും പരിഗണിക്കില്ല (നിയമങ്ങളാണെങ്കിലും
"foo"-ൽ ഒരു സ്മാർട്ട് മാച്ച് ഉപയോഗിക്കാൻ പറയുക). ഇതുപോലുള്ള ഒരു ആൾട്ടർനേഷനായി, ഒരു അറേ റെഫർ പ്രവർത്തിക്കും,
കാരണം ഇത് സ്മാർട്ട് മാച്ചിംഗിന് പ്രചോദനം നൽകും:

എപ്പോൾ ([qw(foo bar)] { ...}

ഇത് സി-സ്റ്റൈൽ സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ ഫാൾത്രൂ പ്രവർത്തനത്തിന് ഒരു പരിധിവരെ തുല്യമാണ്
(തെറ്റിദ്ധരിക്കരുത് പേളിന്റേത് ഫാൾത്രൂ ഫങ്ഷണാലിറ്റി--താഴെ കാണുക), അതിൽ തന്നെ
ബ്ലോക്ക് നിരവധി "കേസ്" പ്രസ്താവനകൾക്കായി ഉപയോഗിക്കുന്നു.

മറ്റൊരു ഉപയോഗപ്രദമായ കുറുക്കുവഴി, നിങ്ങൾ ഒരു ലിറ്ററൽ അറേ അല്ലെങ്കിൽ ഹാഷ് ഉപയോഗിക്കുകയാണെങ്കിൽ
"നൽകി", അത് ഒരു റഫറൻസായി മാറുന്നു. അതിനാൽ "നൽകിയ(@foo)" എന്നത് "നൽകിയ(\@foo)" എന്നതിന് തുല്യമാണ്,
ഉദാഹരണത്തിന്.

"default" കൃത്യമായി "എപ്പോൾ(1 == 1)" പോലെയാണ് പെരുമാറുന്നത്, അതായത് അത് എല്ലായ്പ്പോഴും പൊരുത്തപ്പെടുന്നു.

ബ്രേക്കിംഗ് പുറത്ത്

"നൽകിയിരിക്കുന്ന" ബ്ലോക്കിൽ നിന്ന് പുറത്തുകടക്കാൻ നിങ്ങൾക്ക് "ബ്രേക്ക്" കീവേഡ് ഉപയോഗിക്കാം. എല്ലാ "എപ്പോൾ"
ബ്ലോക്ക് ഒരു "ബ്രേക്ക്" കൊണ്ട് പരോക്ഷമായി അവസാനിച്ചു.

വീഴ്ച-വഴി

ഒരു കേസിൽ നിന്ന് അടുത്തതിലേക്ക് വീഴാൻ നിങ്ങൾക്ക് "തുടരുക" കീവേഡ് ഉപയോഗിക്കാം:

നൽകിയത്($foo) {
എപ്പോൾ (/x/) {'$foo ഒരു x അടങ്ങിയിരിക്കുന്നു' എന്ന് പറയുക; തുടരുക }
എപ്പോൾ (/y/) {'$foo ay അടങ്ങിയിരിക്കുന്നു' എന്ന് പറയുക}
ഡിഫോൾട്ട് {'$foo ൽ ay അടങ്ങിയിട്ടില്ല' എന്ന് പറയുക}
}

മടങ്ങുക മൂല്യം

"നൽകിയിരിക്കുന്ന" പ്രസ്താവനയും സാധുവായ ഒരു പദപ്രയോഗമാകുമ്പോൾ (ഉദാഹരണത്തിന്, അത് അവസാനത്തേതായിരിക്കുമ്പോൾ
ഒരു ബ്ലോക്കിന്റെ പ്രസ്താവന), ഇത് വിലയിരുത്തുന്നു:

· വ്യക്തമായ ഒരു "ബ്രേക്ക്" നേരിട്ട ഉടൻ ഒരു ശൂന്യമായ ലിസ്റ്റ്.

വിജയകരമായ "എപ്പോൾ"/"സ്ഥിരസ്ഥിതി" ക്ലോസിന്റെ അവസാനമായി വിലയിരുത്തിയ പദപ്രയോഗത്തിന്റെ മൂല്യം,
ഒന്ന് ഉണ്ടായാൽ.

ഒരു വ്യവസ്ഥയും ഇല്ലെങ്കിൽ, "നൽകിയ" ബ്ലോക്കിന്റെ അവസാനമായി വിലയിരുത്തിയ പദപ്രയോഗത്തിന്റെ മൂല്യം
ശരി.

അവസാനത്തെ രണ്ട് സന്ദർഭങ്ങളിലും, അവസാന പദപ്രയോഗം പ്രയോഗിച്ച സന്ദർഭത്തിൽ വിലയിരുത്തപ്പെടുന്നു
"നൽകിയ" ബ്ലോക്ക്.

ശ്രദ്ധിക്കുക, "if", "unless" എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി, "എപ്പോൾ" പ്രസ്താവനകൾ എല്ലായ്പ്പോഴും ശൂന്യമായി വിലയിരുത്തുന്നത് പരാജയപ്പെട്ടു
പട്ടിക.

എന്റെ $വില = ചെയ്യുക {
നൽകിയത് ($ഇനം) {
എപ്പോൾ (["പിയർ", "ആപ്പിൾ"]) { 1 }
"വോട്ട്" ചെയ്യുമ്പോൾ ബ്രേക്ക്; # എന്റെ വോട്ട് വാങ്ങാൻ കഴിയില്ല
1e10 എപ്പോൾ /മോണലിസ/;
"അജ്ഞാതം";
}
};

നിലവിൽ, "നൽകിയ" ബ്ലോക്കുകൾ എല്ലായ്പ്പോഴും ശരിയായ പദപ്രയോഗങ്ങളായി ഉപയോഗിക്കാൻ കഴിയില്ല. ഇതായിരിക്കാം
Perl-ന്റെ ഭാവി പതിപ്പിൽ അഭിസംബോധന ചെയ്തു.

മാറുന്നു in a ലൂപ്പ്

"Given()" ഉപയോഗിക്കുന്നതിന് പകരം നിങ്ങൾക്ക് "foreach()" ലൂപ്പ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഇതാ ഒരു വഴി
ഒരു അറേയിൽ ഒരു പ്രത്യേക സ്ട്രിംഗ് എത്ര തവണ സംഭവിക്കുന്നുവെന്ന് കണക്കാക്കാൻ:

v5.10.1 ഉപയോഗിക്കുക;
എന്റെ $എണ്ണം = 0;
വേണ്ടി (@array) {
എപ്പോൾ ("foo") { ++$count }
}
പ്രിന്റ് "\@അറേയിൽ 'foo' ന്റെ $count കോപ്പികൾ അടങ്ങിയിരിക്കുന്നു\n";

അല്ലെങ്കിൽ ഏറ്റവും പുതിയ പതിപ്പിൽ:

v5.14 ഉപയോഗിക്കുക;
എന്റെ $എണ്ണം = 0;
വേണ്ടി (@array) {
"foo" ആകുമ്പോൾ ++$count;
}
പ്രിന്റ് "\@അറേയിൽ 'foo' ന്റെ $count കോപ്പികൾ അടങ്ങിയിരിക്കുന്നു\n";

എല്ലാ "എപ്പോൾ" ബ്ലോക്കുകളുടെയും അവസാനം, ഒരു "അടുത്തത്" ഉണ്ട്. നിങ്ങൾക്ക് അത് അസാധുവാക്കാം
ആദ്യ മത്സരത്തിൽ മാത്രം നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ വ്യക്തമായ "അവസാനം".

"$item (@array)" എന്നതിലെ പോലെ നിങ്ങൾ ഒരു ലൂപ്പ് വേരിയബിൾ വ്യക്തമായി വ്യക്തമാക്കിയാൽ ഇത് പ്രവർത്തിക്കില്ല.
നിങ്ങൾ $_ എന്ന ഡിഫോൾട്ട് വേരിയബിൾ ഉപയോഗിക്കണം.

വ്യത്യാസങ്ങൾ നിന്ന് പേൾ 6

Perl 5 സ്‌മാർട്ട്‌മാച്ചും "നൽകിയ"/"എപ്പോൾ" നിർമ്മിതികളും അവയുടെ Perl 6-ന് അനുയോജ്യമല്ല
അനലോഗുകൾ. ഏറ്റവും ദൃശ്യമായ വ്യത്യാസവും ഏറ്റവും കുറഞ്ഞ വ്യത്യാസവും, Perl 5-ൽ,
ആർഗ്യുമെന്റിന് ചുറ്റും "നൽകിയ()", "എപ്പോൾ()" (ഇത് ഒഴികെ
അവസാനത്തേത് ഒരു സ്റ്റേറ്റ്മെന്റ് മോഡിഫയറായി ഉപയോഗിക്കുന്നു). പേൾ 6 ലെ പരാൻതീസിസുകൾ എയിൽ എപ്പോഴും ഓപ്ഷണലാണ്
"if()", "while()", അല്ലെങ്കിൽ "when()" എന്നിങ്ങനെയുള്ള നിയന്ത്രണ നിർമ്മാണം; അവ ഓപ്ഷണൽ ആക്കാനാവില്ല
വലിയ ആശയക്കുഴപ്പങ്ങളില്ലാതെ Perl 5, കാരണം Perl 5 പാഴ്‌സ് ചെയ്യും
പദപ്രയോഗം

$foo { നൽകി
...
}

%foo എന്ന ഹാഷിന്റെ ഒരു ഘടകമാണ് "നൽകിയത്" എന്നതിനുള്ള വാദം പോലെ, അതിനെ വ്യാഖ്യാനിക്കുന്നു
ഹാഷ്-ഘടക വാക്യഘടനയായി ബ്രേസുകൾ.

എന്നിരുന്നാലും, അവയ്ക്ക് നിരവധി, മറ്റ് നിരവധി വ്യത്യാസങ്ങളുണ്ട്. ഉദാഹരണത്തിന്, ഇത് Perl 5 ൽ പ്രവർത്തിക്കുന്നു:

v5.12 ഉപയോഗിക്കുക;
എന്റെ @പ്രൈമറി = ("ചുവപ്പ്", "നീല", "പച്ച");

എങ്കിൽ (@പ്രാഥമിക ~~ "ചുവപ്പ്") {
"പ്രാഥമിക സ്മാർട്ട് മാച്ചുകൾ ചുവപ്പ്" എന്ന് പറയുക;
}

എങ്കിൽ ("ചുവപ്പ്" ~~ @പ്രൈമറി) {
"റെഡ് സ്മാർട്ട് മാച്ചുകൾ പ്രൈമറി" എന്ന് പറയുക;
}

പറയുക "അത്രമാത്രം, ആളുകളേ!";

എന്നാൽ ഇത് Perl 6-ൽ പ്രവർത്തിക്കുന്നില്ല. പകരം, നിങ്ങൾ (സമാന്തരമാക്കാവുന്ന) "ഏതെങ്കിലും" ഉപയോഗിക്കണം.
ഓപ്പറേറ്റർ:

എന്തെങ്കിലും ഉണ്ടെങ്കിൽ (@പ്രാഥമിക) eq "ചുവപ്പ്" {
"പ്രാഥമിക സ്മാർട്ട് മാച്ചുകൾ ചുവപ്പ്" എന്ന് പറയുക;
}

"ചുവപ്പ്" എങ്കിൽ ഏതെങ്കിലും (@primary) {
"റെഡ് സ്മാർട്ട് മാച്ചുകൾ പ്രൈമറി" എന്ന് പറയുക;
}

പെർലോപ്പിലെ "സ്മാർട്ട്മാച്ച് ഓപ്പറേറ്റർ" എന്നതിലെ സ്മാർട്ട് മാച്ചുകളുടെ പട്ടിക അതിന് സമാനമല്ല
Perl 6-ഉം Perl-ഉം തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കാരണം Perl 6 സ്പെസിഫിക്കേഷൻ നിർദ്ദേശിച്ചു
5-ന്റെ ഡാറ്റാ മോഡലുകൾ, മാത്രമല്ല Perl 6-ന് കുതിച്ചുകയറിയത് മുതൽ Perl 5 സ്പെസിഫിക്കേഷൻ മാറിയതുകൊണ്ടും
നേരത്തെയുള്ള ദത്തെടുക്കൽ.

Perl 6-ൽ, "when()", Perl-ൽ ആയിരിക്കുമ്പോൾ, അതിന്റെ ആർഗ്യുമെന്റുമായി എല്ലായ്പ്പോഴും ഒരു വ്യക്തമായ സ്‌മാർട്ട് മാച്ച് നടത്തും.
5 ഈ അവ്യക്തമായ സ്‌മാർട്ട് മാച്ച് അടിച്ചമർത്തുന്നത് സൗകര്യപ്രദമാണ് (ആശയക്കുഴപ്പമുണ്ടാക്കാൻ സാധ്യതയുണ്ടെങ്കിലും)
മുകളിൽ പറഞ്ഞിരിക്കുന്നതുപോലെ, അയഞ്ഞ നിർവചിക്കപ്പെട്ട വിവിധ സാഹചര്യങ്ങൾ. (വ്യത്യാസം
പ്രധാനമായും കാരണം Perl 5 ന് ആന്തരികമായി പോലും ഒരു ബൂളിയൻ തരം ഇല്ല.)

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