ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ എക്സ്പ്രഷനുകളുടെ നിബന്ധനകളായി ഉപയോഗിക്കുന്നു, അവ രണ്ട് വിഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു: ലിസ്റ്റ് ഓപ്പറേറ്റർമാർ, യൂണറി ഓപ്പറേറ്റർമാർ. ഇത് "," - കോമ ഓപ്പറേറ്ററിലുള്ള അവരുടെ മുൻഗണനയെ ബാധിക്കുന്നു. ലിസ്റ്റ് ഓപ്പറേറ്റർമാർക്ക് നിരവധി (ലിസ്റ്റുകൾ) ആർഗ്യുമെന്റുകൾ എടുക്കാൻ കഴിയും, അതേസമയം ഏകീകൃത ഓപ്പറേറ്റർമാർക്ക് ഒരെണ്ണം മാത്രമേ എടുക്കാൻ കഴിയൂ. അങ്ങനെ, ഒരു അനിയറി ഓപ്പറേറ്ററുടെ ആർഗ്യുമെന്റുകൾ കോമ അവസാനിപ്പിക്കുകയും ഒരു ലിസ്റ്റ് ഓപ്പറേറ്ററുടെ ആർഗ്യുമെന്റുകളെ വേർതിരിക്കുകയും ചെയ്യുന്നു.
unary operator ന്റെ വാദം സാധാരണയായി ഇങ്ങനെയാണ് മനസ്സിലാക്കുന്നത് സ്കെയിലർ സന്ദർഭംസ്കെയിലർ രണ്ടിലും ലിസ്റ്റ് ചെയ്യുക
ആദ്യം വരുന്ന സ്കെയിലർ ആർഗ്യുമെന്റുകൾക്കൊപ്പം ലിസ്റ്റ്വൈസ്. ഇനിപ്പറയുന്നതിൽ, "LIST" എന്ന വാക്ക് ഉപയോഗിച്ച് ഞങ്ങൾ ലിസ്റ്റ് ആർഗ്യുമെന്റുകളെ സൂചിപ്പിക്കും, അതായത് ഫംഗ്ഷനിൽ കോമകളാൽ വേർതിരിച്ച ആർഗ്യുമെന്റുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ട്.
ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകൾ പരാൻതീസിസുകളിൽ ഉൾപ്പെടുത്താം, അങ്ങനെ "ഇതൊരു ഫംഗ്‌ഷനാണ്" എന്നും മുൻഗണന പ്രശ്നമല്ലെന്നും സൂചിപ്പിക്കാം, അല്ലാത്തപക്ഷം ഇത് ഒരു നിശ്ചിത മുൻ‌ഗണനയുള്ള ഒരു ലിസ്‌റ്റോ അനിയറി ഓപ്പറേറ്ററോ ആണ്. ഫംഗ്ഷൻ നാമത്തിനും പരാൻതീസിസിനും ശേഷമുള്ള സ്‌പെയ്‌സിന് അർത്ഥമില്ല. അതിനാൽ, ശ്രദ്ധിക്കുക!
ഉദാഹരണം:
പ്രിന്റ് 1 + 2 + 3; # ഫലം 6
പ്രിന്റ്(1+2)+3; # ഫലം 3
പ്രിന്റ് (1+2)+3; # വീണ്ടും 3
പ്രിന്റ് (1+2+3); #6
ഒരു ഫംഗ്ഷൻ സ്കെയിലറിലും ലിസ്റ്റ് സന്ദർഭത്തിലും ഒരു ഫലം നൽകുകയാണെങ്കിൽ, പിശക് എക്സിറ്റ് കോഡ് സ്കെയിലർ സി ആണ് നിർവചിക്കാത്തത്അല്ലെങ്കിൽ ഒരു ശൂന്യമായ ലിസ്റ്റ്.
നിയമം ഓർക്കുക:
ഒരു ലിസ്റ്റ് സ്കെയിലറിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിന് പൊതുവായ നിയമമൊന്നുമില്ല!
സ്കെയിലർ സന്ദർഭത്തിൽ ഓരോ ഓപ്പറേറ്റർക്കും ഫംഗ്ഷനും അതിന്റേതായ മൂല്യമുണ്ട്.
ചിലർക്ക്, ഇത് സ്കെയിലർ സന്ദർഭത്തിൽ നിന്നുള്ള മൂലകങ്ങളുടെ എണ്ണമാണ്. മറ്റുള്ളവർക്ക്, ലിസ്റ്റിലെ ആദ്യ ഘടകം അല്ലെങ്കിൽ അവസാനത്തേത് അല്ലെങ്കിൽ വിജയകരമായ പ്രവർത്തനങ്ങളുടെ എണ്ണം. നിങ്ങൾ പ്രത്യേകം സൂചിപ്പിക്കാത്ത പക്ഷം ഓരോന്നും അവരുടേതാണ്.
ഓപ്പറേറ്റർ "-X".
-എക്സ് ഫയൽ പോയിന്റർ
-എക്സ് എക്സ്പ്രഷൻ
ചുവടെ വിവരിച്ചിരിക്കുന്ന മൂല്യങ്ങളിൽ ഒന്നായ "X" ഒരു ഫയൽ പരിശോധിക്കുന്നു.
ഫയലിന്റെ പേരോ ഫയൽ പോയിന്ററോ ഉള്ള ഒരു ആർഗ്യുമെന്റുള്ള ഒരു ഏകീകൃത ഓപ്പറേറ്ററാണിത്. വ്യവസ്ഥകളിലൊന്ന് പരിശോധിക്കുന്നു. ആർഗ്യുമെന്റ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, $_ എന്ന വേരിയബിളിന്റെ മൂല്യം എടുക്കും. -t STDIN സ്വിച്ചിന്.
ഫലം 1 ശരിയാണെങ്കിൽ, "" തെറ്റാണെങ്കിൽ അല്ലെങ്കിൽ ഫയൽ കണ്ടെത്തിയില്ലെങ്കിൽ നിർവചിച്ചിട്ടില്ല. വിചിത്രമായ രൂപഭാവം ഉണ്ടായിരുന്നിട്ടും, ഇത് അനുയോജ്യമായ മുൻ‌ഗണനയുള്ള ഒരു ഏകീകൃത ഓപ്പറേറ്ററാണ്. വാദം പരാൻതീസിസിൽ ഉൾപ്പെടുത്താം.
"എക്സ്" എന്നതിന് ഇനിപ്പറയുന്ന അർത്ഥങ്ങളുണ്ട്:
-ആർഫലപ്രദമായ uid/gid ഉപയോഗിച്ച് ഫയൽ വായിക്കാനാകും
-ഡബ്ല്യുറെക്കോർഡിംഗിനായി -//-
-xവധശിക്ഷ -//-
-ഒഫലപ്രദമായ യുഐഡിയുടെ (ഉപയോക്തൃ ഐഡി)
-ആർയഥാർത്ഥ uid/gid ഉപയോഗിച്ച് ഫയൽ വായിക്കാനാകും
-ഡബ്ല്യുറെക്കോർഡിംഗിനായി -//-
-എക്സ്വധശിക്ഷ -//-
-ഒയഥാർത്ഥ യുഐഡിയുടെതാണ്
-ഇഫയൽ നിലവിലുണ്ട്
-zശൂന്യം
-എസ്ശൂന്യമല്ല
-എഫ്പ്ലെയിൻ ടെക്സ്റ്റ്
-ഡിഡയറക്ടറി
-പിപൈപ്പുകൾ (കൺവെയർ)
-എസ്സോക്കറ്റ്
-ബിപ്രത്യേക ബ്ലോക്ക് ഉപകരണം
-സി-//– പ്രതീകാത്മകം -//-
-ടിടിടി ഉപകരണത്തിലേക്കുള്ള പോയിന്റർ
-യു setuid ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു
-ജി-//– setgid
-കെ-//- പശിമയുള്ള
-ടിടെക്സ്റ്റ് ഫയൽ
-ബിബൈനറി
-എംസ്ക്രിപ്റ്റ് ആരംഭിച്ച സമയത്തെ ദിവസങ്ങളിൽ ഫയലിന്റെ "പ്രായം"
-എഅവസാന വായനയ്ക്ക് ശേഷം ദിവസങ്ങൾ
-സിഐനോഡിന്റെ അവസാന പരിഷ്‌ക്കരണത്തിന് ശേഷം ദിവസങ്ങൾ
abs എക്സ്പ്രഷൻ
ആവിഷ്കാരത്തിന്റെ സമ്പൂർണ്ണ മൂല്യം
NEWSOCKET, GENERICOCKET സ്വീകരിക്കുക
ഒരു ബാഹ്യ അഭ്യർത്ഥനയെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ സോക്കറ്റ് തുറക്കുക. സിസ്റ്റം കോൾ പോലെ തന്നെ സ്വീകരിക്കുക (). പരാജയപ്പെട്ടാൽ വിലാസം അല്ലെങ്കിൽ തെറ്റ് നൽകുന്നു.
അലാറം സെക്കന്റുകൾ
ഒരു നിശ്ചിത കാലയളവ് കഴിഞ്ഞതിന് ശേഷം നിലവിലെ പ്രക്രിയയിലേക്ക് ഒരു SIGALARM സിഗ്നൽ അയയ്‌ക്കുക. ഒരു കാലയളവിൽ ഒരേസമയം നിരവധി കോളുകൾ ചെയ്യുന്നത് അനുവദനീയമല്ല.
മുമ്പത്തെ കൗണ്ടറിന്റെ ശേഷിക്കുന്ന സമയം നൽകുന്നു.
അടൻ2 Y, X
-pi മുതൽ +pi വരെയുള്ള Y മുതൽ X വരെയുള്ള അനുപാതത്തിന്റെ ആർക്‌ടേഞ്ച്.
ബൈൻഡ് സോക്കറ്റ്, പേര്
അസൈൻ ചെയ്യുക നെറ്റ്വർക്ക് വിലാസംസോകിതു. ഒരു സിസ്റ്റം കോളിന് സമാനമാണ് ബന്ധിക്കുക. മടങ്ങുന്നു സത്യം വിജയിച്ചാൽ ഒപ്പം തെറ്റായ അല്ലാത്തപക്ഷം.
പേര് - പാക്കേജ് വിലാസംസോകിത.
binmode ഫയൽ
ബൈനറി ആക്സസ് മോഡിനായി ഫയൽ തുറക്കുക.
സാധാരണ മോഡിൽ, CR LF ഇൻപുട്ടിൽ LF ആയും LF ഔട്ട്പുട്ടിൽ CR LF ആയും വിവർത്തനം ചെയ്യപ്പെടുന്നു.
ചടങ്ങിനെ അനുഗ്രഹിക്കുക
ലിങ്ക് വ്യക്തമാക്കിയ ഒബ്‌ജക്റ്റ് ക്ലാസിന്റേതാണെന്ന് ഈ ഫംഗ്ഷൻ നിർണ്ണയിക്കുന്നു. ക്ലാസ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് നിലവിലെ ക്ലാസിനെ സൂചിപ്പിക്കുന്നു. ഇത് സാധാരണയായി ഒരു ഒബ്ജക്റ്റിന്റെ കൺസ്ട്രക്റ്ററിലെ അവസാന പ്രസ്താവനയാണ്.
നിർവചിക്കപ്പെട്ട ഒബ്‌ജക്റ്റ് ഒരു ഡിസെൻഡന്റ് ക്ലാസിന് പാരമ്പര്യമായി ലഭിക്കുമെങ്കിൽ ക്ലാസിന്റെ പേര് വ്യക്തമാക്കേണ്ടത് ആവശ്യമാണ്.
കോളർ പ്രവർത്തനം
കോളർ എക്സ്പ്രഷൻ
നിലവിലെ സബ്റൂട്ടീന്റെ കോളിംഗ് സന്ദർഭം നൽകുന്നു.
ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ, അത് eval() അല്ലെങ്കിൽ ആവശ്യമായ() ഓപ്പറേറ്റർമാർ വിളിക്കുന്ന ഒരു സബ്റൂട്ടീനോ നടപടിക്രമമോ ആണെങ്കിൽ ശരിയും അല്ലാത്തപക്ഷം തെറ്റും.
ഒരു ലിസ്റ്റ്ബോക്സിൽ ഇതൊരു ലിസ്റ്റ് ആണ് ($package, $filename, $line)
$പാക്കേജ്- പാക്കേജിന്റെ പേര്
$ഫയലിന്റെ പേര്- പാക്കേജ് ഫയലിന്റെ പേര്
$ലൈൻ- കോൾ ചെയ്ത ലൈൻ നമ്പർ.
ഒരു എക്സ്പ്രഷൻ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഒരു ലിസ്റ്റ് തിരികെ നൽകും:
($package, $filename, $line, $subroutine, $hasargs, $wantargs)
കോൾ സ്റ്റാക്ക് കാഴ്‌ചയുടെ നെസ്റ്റിംഗ് ഡെപ്‌ത്ത് എക്സ്പ്രഷൻ നിർണ്ണയിക്കുന്നു.
$സബ്റൂട്ടീൻ- സബ്റൂട്ടീന്റെ പേര്
$hasargs- ലഭ്യമായ വാദങ്ങൾ
$wantargs- ആവശ്യമായ വാദങ്ങൾ
ഒരു ഡിബി പാക്കേജിൽ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് കൂടുതൽ വിശദമായ വിവരങ്ങൾ നൽകുന്നു. @DB::args ലിസ്റ്റ് ആർഗ്യുമെന്റ് ലിസ്റ്റിൽ ചേർത്തിരിക്കുന്നു.
chdir പദപ്രയോഗം
എക്സ്പ്രഷൻ വ്യക്തമാക്കിയ ഡയറക്ടറിയിലേക്ക് പോകുക. എക്സ്പ്രഷൻ നഷ്ടപ്പെട്ടാൽ, "ഹോം" ഡയറക്ടറിയിലേക്ക് പോകുക.
വിജയത്തിൽ സത്യവും പരാജയത്തിൽ തെറ്റും തിരികെ നൽകുന്നു.
chmod ലിസ്റ്റ്
ലിസ്റ്റിൽ വ്യക്തമാക്കിയ ഫയലുകളിലേക്കുള്ള ആക്സസ് അവകാശങ്ങൾ മാറ്റുക.
ലിസ്റ്റിലെ ആദ്യ ഘടകം ഒരു സംഖ്യയാണ്, സാധാരണയായി ഒക്ടൽ, അനുമതി മൂല്യം.
അനുമതികൾ മാറ്റിയ ഫയലുകളുടെ എണ്ണം നൽകുന്നു.
chmod 0666 "f1", "f2", "f3";
chomp വേരിയബിൾ
ചോമ്പ് ലിസ്റ്റ്
വരിയുടെ അവസാനം മുതൽ $/ വേരിയബിൾ വ്യക്തമാക്കിയ പ്രതീകം നീക്കംചെയ്യുന്നു.
ഇത് സാധാരണയായി "LF" ആണ്. നീക്കം ചെയ്ത പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു. വേരിയബിൾ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, $_ വേരിയബിൾ ഉപയോഗിക്കും.
ഒരു ലിസ്റ്റ് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ലിസ്റ്റിന്റെ ഓരോ വരിയും പ്രോസസ്സ് ചെയ്യുകയും നീക്കം ചെയ്ത പ്രതീകങ്ങളുടെ എണ്ണം തിരികെ നൽകുകയും ചെയ്യും.
ചോപ്പ് വേരിയബിൾ
ചോപ്പ് ലിസ്റ്റ്
ചോമ്പ് ഫംഗ്‌ഷനുമായി പൂർണ്ണമായും സാമ്യമുള്ളതാണ്, പക്ഷേ എല്ലായ്പ്പോഴും സ്ട്രിംഗിന്റെ അവസാന പ്രതീകം നീക്കംചെയ്യുന്നു.
ചോൺ ലിസ്റ്റ്
ലിസ്റ്റ് ഫയലുകളുടെ "ഉടമ", "ഗ്രൂപ്പ്" എന്നിവ മാറ്റുക.
ആദ്യ ഘടകം പുതിയ ഉടമയുടെ സംഖ്യയാണ്, രണ്ടാമത്തെ നമ്പർ പുതിയ ഗ്രൂപ്പ്തുടർന്ന് ഫയലുകളുടെ ഒരു ലിസ്റ്റ്.
മിക്ക Unix സിസ്റ്റങ്ങളിലും, നിങ്ങൾ ഒരു സൂപ്പർ യൂസർ അല്ലാത്തപക്ഷം നിങ്ങൾക്ക് ഉടമയെ മാറ്റാൻ കഴിയില്ല, എന്നാൽ നിങ്ങളുടെ "ദ്വിതീയ" ഗ്രൂപ്പുകളിൽ ഒന്നാണെങ്കിൽ നിങ്ങൾക്ക് ഗ്രൂപ്പ് മാറ്റാൻ കഴിയും.
chr നമ്പർ
നിർദ്ദിഷ്ട എൻകോഡിംഗ് കോഡുള്ള ഒരു പ്രതീകം നൽകുന്നു.
chroot ഡയറക്ടറി
നിർദ്ദിഷ്ട ഡയറക്ടറി "റൂട്ട്" ആക്കുക.
"റൂട്ട്" എന്നതിനർത്ഥം പ്രോഗ്രാമിനുള്ളിൽ അതിനെ "" എന്ന് വിളിക്കാം എന്നാണ്. / ".
ഫയൽ അടയ്ക്കുക
ഒരു തുറന്ന ഫയലോ സ്ട്രീമോ അടയ്ക്കുക. ഉപയോഗിച്ചേക്കില്ല
അതേ ഫയൽ വീണ്ടും തുറന്നാൽ കാരണം ഒരു പുതിയ ഓപ്പൺ() കോൾ ഉപയോഗിച്ച് ഇത് യാന്ത്രികമായി അടയ്ക്കും.
Closir ഡയറക്ടറി
ഡയറക്ടറി അടയ്ക്കുക തുറന്ന പ്രവർത്തനം opendir().
കണക്ട് സോക്കറ്റ്, പേര്
റിമോട്ട് സോക്കറ്റുമായി ബന്ധപ്പെടുക. ഈ പ്രവർത്തനം ഒരു സിസ്റ്റം കോളിന് സമാനമാണ് ബന്ധിപ്പിക്കുക(). വിജയിച്ചാൽ ശരിയാണെന്ന് തിരികെ നൽകുന്നു
തെറ്റിൽ തെറ്റും.
cos എക്സ്പ്രഷൻ
പദപ്രയോഗത്തിന്റെ കോസൈൻ റേഡിയനിലാണ്.
ക്രിപ്റ്റ് ടെക്സ്റ്റ്, ഉപ്പ്
ടെക്സ്റ്റ് എൻക്രിപ്ഷൻ. സിസ്റ്റത്തിന് സമാനമാണ് crypt().
dbmclose ഹാഷ്
ഹാഷും ഡാറ്റാബേസും തമ്മിലുള്ള ബന്ധം അടയ്ക്കുന്നു.
dbmopen ഹാഷ്, ബേസ്, മോഡ്
നിർദ്ദിഷ്ട മോഡിൽ നിർദ്ദിഷ്ട ഹാഷും ബേസും ബന്ധപ്പെടുത്തുക.
dbm, ndbm, sbdm, gdbm, Berkeley DB തുടങ്ങിയ ഡാറ്റാബേസുകളിൽ പ്രവർത്തിക്കാൻ വളരെ സൗകര്യപ്രദമായ ഒരു സംവിധാനം പേൾ നടപ്പിലാക്കുന്നു എന്നതാണ് വസ്തുത. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഹാഷ് നാമത്തിൽ ഡാറ്റാബേസ് ലിങ്ക് ചെയ്യണം (തുറക്കുക). ഡാറ്റാബേസ് റെക്കോർഡുകളുള്ള എല്ലാ ജോലികളും ഒരു സാധാരണ ഹാഷ് (അസോസിയേറ്റീവ് അറേ) പോലെയാണ് ചെയ്യുന്നത്.
കൂടുതൽ വിവരങ്ങൾക്ക് ഫംഗ്ഷൻ വിവരണം കാണുക. AnyDBM().
പദപ്രയോഗം നിർവ്വചിക്കുക
മൂല്യം നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ ശരിയും (നിലവിലുണ്ട്) ഇല്ലെങ്കിൽ തെറ്റും നൽകുന്നു. ഫയലിന്റെ അവസാനത്തെ വായന, നിർവചിക്കാത്ത വേരിയബിളുകൾ, സിസ്റ്റം പിശകുകൾ മുതലായവ ഉപയോഗിച്ച് പല പ്രവർത്തനങ്ങളും നിർവചിക്കാത്ത മൂല്യത്തിൽ അവസാനിക്കുന്നു.
ഈ ഫംഗ്ഷൻ നിങ്ങളെ അസാധുവായതും നിർവചിക്കാത്തതുമായ മൂല്യങ്ങൾ തമ്മിൽ വേർതിരിച്ചറിയാൻ അനുവദിക്കുന്നു, കൂടാതെ ഫംഗ്‌ഷനുകളോ റഫറൻസുകളോ നിർവചിച്ചതാണോ അതോ നിർവചിച്ചിട്ടില്ലാത്തതാണോ എന്ന്. ഒരു ഹാഷിൽ കീ ഉറപ്പ് ഉപയോഗിക്കുമ്പോൾ, അത് ഉറപ്പായി നൽകുന്നു താക്കോൽ കൊടുത്തുഇല്ലെങ്കിലും അവൻ ഉണ്ടോ ഇല്ലയോ എന്ന്.
എക്സ്പ്രഷൻ ഇല്ലാതാക്കുക
ഒരു ഹാഷിൽ നിന്ന് ഒരു മൂല്യം നീക്കം ചെയ്യുക. നീക്കം ചെയ്യേണ്ട മൂല്യം നൽകുന്നു, അല്ലെങ്കിൽ ഒന്നും നീക്കം ചെയ്തില്ലെങ്കിൽ നിർവചിച്ചിട്ടില്ല.
$ENV() എന്ന ശ്രേണിയിൽ നിന്ന് പരിസ്ഥിതിയെ നീക്കം ചെയ്യുന്നു - പരിസ്ഥിതിയെ മാറ്റുന്നു.
ഒരു ഡാറ്റാബേസുമായി ബന്ധപ്പെട്ട ഒരു ഹാഷിൽ നിന്ന് നീക്കംചെയ്യുന്നു - ഡാറ്റാബേസിലെ ഒരു എൻട്രി ഇല്ലാതാക്കുന്നു.
മരിക്കുന്ന പട്ടിക
പ്രോഗ്രാം ആരംഭിച്ചില്ലെങ്കിൽ eval()ഈ ഫംഗ്ഷൻ STDERR സ്ട്രീമിലേക്ക് ഒരു ലിസ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുകയും $! വേരിയബിളിൽ നിന്നുള്ള കോഡ് ഉപയോഗിച്ച് പ്രോഗ്രാം അവസാനിപ്പിക്കുകയും ചെയ്യുന്നു. എങ്കിൽ $! 0, പിന്നെ കോഡ് ($? >> 8) എന്നിവ അടങ്ങിയിരിക്കുന്നു. ഇതും 0 ആണെങ്കിൽ കോഡ് 255 ഉപയോഗിച്ച്.
eval() എന്നതിൽ നിന്ന് വിളിക്കുമ്പോൾ, ഒരു പിശക് സന്ദേശം $@ വേരിയബിളിൽ സംഭരിക്കുകയും eval() നിർവചിക്കാത്ത മൂല്യത്തിൽ പരാജയപ്പെടുകയും ചെയ്യുന്നു. ഹെഡ് മൊഡ്യൂൾ ഷട്ട്ഡൗൺ ചെയ്യാതെ തന്നെ പിശക് സാഹചര്യങ്ങൾ പരിഹരിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
ലിസ്റ്റിൽ നിന്നുള്ള ഒരു വരി "\n" പ്രതീകത്തിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ, ഫംഗ്ഷൻ വിളിച്ച സ്ക്രിപ്റ്റ് ലൈനിന്റെ നമ്പറും ഇൻപുട്ട് ലൈനിന്റെ നമ്പറും ഉണ്ടെങ്കിൽ, അധികമായി പ്രിന്റ് ചെയ്യുന്നു.
BLOCK ചെയ്യുക
ഇത് ശരിക്കും ഒരു ചടങ്ങല്ല. ഇത് ബ്ലോക്കിലെ അവസാന പ്രസ്താവനയുടെ മൂല്യം നൽകുന്നു. സൈക്ലിക് മോഡിഫയർ എപ്പോൾ ഉപയോഗിക്കണം
സാധാരണ ലൂപ്പുകളിൽ നിന്ന് വ്യത്യസ്തമായി ലൂപ്പ് അവസ്ഥ പരിശോധിക്കുന്നതിന് മുമ്പ് BLOCK എക്സിക്യൂട്ട് ചെയ്യുന്നു.
സബ്റൂട്ടീൻ ചെയ്യുക
സബ്റൂട്ടീനുകളെ വിളിക്കുന്നതിനുള്ള ഒഴിവാക്കിയ രീതി.
ആവിഷ്കാരം ചെയ്യുക
പദപ്രയോഗത്തിന്റെ മൂല്യം പേൾ സ്ക്രിപ്റ്റ് ഫയലിന്റെ പേരായി വ്യാഖ്യാനിക്കപ്പെടുന്നു.
ഇത് ആദ്യം ലൈബ്രറി ദിനചര്യകൾ ഉൾപ്പെടുത്താൻ ഉപയോഗിച്ചിരുന്നു.
ഇപ്പോൾ ഉപയോഗം() ഉം ആവശ്യമുള്ള () കോളുകളും ഉപയോഗിക്കുന്നത് കൂടുതൽ ശരിയാണ്, അത് പിശകും അവസാനിപ്പിക്കൽ നിയന്ത്രണവും നൽകുന്നു.
ഡംപ് ലേബൽ
നിലവിലെ മെമ്മറിയുടെ ഒരു ഡംപ് നടത്തുന്നു. എല്ലാ വേരിയബിളുകളും സമാരംഭിച്ചതിന് ശേഷം പ്രോഗ്രാമിൽ നിലവിലുള്ള എക്സിക്യൂട്ടബിൾ കോഡ് ഉൾപ്പെടുത്താൻ undump പ്രോഗ്രാം ഉപയോഗിക്കുന്നതിന് ഇത് ഉപയോഗിച്ചു.
ഈ പുതിയ പ്രോഗ്രാമിന്റെ നിർവ്വഹണം ഒരു ഗോട്ടോ പ്രസ്താവനയോടെ ആരംഭിക്കും. ലേബൽ ഒഴിവാക്കിയാൽ, ആദ്യം മുതൽ ആരംഭിക്കുക.
ശ്രദ്ധ! ഡമ്പിന് മുമ്പ് തുറന്ന ഫയലുകൾ തുറക്കില്ല
പുതിയ പ്രോഗ്രാം നടപ്പിലാക്കുന്ന സമയത്ത്.
ഓരോ ഹാഷും
ഒരു 2-ഘടക അറേ നൽകുന്നു. ആദ്യ ഘടകം കീയാണ്, രണ്ടാമത്തേത് അടുത്ത ഹാഷ് മൂലകത്തിന്റെ മൂല്യമാണ്. ഒരു പ്രത്യേക ക്രമത്തിൽ എല്ലാ ഹാഷ് മൂല്യങ്ങളും "ബ്രൗസ്" ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. മുഴുവൻ അറേയും സഞ്ചരിച്ചതിനുശേഷം മാത്രമേ ലൂപ്പ് വേരിയബിൾ പുനഃസജ്ജീകരിക്കൂ.
eof()
അവസാനിച്ചതിന് ശേഷം വായിക്കുകയോ ഇല്ലെങ്കിൽ വായിക്കുകയോ ചെയ്താൽ 1 നൽകുന്നു ഫയൽ തുറക്കുക. ആർഗ്യുമെന്റ് നിലവിലുള്ള ഫയൽ പോയിന്റർ നൽകുന്ന ഒരു എക്സ്പ്രഷൻ ആയിരിക്കണം. ഈ പ്രവർത്തനംടെർമിനലുകളായി തുറന്ന ഫയലുകൾ വായിക്കാൻ ഉപയോഗിക്കാനാവില്ല.
ആർഗ്യുമെന്റ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അവസാനം വായിച്ച ഫയൽ ഉപയോഗിക്കും.
ഫോമിൽ eof() ഉപയോഗിക്കുന്നത് ഉപയോഗപ്രദമാണ് ലൂപ്പുകൾ സമയത്ത്(<>) അവസാനം മാത്രം നിർണ്ണയിക്കാൻ അവസാന ഫയൽനിന്ന്
പട്ടിക. ലിസ്റ്റിലെ ഓരോ ഫയലിന്റെയും അവസാനം നിർണ്ണയിക്കാൻ eof(ARGV) അല്ലെങ്കിൽ eof ഉപയോഗിക്കുക.
എവൽ എക്സ്പ്രഷൻ
എവൽ എക്സ്പ്രഷൻ
ഒരു സാധാരണ പേൾ പ്രോഗ്രാമായി എക്സ്പ്രഷൻ സ്കാൻ ചെയ്ത് എക്സിക്യൂട്ട് ചെയ്യുന്നു.
നിലവിലെ പ്രോഗ്രാമിന്റെ പശ്ചാത്തലത്തിലാണ് ഇത് ചെയ്യുന്നത്, അതിനാൽ നിങ്ങൾക്ക് ഇതിനകം നിർവചിച്ചിരിക്കുന്ന വേരിയബിളുകളും സബ്റൂട്ടീനുകളും ഉപയോഗിക്കാം.
ബ്ലോക്കിലെ അവസാന പ്രസ്താവനയുടെ ഫലം അല്ലെങ്കിൽ പ്രസ്താവനയുടെ മൂല്യം നൽകുന്നു മടങ്ങുക . കണ്ടെത്തിയാൽ വാക്യഘടന പിശക്അല്ലെങ്കിൽ പ്രസ്താവന നടപ്പിലാക്കും മരിക്കുന്നുനിർവചിക്കാത്ത മൂല്യം തിരികെ നൽകുന്നു, $@ വേരിയബിളിൽ ഒരു പിശക് സന്ദേശം അടങ്ങിയിരിക്കുന്നു. ഒരു പിശകും ഇല്ലെങ്കിൽ, $@ എന്നതിൽ ഒരു നൾ സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു. ആർഗ്യുമെന്റ് ഇല്ലെങ്കിൽ, $_ എന്ന വേരിയബിളിന്റെ മൂല്യം എടുക്കും.
എക്സിക്യൂട്ടീവ് ലിസ്റ്റ്
നിർവഹിച്ചു സിസ്റ്റം കമാൻഡ്ലിസ്റ്റിൽ നിന്നും പ്രോഗ്രാം എക്സിക്യൂഷൻ അവസാനിക്കുന്നു. നിങ്ങൾക്ക് തിരികെ പോകണമെങ്കിൽ, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതാണ് നല്ലത് സിസ്റ്റം(). ലിസ്റ്റിൽ ഒന്നിൽ കൂടുതൽ ആർഗ്യുമെന്റുകൾ ഉണ്ടെങ്കിലോ ലിസ്റ്റ് 1-ൽ കൂടുതൽ ഘടകങ്ങളുള്ള ഒരു അറേ ആണെങ്കിലോ, എക്സിക്യൂട്ട് ചെയ്യുക സിസ്റ്റം കോൾ execvp()ഒരു ലിസ്റ്റിൽ നിന്നുള്ള വാദങ്ങൾക്കൊപ്പം.
ഒരു സ്കെയിലർ ആർഗ്യുമെന്റ് ഉണ്ടെങ്കിൽ, അത് മെറ്റാക്യാരാക്‌ടറുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനായി സ്കാൻ ചെയ്യുന്നു, അവ ഉണ്ടെങ്കിൽ, തത്ഫലമായുണ്ടാകുന്ന ആർഗ്യുമെന്റുകൾ വ്യാഖ്യാതാവിന് കൈമാറും. /ബിൻ/ഷകൂടുതൽ പ്രോസസ്സിംഗിനായി -സി.
മെറ്റാക്യാരാക്‌ടറുകൾ ഇല്ലെങ്കിൽ, വാദം വാക്കുകളായി വിഭജിച്ച് സിസ്റ്റം കോളിലേക്ക് കൈമാറും execvp()കൂടുതൽ കാര്യക്ഷമമായത്.
ശ്രദ്ധ! exec()ഒപ്പം സിസ്റ്റം(0) I/O ബഫർ പുനഃസജ്ജമാക്കരുത് അതിനാൽ നിങ്ങൾ വേരിയബിൾ സജ്ജമാക്കേണ്ടതുണ്ട് $| ഔട്ട്പുട്ട് വിവരങ്ങൾ നഷ്ടപ്പെടാതിരിക്കാൻ.
എക്സ്പ്രഷൻ നിലവിലുണ്ട്
നിലവിലുണ്ടെങ്കിൽ ശരിയാണെന്ന് നൽകുന്നു വ്യക്തമാക്കിയ കീഹാഷ് അതിന്റെ മൂല്യം നിർവചിച്ചിട്ടില്ലെങ്കിലും.
എക്സിറ്റ് എക്സ്പ്രഷൻ
പ്രോഗ്രാം എക്സ്പ്രഷൻ കോഡിൽ അവസാനിക്കുന്നു.
എക്സ് എക്സ്പ്രഷൻ
എക്സ്പ്രഷന്റെ ശക്തിയിലേക്ക് e (സ്വാഭാവിക ലോഗരിതം അടിസ്ഥാനം) നൽകുന്നു.
fcntl ഫയൽ, ഫംഗ്ഷൻ, സ്കെയിലർ
fcntl() സിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഇത് ഉപയോഗിക്കുന്നതിന്, Fcntl ഉപയോഗിക്കുക എന്നത് ഉറപ്പാക്കുക;
ഫയൽ നോ ഫയൽ
നൽകിയിരിക്കുന്ന ഫയൽ പോയിന്ററിനായി ഫയൽ ഹാൻഡിൽ നൽകുന്നു.
ഫ്ലോക്ക് ഫയൽ, ഓപ്പറേഷൻ
ഫ്ലോക്ക് () സിസ്റ്റം കോൾ
നാൽക്കവല
ഫോർക്ക്() സിസ്റ്റം കോൾ. രക്ഷിതാവിന് കുട്ടിയുടെ പിഡും വിജയിച്ചാൽ കുട്ടിക്ക് 0 ഉം നൽകുന്നു, അല്ലാത്തപക്ഷം നിർവചിക്കാത്ത മൂല്യം.
ഫോർമാറ്റ്
പേൾ ഡിക്ലറേറ്റീവ് ഫംഗ്ഷൻ. പ്രസ്താവനയുടെ ഔട്ട്പുട്ട് ഫോർമാറ്റ് വ്യക്തമാക്കുന്നു എഴുതുക. വിശദാംശങ്ങൾക്ക് ചാപ്റ്റർ ഫോർമാറ്റുകൾ കാണുക.
ഫോംലൈൻ ഫോർമാറ്റ്, ലിസ്റ്റ്
ഫോർമാറ്റിൽ ഉപയോഗിക്കുന്ന ആന്തരിക പ്രവർത്തനം. ഒരു ലിസ്റ്റിൽ നിന്നുള്ള പാരാമീറ്ററുകളുടെ ഔട്ട്പുട്ട് ഫോർമാറ്റ് ചെയ്യുന്നു. ഫലം $^A വേരിയബിളിൽ സ്ഥാപിച്ചിരിക്കുന്നു. റൈറ്റ് ഫംഗ്ഷൻ ഈ വേരിയബിളിന്റെ മൂല്യം പ്രിന്റ് ചെയ്യുന്നു, പക്ഷേ ഇത് വായിക്കാനും പുനഃസജ്ജമാക്കാനും കഴിയും. സാധാരണയായി ഫോർമാറ്റ് ഒരു ഫോം ലൈനിലേക്ക് ഒരു കോൾ ചെയ്യുന്നു, എന്നാൽ ഫോംലൈൻ ഫോർമാറ്റ് ലൈനുകളെ വേർതിരിക്കുന്നില്ല. ഇതിനർത്ഥം "~", "~~" എന്നീ പ്രതീകങ്ങൾ മുഴുവൻ ഫോർമാറ്റിനെയും ഒരു വരിയായി കണക്കാക്കുന്നു, അതിനാൽ ഒരൊറ്റ ഫോർമാറ്റ് എൻട്രി വിവരിക്കാൻ മൾട്ടിലൈൻ ഫോർമിഡുകൾ ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണ്.
getc ഫയൽ
getc ഫയൽ
നിർദ്ദിഷ്ട ഫയലിൽ നിന്ന് ഒരു പ്രതീകം വായിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.
ഫയൽ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, STDIN വായിക്കും. ഫയലിന്റെ അവസാനത്തിന് ശേഷം ഒരു ശൂന്യമായ സ്ട്രിംഗ് നൽകുന്നു.
ലോഗിൻ
/etc/utmp ഫയലിൽ നിന്നുള്ള നിലവിലെ ലോഗിൻ നൽകുന്നു
ഉപയോക്താവിനെ തിരിച്ചറിയാൻ ഇത് ഉപയോഗിക്കരുത്; ഇത് getpwuid() പോലെ "അടച്ച" അല്ല.
getpeername സോക്കറ്റ്
റിമോട്ട് സോക്കറ്റിന്റെ പായ്ക്ക് ചെയ്ത വിലാസം നൽകുന്നു.
getpgrp PID
നിർദ്ദിഷ്ട PID ഉപയോഗിച്ച് പ്രോസസ് ഗ്രൂപ്പ് നൽകുന്നു. ആർഗ്യുമെന്റ് നഷ്ടപ്പെട്ടാൽ, നിലവിലെ പ്രക്രിയയുടെ ഗ്രൂപ്പ് നൽകുന്നു.
getppid
പാരന്റ് പ്രോസസിന്റെ PID നൽകുന്നു.
മുൻഗണന, WHO
ഒരു പ്രോസസ്സിന്റെയോ പ്രോസസ് ഗ്രൂപ്പിന്റെയോ ഉപയോക്താവിന്റെയോ നിലവിലെ മുൻഗണന നൽകുന്നു.
നമുക്ക് പേർൾ പഠിക്കുന്നത് തുടരാം. ഈ അധ്യായത്തിൽ നമ്മൾ ഫംഗ്ഷനുകളിലേക്ക് ശ്രദ്ധ തിരിക്കുന്നു. ഫംഗ്ഷനുകൾ എന്നത് പേരുകൾ നൽകിയിട്ടുള്ള കോഡിന്റെ ബ്ലോക്കുകളാണ്, അതിനാൽ നമുക്ക് ആവശ്യമുള്ളപ്പോൾ അവ ഉപയോഗിക്കാൻ കഴിയും. എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്ന ഭാഗങ്ങളായി നിങ്ങളുടെ കോഡ് ക്രമീകരിക്കാൻ ഫംഗ്ഷനുകൾ സഹായിക്കുന്നു. ഘട്ടം ഘട്ടമായി ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കാൻ അവർ നിങ്ങളെ അനുവദിക്കുന്നു, വഴിയിൽ അത് പരീക്ഷിക്കുന്നു.
ഒരു പ്രോഗ്രാമിനായി നിങ്ങൾക്ക് ഒരു ആശയം ലഭിച്ചുകഴിഞ്ഞാൽ, അതിന്റെ നിർമ്മാണത്തിന്റെ ഒരു ഡയഗ്രം നിങ്ങൾ വികസിപ്പിക്കണം - നിങ്ങളുടെ തലയിലോ പേപ്പറിലോ. ഡയഗ്രാമിലെ ഓരോ ഘട്ടവും നിങ്ങളുടെ പ്രോഗ്രാമിലെ ഒരു ഫംഗ്ഷനെ പ്രതിനിധീകരിക്കും. ഇതിനെ മോഡുലാർ പ്രോഗ്രാമിംഗ് എന്ന് വിളിക്കുന്നു. പ്രോഗ്രാം വിശദാംശങ്ങൾ മറയ്ക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നതിൽ മോഡുലാർ പ്രോഗ്രാമിംഗ് വളരെ നല്ലതാണ്, അതുവഴി നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ സോഴ്സ് കോഡിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നു.
ഉദാഹരണത്തിന്, നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഒരു സർക്കിളിന്റെ വിസ്തീർണ്ണം കണക്കാക്കുന്ന ഒരു ഫംഗ്ഷൻ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അതിനെ ഇനിപ്പറയുന്ന വരിയിൽ വിളിക്കാം:
$areaOfFirstCircle = areaOfCircle($firstRadius);
ഇതുപോലുള്ള ഫംഗ്ഷൻ കോളുകൾ നോക്കുമ്പോൾ, വായിക്കുന്ന വ്യക്തി ഉറവിടംനിങ്ങളുടെ പ്രോഗ്രാം, നിങ്ങളുടെ പ്രോഗ്രാം എന്താണ് ചെയ്യുന്നതെന്ന് മനസ്സിലാക്കുന്നു. അതേ സമയം, ഈ അല്ലെങ്കിൽ ആ ഫംഗ്ഷൻ എങ്ങനെ കൃത്യമായി നടപ്പിലാക്കുന്നുവെന്ന് അയാൾക്ക് അറിയേണ്ടതില്ല. അതിനാൽ, ഫംഗ്ഷനുകൾക്ക് “പറയുന്ന” പേരുകൾ നൽകേണ്ടത് പ്രധാനമാണ് - അതുവഴി ഫംഗ്ഷൻ കൃത്യമായി എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് മനസിലാക്കാൻ കഴിയും.
ഒരു ഫംഗ്ഷൻ കോൾ അർത്ഥമാക്കുന്നത്, ഫംഗ്ഷനെ വിളിക്കുന്ന പോയിന്റിലെ പെർൾ ഇന്റർപ്രെട്ടർ നിലവിലെ കോഡിന്റെ വരികളുടെ പ്രവർത്തനം നിർത്തുകയും ഫംഗ്ഷൻ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിലേക്ക് നീങ്ങുകയും ചെയ്യുന്നു എന്നാണ്. ഫംഗ്ഷൻ കോഡ് പൂർത്തിയാകുമ്പോൾ, ഇന്റർപ്രെറ്റർ കോൾ പോയിന്റിലേക്ക് മടങ്ങുകയും അടുത്ത വരിയിൽ നിന്ന് പ്രോഗ്രാം എക്സിക്യൂഷൻ തുടരുകയും ചെയ്യുന്നു.
നമുക്ക് ഫംഗ്ഷൻ കോൾ സൂക്ഷ്മമായി പരിശോധിക്കാം - ആദ്യം നമ്മൾ സ്കെലാർ വേരിയബിളും പിന്നീട് അസൈൻമെന്റ് ഓപ്പറേറ്ററും കാണുന്നു. ഇതിന്റെ അർത്ഥമെന്താണെന്ന് നിങ്ങൾക്ക് ഇതിനകം തന്നെ അറിയാം - അസൈൻമെന്റ് ചിഹ്നത്തിന്റെ വലതുവശത്തുള്ള മൂല്യം $areaOfFirstCircle വേരിയബിളിനെ Perl നിയോഗിക്കും. എന്നാൽ യഥാർത്ഥത്തിൽ വലതുവശത്ത് എന്താണ് ഉള്ളത്?
ഏരിയഓഫ് സർക്കിൾ() എന്ന ഫംഗ്ഷൻ നാമമാണ് നിങ്ങൾ ആദ്യം കാണുന്നത്. വലത് പരാൻതീസിസും പേരിന് മുമ്പുള്ള $, @, % ചിഹ്നങ്ങളുടെ അഭാവവും ഇതൊരു ഫംഗ്ഷൻ കോളാണെന്ന് സൂചിപ്പിക്കുന്നു. പരാൻതീസിസിനുള്ളിൽ ഫംഗ്ഷനിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെയോ മൂല്യങ്ങളുടെയോ ഒരു ലിസ്റ്റ് ഉണ്ട്.
ഒരു സർക്കിളിന്റെ വിസ്തീർണ്ണത്തിന്റെ കണക്കുകൂട്ടൽ:
$areaOfFirstCircle = areaOfCircle(5);
പ്രിന്റ് ("$areaOfFirstCircle\n");
ഉപ മേഖലഓഫ് സർക്കിൾ(
$ ആരം = $_;
മടക്കം (3.1415 * ($ ആരം ** 2));
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
പ്രവർത്തന പ്രഖ്യാപനം:
ഉപ ഫംഗ്ഷൻ പേര് (
പ്രവർത്തന ശരീരം
}
അത്രയേയുള്ളൂ. നിങ്ങളുടെ പ്രവർത്തനം തയ്യാറാണ്.
പരാമീറ്ററുകൾ ഉപയോഗിച്ച് സ്ഥിതി കൂടുതൽ സങ്കീർണ്ണമാണ്. ഫംഗ്ഷനിലേക്ക് നമ്മൾ കൈമാറുന്ന മൂല്യങ്ങളാണ് പാരാമീറ്ററുകൾ. ഫംഗ്ഷൻ നാമത്തിനു തൊട്ടുപിന്നാലെ പരാൻതീസിസിനുള്ളിൽ പരാമീറ്ററുകൾ അടങ്ങിയിരിക്കുന്നു. മുകളിലെ ഉദാഹരണത്തിൽ, ഫംഗ്ഷൻ കോൾ ഏരിയഓഫ് സർക്കിൾ (5) ആണ്. ഇവിടെ നമ്മൾ ഒരു പരാമീറ്റർ മാത്രമേ ഉപയോഗിച്ചിട്ടുള്ളൂ. ഒരു ഫംഗ്ഷന് ഒരു പരാമീറ്റർ മാത്രമേ ഉള്ളൂവെങ്കിലും, ഫംഗ്ഷനെ വിളിക്കുമ്പോൾ, ഫംഗ്ഷന് ഉപയോഗിക്കുന്നതിന് Perl, പരാമീറ്ററുകളുടെ ഒരു നിര സൃഷ്ടിക്കുന്നു.
ഫംഗ്‌ഷനുള്ളിൽ, പരാമീറ്റർ അറേയെ @_ എന്ന് നാമകരണം ചെയ്യുന്നു. ഫംഗ്ഷനിലേക്ക് കൈമാറിയ എല്ലാ പാരാമീറ്ററുകളും @_ അറേയിൽ അടങ്ങിയിരിക്കുന്നു, ആവശ്യമെങ്കിൽ അവ വീണ്ടെടുക്കാൻ കഴിയും.
മുകളിലുള്ള ഉദാഹരണത്തിൽ നിന്നുള്ള ഞങ്ങളുടെ ചെറിയ പ്രവർത്തനം ഇനിപ്പറയുന്ന വരി ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും:
$ ആരം = $_;
ഈ ലൈൻ @_ അറേയുടെ ആദ്യ ഘടകം $റേഡിയസ് എന്ന സ്കെയിലർ വേരിയബിളിലേക്ക് നൽകുന്നു.
നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഒരു മൂല്യം നൽകുന്നതിന് ഫംഗ്ഷനിൽ ഒരു റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കേണ്ടതില്ല; അവസാനമായി വിലയിരുത്തിയ എക്‌സ്‌പ്രഷനിന്റെ മൂല്യം പേൾ സ്വയമേവ തിരികെ നൽകും. എന്നാൽ നിങ്ങൾ ഇപ്പോഴും റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുന്നതാണ് നല്ലത് - ഈ രീതിയിൽ നിങ്ങൾ ആകസ്മികമായ നിരവധി പിശകുകൾ ഒഴിവാക്കും.
ചില പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ സബ്റൂട്ടീനുകളും ഫംഗ്ഷനുകളും തമ്മിലുള്ള വ്യത്യാസം നിങ്ങൾ കണ്ടിരിക്കാം. അത്തരം ഭാഷകളിൽ, ഒരു ഫംഗ്ഷൻ അനിവാര്യമായും ഒരു മൂല്യം നൽകുന്നു, അതേ സമയം, ഒരു സബ്റൂട്ടീൻ ഒരു മൂല്യം നൽകുന്നില്ല. Perl-ൽ അത്തരത്തിലുള്ള ഒന്നുമില്ല - നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ മാത്രമേയുള്ളൂ - അത് എന്തെങ്കിലും മൂല്യം നൽകുന്നുണ്ടോ ഇല്ലയോ എന്നത് പരിഗണിക്കാതെ തന്നെ.
ഒരു പാരാമീറ്റർ അറേ ഉപയോഗിക്കുന്നു (@_)
നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, @_ എന്ന പാരാമീറ്റർ അറേയിലെ എല്ലാ പാരാമീറ്ററുകളും ഫംഗ്ഷന് കണ്ടെത്താനാകും. ഇത് വളരെ സൗകര്യപ്രദമാണ് - ഒരു ഫംഗ്ഷനിലേക്ക് എത്ര പാരാമീറ്ററുകൾ കൈമാറിയെന്ന് കണ്ടെത്താൻ, നിങ്ങൾ @_ പാരാമീറ്റർ അറേ ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ ആക്സസ് ചെയ്യേണ്ടതുണ്ട്.
ഫസ്റ്റ് സബ്(1, 2, 3, 4, 5, 6);
ഫസ്റ്റ് സബ്(1..3);
firstSub("A".."Z");
സബ് ഫസ്റ്റ് സബ്(
$numParameters = @_ ;
പ്രിന്റ് ("പരാമീറ്ററുകളുടെ എണ്ണം $numParameters\n");
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
പരാമീറ്ററുകളുടെ എണ്ണം 6 ആണ്
പരാമീറ്ററുകളുടെ എണ്ണം 3 ആണ്
പരാമീറ്ററുകളുടെ എണ്ണം 26 ആണ്
ഒരു ഫംഗ്ഷനിലേക്ക് എത്ര പാരാമീറ്ററുകൾ വേണമെങ്കിലും കൈമാറാൻ Perl നിങ്ങളെ അനുവദിക്കുന്നു. ഏത് പാരാമീറ്ററുകൾ ഉപയോഗിക്കണമെന്നും ഏത് ക്രമത്തിൽ ഉപയോഗിക്കണമെന്നും ഫംഗ്ഷന് തന്നെ നിർണ്ണയിക്കാനാകും. മറ്റേതൊരു അറേയും പോലെ @_ പാരാമീറ്റർ അറേ ഉപയോഗിക്കാനാകും.
തീർച്ചയായും, ഒരു ഫംഗ്ഷനിലേക്ക് അയച്ച പാരാമീറ്ററുകൾ അവയുടെ നമ്പറുകൾ ഉപയോഗിച്ച് ആക്സസ് ചെയ്യുന്നത് വളരെ സൗകര്യപ്രദമല്ല - @_ അല്ലെങ്കിൽ @_. നിങ്ങൾക്ക് കൂടുതൽ സൗകര്യപ്രദമായ സാങ്കേതികവിദ്യ ഉപയോഗിക്കാം:
ദീർഘചതുരം (2, 3);
ദീർഘചതുരം (5, 6);
ദീർഘചതുരത്തിന്റെ ഉപ പ്രദേശം(
($ ഉയരം, $ വീതി) = @_ ;
$ ഏരിയ = $ ഉയരം * $ വീതി;
പ്രിന്റ് ("ഉയരം $ ഉയരമാണ്. വീതി $ വീതിയാണ്. ഏരിയ $ ഏരിയയാണ്.\n\n");
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
ഉയരം 2. വീതി 3. വിസ്തീർണ്ണം 6.
ഉയരം 5. വീതി 6. വിസ്തീർണ്ണം 30.
നിങ്ങൾ ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു സംഖ്യയെക്കാൾ ഒരു വേരിയബിളാണ് കൈമാറുന്നതെങ്കിൽ, ഫംഗ്ഷനിൽ അതിന്റെ മൂല്യം മാറുകയാണെങ്കിൽ, ബാക്കിയുള്ള പ്രോഗ്രാമുകൾക്കും അത് മാറുന്നു. ഇതിനെ റഫറൻസ് വഴി പാസിംഗ് പാരാമീറ്ററുകൾ എന്ന് വിളിക്കുന്നു.
@അറേ = (0..5);
firstSub(@array);
സബ് ഫസ്റ്റ് സബ്(
$_ = "എ";
$_ = "ബി";
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
ഫംഗ്ഷൻ കോളിന് ശേഷം, അറേ = A B 2 3 4 5
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഫംഗ്ഷൻ അതിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെ മൂല്യം മാറ്റി, ഇത് പ്രോഗ്രാമിന്റെ ബാക്കി ഭാഗങ്ങളെയും ബാധിച്ചു - @array അറേയുടെ മൂല്യങ്ങൾ ഫംഗ്ഷന് മാത്രമല്ല, ബാക്കി പ്രോഗ്രാമുകൾക്കും മാറി. . ഇതൊരു മോശം പ്രോഗ്രാമിംഗ് പരിശീലനമാണ് - നിങ്ങൾക്ക് അത്തരമൊരു നിർദ്ദിഷ്ട ലക്ഷ്യമില്ലെങ്കിൽ, അത്തരം ബോണസുകൾ ഒരിക്കലും ഉപയോഗിക്കരുത് - അവ വ്യക്തമല്ലാത്ത പിശകുകളാൽ നിറഞ്ഞതാണ്. മറുവശത്ത്, ഫംഗ്ഷന്റെ തുടക്കത്തിൽ നിങ്ങൾ പാസ്സാക്കിയ പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ പുതിയ വേരിയബിളുകളിലേക്ക് (നേരത്തെ കാണിച്ചിരിക്കുന്നതുപോലെ) നിയോഗിക്കുകയും പിന്നീട് അവയിൽ മാത്രം പ്രവർത്തിക്കുകയും ചെയ്താൽ, നിങ്ങൾക്ക് അത്തരമൊരു പ്രശ്നം ഉണ്ടാകില്ല - കാരണം ഈ സാഹചര്യത്തിൽ ഫംഗ്ഷൻ പാരാമീറ്ററുകളിലേക്ക് കൈമാറിയ മൂല്യങ്ങൾ നിങ്ങൾ യഥാർത്ഥത്തിൽ മാറ്റുന്നില്ല.
അതേ പ്രോഗ്രാമിന്റെ ഒരു ഉദാഹരണം ഇതാ, എന്നാൽ കൂടുതൽ ശരിയായി എഴുതിയിരിക്കുന്നു:
@അറേ = (0..5);
പ്രിന്റ് ("fuNCtion കോളിന് മുമ്പ്, അറേ = @array\n");
firstSub(@array);
പ്രിന്റ് ("fuNCtion കോളിന് ശേഷം, അറേ = @array\n");
സബ് ഫസ്റ്റ് സബ്(
$firstVar = "A";
$secondVar = "B";
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
ഫംഗ്ഷൻ കോളിന് മുമ്പ്, അറേ = 0 1 2 3 4 5
ഫംഗ്ഷൻ കോളിന് ശേഷം, അറേ = 0 1 2 3 4 5
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഫംഗ്ഷൻ അതിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ പുതിയ വേരിയബിളുകളിലേക്ക് നിയോഗിക്കുന്നു, തുടർന്ന് അവയിൽ മാത്രം പ്രവർത്തിക്കുന്നു - പാരാമീറ്ററുകളുടെ നിര നേരിട്ട് മാറ്റാതെ.
എന്നാൽ നിങ്ങൾക്ക് മറ്റൊരു പ്രശ്നം നേരിടാം:
$firstVar = 10;
@അറേ = (0..5);
പ്രിന്റ് ("ഫൺക്ഷൻ കോളിന് മുമ്പ്\n");
പ്രിന്റ് ("\tarray = @array\n");
firstSub(@array);
പ്രിന്റ് ("ഫൺക്ഷൻ കോളിന് ശേഷം\n");
പ്രിന്റ് ("\tfirstVar = $firstVar\n");
പ്രിന്റ് ("\tarray = @array\n");
സബ് ഫസ്റ്റ് സബ്(
($firstVar, $secondVar) = @_ ;
$firstVar = "A";
$secondVar = "B";
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
ഫംഗ്ഷൻ കോളിന് മുമ്പ്
firstVar = 10
അറേ = 0 1 2 3 4 5
ഫംഗ്ഷൻ കോൾ കഴിഞ്ഞ്
ആദ്യവാർ = എ
അറേ = 0 1 2 3 4 5
അതായത്, സ്ഥിരസ്ഥിതിയായി, ഒരു പേൾ പ്രോഗ്രാമിലെ എല്ലാ വേരിയബിളുകളും ഏത് കോഡിൽ നിന്നും ആക്സസ് ചെയ്യാൻ കഴിയും. പല കേസുകളിലും ഇത് വളരെ സൗകര്യപ്രദമാണ്, പക്ഷേ പലപ്പോഴും അസൗകര്യങ്ങൾ ഉണ്ടാക്കുകയും അസുഖകരമായ പിശകുകളിലേക്ക് നയിക്കുകയും ചെയ്യുന്നു. അടുത്തതായി, അതത് ഫംഗ്ഷനുകളിൽ മാത്രം ദൃശ്യമാകുന്ന വേരിയബിളുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും.
വേരിയബിളുകളുടെ വ്യാപ്തി.
നിങ്ങൾക്ക് തന്നിരിക്കുന്ന വേരിയബിൾ ഉപയോഗിക്കാനാകുന്ന കോഡിന്റെ ഭാഗങ്ങളാണ് വേരിയബിൾ സ്കോപ്പുകൾ. സ്ഥിരസ്ഥിതിയായി, ഒരു Perl പ്രോഗ്രാമിലെ ഏത് വേരിയബിളും പ്രോഗ്രാമിൽ എവിടെനിന്നും "ദൃശ്യമാണ്".
ഒരു ഫംഗ്ഷനിൽ ഒരു പ്രത്യേക വേരിയബിളിന്റെ വ്യാപ്തി പരിമിതപ്പെടുത്തുന്നത് ചിലപ്പോൾ വളരെ ഉപയോഗപ്രദമാണ്. ഈ സാഹചര്യത്തിൽ, ഫംഗ്ഷനിലെ ഒരു വേരിയബിളിന്റെ മൂല്യം മാറ്റുന്നത് പ്രോഗ്രാമിന്റെ ബാക്കി ഭാഗങ്ങളെ ഒരു തരത്തിലും ബാധിക്കില്ല. പേളിന് രണ്ട് ഫംഗ്ഷനുകളുണ്ട് - my() ഉം ലോക്കൽ(). ആദ്യത്തേത് തന്നിരിക്കുന്ന ഫംഗ്ഷനിൽ മാത്രം ദൃശ്യമാകുന്ന ഒരു വേരിയബിൾ സൃഷ്ടിക്കുന്നു. രണ്ടാമത്തേത് ഒരു വേരിയബിൾ സൃഷ്ടിക്കുന്നു, അത് ഈ ഫംഗ്ഷനിൽ നിന്ന് വിളിക്കപ്പെടുന്ന ഫംഗ്ഷനുകൾ വഴിയും "കാണാൻ" കഴിയും.
firstSub("AAAAA", "BBBBB");
സബ് ഫസ്റ്റ് സബ്(
ലോക്കൽ($firstVar) = $_;
my($secondVar) = $_;
secondSub();
പ്രിന്റ് ("firstSub: firstVar = $firstVar\n");
പ്രിന്റ് ("firstSub: secondVar = $secondVar\n\n");
}
ഉപ സെക്കന്റ് സബ്(
$firstVar = "ccccC";
$secondVar = "DDDDD";
പ്രിന്റ് ("secondSub: firstVar = $firstVar\n");
പ്രിന്റ് ("secondSub: secondVar = $secondVar\n\n");
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
firstSub: firstVar = AAAAAA
firstSub: secondVar = BBBBB
secondSub: firstVar = AAAAA
test.pl വരി 19-ൽ ആരംഭിക്കാത്ത മൂല്യത്തിന്റെ ഉപയോഗം.
secondSub: secondVar =
secondSub: firstVar = ccccC
secondSub: secondVar = DDDDD
firstSub: firstVar = ccccC
firstSub: secondVar = BBBBB
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, secondSub() ഫംഗ്ഷന് $secondVar വേരിയബിളിലേക്ക് ആക്സസ് ഇല്ല, ഇത് firstSub() ഫംഗ്ഷനിലെ my() ഫംഗ്ഷൻ സൃഷ്‌ടിച്ചതാണ്. ഇതിനെക്കുറിച്ച് മുന്നറിയിപ്പ് നൽകുന്ന ഒരു സന്ദേശം പോലും പേൾ പ്രദർശിപ്പിക്കുന്നു. അതേ സമയം, $firstVar വേരിയബിൾ ലഭ്യമാണ്, അത് secondSub() ഫംഗ്ഷൻ വഴി മാറ്റാവുന്നതാണ്.
സാധ്യമെങ്കിൽ, my() ഫംഗ്ഷൻ മാത്രം ഉപയോഗിക്കാൻ ശ്രമിക്കുക, ലോക്കൽ() ഫംഗ്ഷൻ ഉപയോഗിക്കരുത് - ഇത് നിങ്ങളുടെ വേരിയബിളുകളുടെ വ്യാപ്തിയിൽ കൂടുതൽ നിയന്ത്രണം നൽകും.
വാസ്തവത്തിൽ, my() ഫംഗ്ഷൻ കൂടുതൽ സങ്കീർണ്ണവും പ്രവർത്തനപരവുമാണ്. എന്നാൽ ഇത് അദ്ധ്യായം 15-ൽ ചർച്ച ചെയ്യും - "Perl Modules".
റഫറൻസും മൂല്യവും അനുസരിച്ച് ഫംഗ്ഷൻ പാരാമീറ്ററുകൾ കൈമാറുന്നത് തമ്മിലുള്ള വ്യത്യാസം നിങ്ങൾ ഓർക്കുന്നുണ്ടോ? നിങ്ങൾ മൂല്യമനുസരിച്ച് പാരാമീറ്ററുകൾ കൈമാറുകയാണെങ്കിൽ, ഫംഗ്ഷന് അതിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെ (വേരിയബിളുകൾ) മൂല്യങ്ങൾ മാറ്റാൻ കഴിയില്ല, അതായത് ഇത് മുഴുവൻ പ്രോഗ്രാമിനെയും ഒരു തരത്തിലും ബാധിക്കില്ല. നിങ്ങൾ റഫറൻസ് വഴി പാരാമീറ്ററുകൾ പാസാക്കുകയാണെങ്കിൽ, ഫംഗ്ഷന് പാരാമീറ്ററുകളുടെ (വേരിയബിളുകൾ) മൂല്യങ്ങൾ മാറ്റാൻ കഴിയും, ഇത് പ്രധാന പ്രോഗ്രാമിൽ പ്രതിഫലിക്കും. അതിനാൽ, ലോക്കൽ () ഫംഗ്ഷൻ ഉപയോഗിക്കുമ്പോൾ, റഫറൻസ് വഴി പാരാമീറ്ററുകൾ കൈമാറുന്ന രീതി അല്പം വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്നു - ഫംഗ്ഷനുകൾക്ക് അവയ്ക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെ (വേരിയബിളുകൾ) മൂല്യങ്ങൾ മാറ്റാൻ കഴിയും, പക്ഷേ ഇത് "ടോപ്പ്" ഫംഗ്ഷനെ മാത്രമേ ബാധിക്കുകയുള്ളൂ - ലോക്കൽ (ഫംഗ്ഷൻ ഉപയോഗിച്ചത്), - ഇത് പ്രധാന പ്രോഗ്രാമിനെ ഒരു തരത്തിലും ബാധിക്കില്ല.
ഒരു ഫംഗ്ഷൻ പാരാമീറ്ററായി ഒരു ലിസ്റ്റ് ഉപയോഗിക്കുന്നു.
ഇപ്പോൾ നമുക്ക് വേരിയബിളുകളുടെ വ്യാപ്തി മനസ്സിലായി, മറ്റൊരു വീക്ഷണകോണിൽ നിന്ന് ഫംഗ്ഷൻ പാരാമീറ്ററുകൾ നോക്കാം. ഞങ്ങൾ ഇതിനകം പറഞ്ഞതുപോലെ, എല്ലാ ഫംഗ്ഷൻ പാരാമീറ്ററുകളും ഒരു അറേയിൽ കടന്നുപോകുന്നു, എന്നാൽ നിങ്ങൾ ഫംഗ്ഷനിലേക്ക് ഒരു പാരാമീറ്റർ കൈമാറണമെങ്കിൽ - ഒരു സ്കെയിലർ, രണ്ടാമത്തെ പാരാമീറ്റർ - ഒരു അറേ? എന്ത് സംഭവിക്കുമെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു:
firstSub((0..10), "AAAA");
സബ് ഫസ്റ്റ് സബ്(
ലോക്കൽ(@അറേ, $firstVar) = @_ ;
പ്രിന്റ് ("firstSub: firstVar = $firstVar\n");
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
firstSub: array = 0 1 2 3 4 5 6 7 8 9 10 AAAA
test.pl വരി 8-ൽ ആരംഭിക്കാത്ത മൂല്യത്തിന്റെ ഉപയോഗം.
firstSub: firstVar =
വേരിയബിളുകൾ സമാരംഭിക്കുമ്പോൾ, @array @_ പാരാമീറ്റർ അറേയുടെ എല്ലാ ഘടകങ്ങളും ആഗിരണം ചെയ്യുന്നു, $firstVar സ്കെയിലർ വേരിയബിളിന് പിന്നിൽ ഒന്നും തന്നെ അവശേഷിപ്പിക്കുന്നില്ല. പേൾ ഇന്റർപ്രെറ്ററിൽ നിന്നുള്ള മുന്നറിയിപ്പ് സന്ദേശം ഇത് സ്ഥിരീകരിക്കുന്നു. പരാമീറ്ററുകൾ സ്വാപ്പ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ഈ പ്രശ്നം പരിഹരിക്കാൻ കഴിയും - നിങ്ങൾ ആദ്യം ഒരു സ്കെയിലർ വേരിയബിളും പിന്നീട് ഒരു അറേയും ഇടുകയാണെങ്കിൽ, എല്ലാം ചെയ്യേണ്ടത് പോലെ ആയിരിക്കും:
firstSub("AAAA", (0..10));
സബ് ഫസ്റ്റ് സബ്(
ലോക്കൽ($firstVar, @array) = @_ ;
പ്രിന്റ് ("firstSub: array = @array\n");
പ്രിന്റ് ("firstSub: firstVar = $firstVar\n");
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
firstSub: array = 0 1 2 3 4 5 6 7 8 9 10
firstSub: firstVar = AAAA
നിങ്ങൾക്ക് ഫംഗ്ഷനിലേക്ക് നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര സ്കെലാർ മൂല്യങ്ങൾ കൈമാറാൻ കഴിയും, എന്നാൽ ഒരു അറേ മാത്രം. നിങ്ങൾ ഒരു ഫംഗ്ഷനിലേക്ക് ഒന്നിലധികം അറേകൾ കൈമാറാൻ ശ്രമിക്കുകയാണെങ്കിൽ, അവയുടെ ഘടകങ്ങൾ ഒരു അറേയിലേക്ക് ലയിക്കും, കൂടാതെ ഒരു അറേ എവിടെ അവസാനിക്കുന്നുവെന്നും മറ്റൊന്ന് ആരംഭിക്കുന്നുവെന്നും ഫംഗ്ഷന് അറിയാൻ കഴിയില്ല.
നെസ്റ്റഡ് (ആവർത്തന) പ്രവർത്തനങ്ങൾ.
പ്രവർത്തനങ്ങൾക്ക് സ്വയം വിളിക്കാൻ കഴിയും, നിരവധി തലങ്ങൾ ആഴത്തിൽ പോകുന്നു. എത്രത്തോളം പെർൾ നടപ്പിലാക്കൽ, നിർദ്ദിഷ്ട ഹാർഡ്‌വെയർ, കോൺഫിഗറേഷൻ എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു. സാധാരണയായി, നിങ്ങളുടെ മെഷീന്റെ ഉറവിടങ്ങൾ മതിയാകും, നിങ്ങൾ അതിനെക്കുറിച്ച് വിഷമിക്കേണ്ടതില്ല. എന്നാൽ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഈ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കാം:
FirstSub();
സബ് ഫസ്റ്റ് സബ്(
പ്രിന്റ് ("$count\n");
$count++;
firstSub();
}
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
പിശക്: റൺടൈം ഒഴിവാക്കൽ
ഈ പിശക് സന്ദേശം അച്ചടിക്കുന്നതിന് മുമ്പ്, പ്രോഗ്രാം $count വേരിയബിളിന്റെ മൂല്യം കഴിയുന്നിടത്തോളം വർദ്ധിപ്പിക്കും. ആവർത്തന കോൾപ്രവർത്തനങ്ങൾ. അതിനാൽ, $count വേരിയബിളിന്റെ മൂല്യം അനുസരിച്ച്, നിങ്ങളുടെ സിസ്റ്റം എത്ര ലെവലുകൾ ആവർത്തന കോളുകൾ അനുവദിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് പറയാൻ കഴിയും.
എന്നാൽ ആവർത്തനത്തിൽ അകപ്പെടരുത് - പ്രത്യേക സന്ദർഭങ്ങളിൽ ഇത് സൂക്ഷ്മമായി പഠിക്കുന്നത് മൂല്യവത്താണ്, ഉദാഹരണത്തിന്, ചില ഗണിതശാസ്ത്ര കണക്കുകൂട്ടലുകളിൽ.
സ്വകാര്യ പ്രവർത്തനങ്ങൾ.
നിങ്ങൾ ഒരു സ്കോപ്പ്ഡ് ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടി വന്നേക്കാം. വേരിയബിളുകൾ ഉപയോഗിച്ച് ഇത് എങ്ങനെ ചെയ്യാമെന്ന് ഞങ്ങൾ ഇതിനകം കണ്ടെത്തിയിട്ടുണ്ട്. ഫംഗ്‌ഷനുകൾക്കൊപ്പം ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇതാ:
$ temp = പെർഫോമൻസ് Calc(10, 10);
പ്രിന്റ് ("താപനില = $temp\n");
സബ് പെർഫോമൻസ് കാൽക്(
എന്റെ ($firstVar, $secondVar) = @_;
എന്റെ $സ്ക്വയർ = ഉപ (
മടക്കം ($_**2);
};
റിട്ടേൺ(&$ സ്ക്വയർ($firstVar) + &$square($secondVar));
};
പ്രോഗ്രാം പ്രിന്റ് ചെയ്യും:
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഞങ്ങൾക്ക് ഒരു $ സ്ക്വയർ ഫംഗ്ഷൻ ഉണ്ട്. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഒരു ഫംഗ്ഷനെ സൂചിപ്പിക്കുന്ന ഒരു സാധാരണ സ്കെയിലർ വേരിയബിളാണ് $സ്ക്വയർ. ഒരു ഫംഗ്ഷൻ റഫർ ചെയ്യുന്നതിന്, ഞങ്ങൾ $സ്ക്വയർ വേരിയബിൾ നെയിമിന് മുന്നിൽ & സൈൻ ഉപയോഗിക്കുന്നു. PerformCalc() ഫംഗ്ഷനിൽ മാത്രമേ നമുക്ക് ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ കഴിയൂ - ഇത് പ്രോഗ്രാമിന്റെ ബാക്കി ഭാഗങ്ങളിൽ ലഭ്യമല്ല.
: അടൻ2 നമ്പർ1, നമ്പർ2 വാദങ്ങൾ: നമ്പർ1, നമ്പർ2സംഖ്യാ പദപ്രയോഗങ്ങൾ ഫലമായി: സംഖ്യാ മൂല്യം
ഫംഗ്ഷൻ അവൻ2വിഭജനത്തിന്റെ ഘടകത്തിന്റെ ആർക്റ്റാൻജന്റ് നൽകുന്നു നമ്പറുകൾ1ഓൺ നമ്പർ2. ഫലം -π മുതൽ +π വരെയുള്ള ശ്രേണിയിലാണ്, കൂടാതെ x-അക്ഷത്തിനും വെക്‌ടറിനും ഇടയിലുള്ള റേഡിയനിലെ കോണുമായി കോർഡിനേറ്റുകളുള്ള പോയിന്റുമായി പൊരുത്തപ്പെടുന്നു ( നമ്പർ2, നമ്പർ1). ഉദാഹരണങ്ങൾ:
$x = അടൻ2 -0, -1; # x -3.14159265358979 $x = അടൻ2 -1, 0; # x തുല്യം -1.5707963267949 $x = അടൻ2 0, 1; # x സമം 0 $x = അടൻ2 1, 1; # x തുല്യം 0.785398163397448 $x = അടൻ2 1, 0; # x എന്നത് 1.5707963267949 $x = അടൻ2 0, -1 ന് തുല്യമാണ്; # x സമം 3.14159265358979
cos ഫംഗ്ഷൻ
വാക്യഘടന :cos നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ കോസ്കോസൈൻ തിരികെ നൽകുന്നു സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ
$pi = അടൻ2 0, -1; $x = cos 0; # x തുല്യം 1 $x = cos $pi/2; # x എന്നത് 6e-17 ആണ് (ഏതാണ്ട് 0) $x = cos $pi; # x തുല്യം -1
എക്സ്ഫംഗ്ഷൻ
വാക്യഘടന : exp നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ exറിട്ടേൺസ് എക്‌സ്‌പോണന്റ് സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. എങ്കിൽ നമ്പർ 709.78 നേക്കാൾ വലുതാണ്, തുടർന്ന് 1.#INF തിരികെ നൽകും. ഉദാഹരണം:
പ്രിന്റ് എക്സ്പ് 1; #2.71828182845905
int ഫംഗ്ഷൻ
വാക്യഘടന : int നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ intമുഴുവൻ ഭാഗവും തിരികെ നൽകുന്നു സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ
ഇൻറ്റ് 1.5 പ്രിന്റ് ചെയ്യുക; #1 പ്രിന്റ് ഇന്റ് -1.5; # -1
ലോഗ് ഫംഗ്ഷൻ
വാക്യഘടന :ലോഗ് നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ലോഗ്സ്വാഭാവിക ലോഗരിതം തിരികെ നൽകുന്നു സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ
പ്രിന്റ് ലോഗ് 2.71828182845905; # 1
റാൻഡ് ഫംഗ്ഷൻ
വാക്യഘടന : റാൻഡ് നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ റാൻഡ്അല്ലെങ്കിൽ അതിലും വലിയ ഒരു ക്രമരഹിത സംഖ്യ നൽകുന്നു പൂജ്യത്തിന് തുല്യംകുറവ് സംഖ്യകൾ, അത് പോസിറ്റീവ് ആയിരിക്കണം. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ 1 ന് തുല്യമാണെന്ന് കരുതപ്പെടുന്നു. ഫംഗ്ഷൻ ഇതുവരെ വിളിച്ചിട്ടില്ലെങ്കിൽ, അത് സ്വയമേവ അതിനെ വിളിക്കുന്നു.
പാപ പ്രവർത്തനം
വാക്യഘടന : പാപം നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ പാപം sine തിരികെ നൽകുന്നു സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണങ്ങൾ:
$pi = അടൻ2 0, -1; $x = sin 0; # x സമം 0 $x = sin $pi/2; # x തുല്യം 1 $x = sin -$pi/2; # x തുല്യം -1
sqrt പ്രവർത്തനം
വാക്യഘടന : ചതുരശ്ര നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ചതുരശ്രഎന്നതിന്റെ വർഗ്ഗമൂല്യം നൽകുന്നു സംഖ്യകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ആർഗ്യുമെന്റ് പൂജ്യത്തേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, മാരകമായ റൺടൈം പിശക് സംഭവിക്കുന്നു. ഉദാഹരണം:
പ്രിന്റ് sqrt 2; #1.4142135623731
srand ഫംഗ്ഷൻ
വാക്യഘടന : srand നമ്പർ വാദങ്ങൾ: നമ്പർസംഖ്യാ പദപ്രയോഗംഫംഗ്ഷൻ സ്രാൻഡ്ജനറേറ്റർ ആരംഭിക്കുന്നു ക്രമരഹിത സംഖ്യകൾ. അതിന്റെ വാദം ഒഴിവാക്കിയാൽ പിന്നെ നമ്പർറൺടൈം സിസ്റ്റം സൃഷ്ടിച്ചത്. PERL 5.004 മുതൽ, ഈ ഫംഗ്ഷനിലേക്കുള്ള ഒരു വ്യക്തമായ കോൾ ഇനി ആവശ്യമില്ല, കാരണം ഇത് ആദ്യമായി വിളിക്കുമ്പോൾ rand() ഉപയോഗിച്ച് സ്വയമേ വിളിക്കുന്നു.
6.9.2. സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ
chomp ഫംഗ്ഷൻ
വാക്യഘടന :ചൊംപ് ലൈൻചോമ്പ് പട്ടിക വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ പട്ടിക ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ചോമ്പ്നിന്ന് ഇല്ലാതാക്കുന്നു ലൈനുകൾനിലവിലെ റെക്കോർഡ് സെപ്പറേറ്ററുമായി പൊരുത്തപ്പെടുന്ന ട്രെയിലിംഗ് സബ്സ്ട്രിംഗ്, അതായത് $/ വേരിയബിളിന്റെ ഉള്ളടക്കം. എങ്കിൽ വാദം പട്ടിക, തുടർന്ന് ഈ ഫംഗ്ഷൻ ലിസ്റ്റിലെ ഓരോ ഘടകത്തിനും പ്രയോഗിക്കുന്നു. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഫംഗ്ഷന്റെ ഫലം നീക്കം ചെയ്ത പ്രതീകങ്ങളുടെ ആകെ എണ്ണമാണ്.
വരി വരിയായി വായിക്കുമ്പോൾ പുതിയ വരികൾ നീക്കം ചെയ്യുക എന്നതാണ് ഇതിന്റെ പ്രധാന ഉപയോഗം. ടെക്സ്റ്റ് ഫയൽ, ഉദാഹരണത്തിന്:
അതേസമയം (<>) (ചോമ്പ്; റീഡ് ലൈനിന്റെ അവസാനം \n നീക്കം ചെയ്യുക $_... )
$\ തുല്യമാണെങ്കിൽ undefഅല്ലെങ്കിൽ ഒരു സംഖ്യയുടെ റഫറൻസ് അടങ്ങിയിരിക്കുന്നു (നിശ്ചിത ദൈർഘ്യമുള്ള റെക്കോർഡുകൾക്കായി), തുടർന്ന് ഈ പ്രവർത്തനം ഒന്നും ഇല്ലാതാക്കില്ല.
ചോപ്പ് ഫംഗ്ഷൻ
വാക്യഘടന : മുളകും ലൈൻമുളകും പട്ടിക വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ പട്ടികസ്ട്രിംഗ് എക്സ്പ്രഷനുകളുടെ ലിസ്റ്റ് ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ മുളകുംനിന്ന് ഇല്ലാതാക്കുന്നു ലൈനുകൾഅതിന്റെ അവസാന പ്രതീകം അത് തിരികെ നൽകുന്നു. എങ്കിൽ വാദം പട്ടിക, തുടർന്ന് ഈ ഫംഗ്ഷൻ ലിസ്റ്റിലെ ഓരോ ഘടകത്തിലും പ്രയോഗിക്കുകയും നീക്കം ചെയ്ത അവസാന പ്രതീകം തിരികെ നൽകുകയും ചെയ്യുന്നു. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ
$_ = "abcde"; മുളകും; അച്ചടിക്കുക; # പ്രിന്റുകൾ "abcd"
ക്രിപ്റ്റ് ഫംഗ്ഷൻ
വാക്യഘടന :ക്രിപ്റ്റ് ലൈൻ, കോഡ് വാദങ്ങൾ: ലൈൻ, കോഡ്സ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ ക്രിപ്റ്റ്ഒറിജിനൽ എൻകോഡ് ചെയ്യുന്നു ലൈൻസ്ട്രിംഗ് ഉപയോഗിച്ച് കോഡ്ഫലം തിരികെ നൽകുന്നു. കോഡ്[./0-9A-Za-z] ശ്രേണിയിൽ രണ്ട് പ്രതീകങ്ങൾ ഉണ്ടായിരിക്കണം. PERL-ൽ ജോടിയാക്കിയ ഡീകോഡിംഗ് ഫംഗ്ഷൻ ഇല്ല, അതിനാൽ ഈ ഫംഗ്ഷന് പ്രായോഗിക ഉപയോഗമില്ല.
സൂചിക പ്രവർത്തനം
വാക്യഘടന : സൂചിക ലൈൻ, സബ്സ്ട്രിംഗ്, സ്ഥാനം? വാദങ്ങൾ: ലൈൻ, സബ്സ്ട്രിംഗ്സ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ സ്ഥാനംസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ സൂചികനോക്കുന്നു ലൈൻനൽകിയത് സബ്സ്ട്രിംഗ്, നൽകിയിരിക്കുന്നതിൽ നിന്ന് ആരംഭിക്കുന്നു സ്ഥാനങ്ങൾഅല്ലെങ്കിൽ വരിയുടെ തുടക്കം മുതൽ എങ്കിൽ സ്ഥാനം
$str = "ക്വീൻ മേരി"; പ്രിന്റ് സൂചിക($str, "മേരി"); # 6 പ്രിന്റ് സൂചിക($str, "മേരി"); # -1
എൽസി ഫംഗ്ഷൻ
വാക്യഘടന : എൽസി ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ lcഎല്ലാ പ്രതീകങ്ങളെയും പരിവർത്തനം ചെയ്യുന്നു ലൈനുകൾചെറിയ അക്ഷരങ്ങളിൽ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ
lc "ABCDE" അച്ചടിക്കുക; #എ ബി സി ഡി ഇ
ആദ്യ പ്രവർത്തനം
വാക്യഘടന : ആദ്യം ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ ആദ്യംആദ്യ പ്രതീകത്തെ പരിവർത്തനം ചെയ്യുന്നു ലൈനുകൾവി ചെറിയ അക്ഷരം. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉപയോഗ ലോക്കേൽ നിർദ്ദേശമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിലവിലെ പ്രാദേശിക ക്രമീകരണം കണക്കിലെടുത്താണ് പരിവർത്തനം നടത്തുന്നത്. ഉദാഹരണം:
ആദ്യം "ABCDE" അച്ചടിക്കുക; # എ ബി സി ഡി ഇ
നീളം പ്രവർത്തനം
വാക്യഘടന : നീളം ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ നീളംഅക്ഷരങ്ങളുടെ എണ്ണം നൽകുന്നു ലൈൻ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണം:
പ്രിന്റ് ദൈർഘ്യം "ABCDE"; # 5
rindex ഫംഗ്ഷൻ
വാക്യഘടന : rindex ലൈൻ, സബ്സ്ട്രിംഗ്, സ്ഥാനം? വാദങ്ങൾ: ലൈൻ, സബ്സ്ട്രിംഗ്സ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ സ്ഥാനംസംഖ്യാ പദപ്രയോഗം ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ റിൻഡക്സ്നോക്കുന്നു ലൈൻനൽകിയത് സബ്സ്ട്രിംഗ്നൽകിയിരിക്കുന്നതിൽ നിന്ന് ആരംഭിച്ച് വലത്തുനിന്ന് ഇടത്തേക്ക് സ്ഥാനങ്ങൾഅല്ലെങ്കിൽ വരിയുടെ അവസാനം മുതൽ സ്ഥാനംഒഴിവാക്കി. ഇത് സോഴ്സ് സ്ട്രിംഗിൽ കണ്ടെത്തിയ സബ്‌സ്‌ട്രിംഗിന്റെ സ്ഥാനം നൽകുന്നു, അല്ലെങ്കിൽ സബ്സ്ട്രിംഗ് കണ്ടെത്തിയില്ലെങ്കിൽ -1. ഉദാഹരണം:
പ്രിന്റ് റിൻഡെക്സ്("abcabc", "abc"); #3
ഫംഗ്ഷൻ substr
വാക്യഘടന :substr ലൈൻ, പക്ഷപാതം, നീളം?, മാറ്റിസ്ഥാപിക്കൽ? വാദങ്ങൾ: ലൈൻ, മാറ്റിസ്ഥാപിക്കൽസ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ പക്ഷപാതം, നീളംസംഖ്യാ പദപ്രയോഗങ്ങൾ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ substrഒരു സബ്സ്ട്രിംഗ് നൽകുന്നു ലൈനുകൾനൽകിയത് നീളം, നൽകിയിരിക്കുന്നതിൽ നിന്ന് ആരംഭിക്കുന്നു ഓഫ്സെറ്റുകൾ. എങ്കിൽ പക്ഷപാതംനെഗറ്റീവ് ആണ്, തുടർന്ന് അത് വരിയുടെ അവസാനം മുതൽ കണക്കാക്കുന്നു. എങ്കിൽ നീളംഒഴിവാക്കിയിരിക്കുന്നു, തുടർന്ന് വരിയുടെ അവസാനം വരെയുള്ള പ്രതീകങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു; അത് നെഗറ്റീവ് ആണെങ്കിൽ, അത് സ്ട്രിംഗിന്റെ നീളം കൂട്ടുന്നു. ഉദാഹരണം:
പ്രിന്റ് substr("abcdef", 1, -2); #bcd
എങ്കിൽ ലൈൻഒരു വേരിയബിൾ നൽകിയാൽ, ഈ ഫംഗ്ഷന് നാലാമത്തെ ആർഗ്യുമെന്റ് ഉണ്ടായിരിക്കാം, അത് നൽകിയിരിക്കുന്ന സബ്‌സ്‌ട്രിംഗിനെ മാറ്റിസ്ഥാപിക്കുന്ന സ്ട്രിംഗ് വ്യക്തമാക്കുന്നു, ഉദാഹരണത്തിന്:
$str = "abcdef"; substr($str, 1, -2,"xxx"); $str അച്ചടിക്കുക; # axxxef
ഈ ഉദാഹരണം ഇങ്ങനെ എഴുതാം:
$str = "abcdef"; substr($str, 1, -2) = "xxx"; $str അച്ചടിക്കുക; # axxxef
uc പ്രവർത്തനം
വാക്യഘടന :uc ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ ucഎല്ലാ പ്രതീകങ്ങളെയും പരിവർത്തനം ചെയ്യുന്നു ലൈനുകൾവലിയ അക്ഷരങ്ങളിൽ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉപയോഗ ലോക്കേൽ നിർദ്ദേശമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിലവിലെ പ്രാദേശിക ക്രമീകരണം കണക്കിലെടുത്താണ് പരിവർത്തനം നടത്തുന്നത്. ഉദാഹരണം:
uc "abcde" എന്ന് അച്ചടിക്കുക; #എ ബി സി ഡി ഇ
ucfirst ഫംഗ്ഷൻ
വാക്യഘടന : ആദ്യം ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ ആദ്യംആദ്യ പ്രതീകത്തെ പരിവർത്തനം ചെയ്യുന്നു ലൈനുകൾവലിയ അക്ഷരത്തിൽ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉപയോഗ ലോക്കേൽ നിർദ്ദേശമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിലവിലെ പ്രാദേശിക ക്രമീകരണം കണക്കിലെടുത്താണ് പരിവർത്തനം നടത്തുന്നത്. ഉദാഹരണം:
ucfirst "abcde" അച്ചടിക്കുക; # എ ബി സി ഡി ഇ
6.9.3. മറ്റ് സ്കെയിലർ പ്രവർത്തനങ്ങൾ
chr പ്രവർത്തനം
വാക്യഘടന : chr കോഡ് വാദങ്ങൾ: കോഡ്സംഖ്യാ പദപ്രയോഗം ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ chrനൽകിയിരിക്കുന്ന സംഖ്യകളുള്ള ഒരു പ്രതീകം നൽകുന്നു കോഡ്. വാദം ഒഴിവാക്കിയാൽ പിന്നെ കോഡ്$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണം:
chr 65 അച്ചടിക്കുക; //എ
ഹെക്സ് ഫംഗ്ഷൻ
വാക്യഘടന : ഹെക്സ് ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ഹെക്സ്രൂപാന്തരപ്പെടുന്നു ലൈൻവി ഹെക്സാഡെസിമൽ നമ്പർ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന എല്ലാ പ്രസ്താവനകളും 165 എന്ന നമ്പർ പ്രദർശിപ്പിക്കും:
ഹെക്സ് "0xaf" അച്ചടിക്കുക; പ്രിന്റ് ഹെക്സ് "xaf"; പ്രിന്റ് ഹെക്സ് "0af"; പ്രിന്റ് ഹെക്സ് "af";
ഒക്ട് ഫംഗ്ഷൻ
വാക്യഘടന : ഒക്ടോബർ ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ഒക്ടോബര്രൂപാന്തരപ്പെടുന്നു ലൈൻഎണ്ണത്തിൽ. എങ്കിൽ ലൈൻ"0x" ൽ ആരംഭിക്കുന്നു, തുടർന്ന് അത് ഒരു ഹെക്സാഡെസിമൽ സംഖ്യയായി വ്യാഖ്യാനിക്കപ്പെടുന്നു; ഇത് "0b" ൽ ആരംഭിക്കുകയാണെങ്കിൽ, അത് ഒരു ബൈനറി സംഖ്യയായി വ്യാഖ്യാനിക്കപ്പെടുന്നു; മറ്റു സന്ദർഭങ്ങളിൽ ഇത് വ്യാഖ്യാനിക്കപ്പെടുന്നു അഷ്ടസംഖ്യ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണങ്ങൾ:
ഒക്ടോബർ "0xaf" അച്ചടിക്കുക; #165 പ്രിന്റ് ഒക്ട് "0b101"; #5 പ്രിന്റ് ഒക്ടോബർ "0100"; #64 പ്രിന്റ് ഒക്ടോബർ "100"; #64
ഫംഗ്ഷൻ ഓർഡർ
വാക്യഘടന :ord ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ ക്രമംആദ്യ പ്രതീകത്തിന്റെ സംഖ്യാ കോഡ് നൽകുന്നു ലൈനുകൾ. വാദം ഒഴിവാക്കിയാൽ പിന്നെ ലൈൻ$_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണ് എടുക്കുന്നത്. ഉദാഹരണം:
പ്രിന്റ് ഓർഡർ "ABC"; #65
പാക്ക് ഫംഗ്ഷൻ
വാക്യഘടന :പാക്ക് സാമ്പിൾ, പട്ടിക വാദങ്ങൾ: സാമ്പിൾസ്ട്രിംഗ് എക്സ്പ്രഷൻ പട്ടികസ്കെയിലർ എക്സ്പ്രഷനുകളുടെ പട്ടിക ഫലമായി: സ്ട്രിംഗ് മൂല്യംഫംഗ്ഷൻ പായ്ക്ക്നൽകിയിരിക്കുന്നത് പായ്ക്ക് ചെയ്യുന്നു പട്ടികഒരു സ്ട്രിംഗിലേക്ക് മൂല്യങ്ങൾ നൽകുകയും അതിന്റെ ഫലമായി അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. പാക്കിംഗ് നിയമങ്ങൾ ലൈൻ വ്യക്തമാക്കുന്നു സാമ്പിൾ, ലിസ്റ്റ് ഘടകങ്ങളുടെ രൂപാന്തര നിയമങ്ങൾ സൂചിപ്പിക്കുന്ന പ്രതീകങ്ങൾ ഉൾക്കൊള്ളുന്നു. സാമ്പിൾഇനിപ്പറയുന്ന പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം:
| ചിഹ്നം | ഫലമായി |
|---|---|
| എ | ഒരു അനിയന്ത്രിതമായ സ്ട്രിംഗ്, അവസാനം ഒരു സീറോ ബൈറ്റ് ചേർക്കുക. |
| എ | ASCII സ്ട്രിംഗ്, അവസാനം ഒരു സ്പേസ് ചേർക്കുക. |
| Z | ASCII സ്ട്രിംഗ്, അവസാനം ഒരു നൾ ബൈറ്റ് ചേർക്കുക. |
| ബി | ബിറ്റ് സ്ട്രിംഗ്, ഒരു ബൈറ്റിലെ ബിറ്റുകൾ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള ബിറ്റിൽ തുടങ്ങുന്നു. |
| ബി | ബിറ്റ് സ്ട്രിംഗ്, ഒരു ബൈറ്റിലെ ബിറ്റുകൾ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റിൽ നിന്ന് പാക്ക് ചെയ്യുന്നു. |
| എച്ച് | ഹെക്സാഡെസിമൽ സ്ട്രിംഗ്, ലോ ടെട്രാഡ് ആദ്യം വരുന്നു. |
| എച്ച് | ഹെക്സാഡെസിമൽ സ്ട്രിംഗ്, ഉയർന്ന ടെട്രാഡ് ആദ്യം വരുന്നു. |
| സി | ഒപ്പിട്ട ഒരു-ബൈറ്റ് പൂർണ്ണസംഖ്യ. |
| സി | ഒപ്പിടാത്ത ഒരു-ബൈറ്റ് പൂർണ്ണസംഖ്യ. |
| എസ് | രണ്ട്-ബൈറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യ. |
| എസ് | രണ്ട്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ. |
| ഐ | ഒപ്പിട്ട പൂർണ്ണസംഖ്യ (ബൈറ്റുകളുടെ എണ്ണം ആർക്കിടെക്ചറിനെ ആശ്രയിച്ചിരിക്കുന്നു). |
| ഐ | ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ (ബൈറ്റുകളുടെ എണ്ണം ആർക്കിടെക്ചറിനെ ആശ്രയിച്ചിരിക്കുന്നു). |
| എൽ | നാല്-ബൈറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യ. |
| എൽ | നാല്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ. |
| എൻ | രണ്ട്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ, ഏറ്റവും പ്രധാനപ്പെട്ട ബൈറ്റ് ആദ്യം വരുന്നു. |
| എൻ | നാല്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ, ഏറ്റവും പ്രധാനപ്പെട്ട ബൈറ്റ് ആദ്യം വരുന്നു. |
| വി | രണ്ട്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ, ആദ്യം കുറഞ്ഞ ബൈറ്റ്. |
| വി | നാല്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ, ആദ്യം കുറഞ്ഞ ബൈറ്റ്. |
| q | എട്ട്-ബൈറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യ. |
| ക്യു | എട്ട്-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ. |
| എഫ് | സാധാരണ പ്രിസിഷൻ ഫ്ലോട്ടിംഗ് നമ്പർ, വാസ്തുവിദ്യയെ ആശ്രയിച്ചിരിക്കുന്ന ഫോർമാറ്റ്. |
| ഡി | ഇരട്ട പ്രിസിഷൻ ഫ്ലോട്ടിംഗ് നമ്പർ, വാസ്തുവിദ്യയെ ആശ്രയിച്ചിരിക്കുന്ന ഫോർമാറ്റ്. |
| പി | നൾ-ടെർമിനേറ്റഡ് സ്ട്രിംഗിലേക്ക് പോയിന്റർ. |
| പി | ഒരു നിശ്ചിത നീളമുള്ള ഘടനയിലേക്കുള്ള ഒരു പോയിന്റർ. |
| യു | uuencode എൻകോഡിംഗിലെ സ്ട്രിംഗ്. |
| യു | UTF-8 എൻകോഡിംഗിലെ സ്ട്രിംഗ്. |
| w | BER ഫോർമാറ്റിൽ കംപ്രസ് ചെയ്ത പൂർണ്ണസംഖ്യ. |
| x | ശൂന്യമായ ബൈറ്റ്. |
| എക്സ് | ഡ്യൂപ്ലിക്കേറ്റ് ബൈറ്റ്. |
| @ | നിർദ്ദിഷ്ട സ്ഥാനം വരെ പൂജ്യങ്ങളുള്ള പാഡ്. |
ടെംപ്ലേറ്റുകൾ അനുസരിക്കുന്നു താഴെ നിയമങ്ങൾ:
- ആവർത്തന കൗണ്ടർ വ്യക്തമാക്കുന്ന ഒരു സംഖ്യ കത്തിന് പിന്നാലെ ഉണ്ടായിരിക്കാം. എ, എ, ഇസഡ്, ബി, ബി, എച്ച്, എച്ച്, പി ഒഴികെയുള്ള എല്ലാ തരങ്ങൾക്കും, മൂലകങ്ങളുടെ അനുബന്ധ എണ്ണം വീണ്ടെടുക്കുന്നു പട്ടിക. കൌണ്ടർ * ചിഹ്നത്താൽ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ലിസ്റ്റിലെ ശേഷിക്കുന്ന എല്ലാ ഘടകങ്ങളും പാക്ക് ചെയ്യുക എന്നാണ് ഇതിനർത്ഥം (@, x, X എന്നിവ ഒഴികെ, ഈ ചിഹ്നം 0-നും u, 1-ന് തുല്യമായിരിക്കുന്നിടത്തും). Z* എന്നാൽ സ്ട്രിംഗിന്റെ അവസാനത്തിൽ ഒരു അധിക നൾ ബൈറ്റ് ചേർക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. ഔട്ട്‌പുട്ടിന്റെ ഒരു വരിയിൽ എൻകോഡ് ചെയ്യേണ്ട പരമാവധി എണ്ണം ബൈറ്റുകളായി u എന്നതിന്റെ ആവർത്തന എണ്ണം വ്യാഖ്യാനിക്കപ്പെടുന്നു; ഈ സാഹചര്യത്തിൽ, 0, 1 എന്നിവ 45 കൊണ്ട് മാറ്റിസ്ഥാപിക്കുന്നു.
- എ, എ, ഇസഡ് തരങ്ങൾ എല്ലായ്പ്പോഴും ലിസ്റ്റിൽ നിന്ന് ഒരു മൂല്യം വീണ്ടെടുക്കുന്നു. അവയ്ക്കുള്ള ആവർത്തന എണ്ണം അർത്ഥമാക്കുന്നത് പായ്ക്ക് ചെയ്ത സ്ട്രിംഗിന്റെ നീളം എന്നാണ്. കൌണ്ടറിനേക്കാൾ ലൈൻ ദൈർഘ്യമേറിയതാണെങ്കിൽ, അത് വെട്ടിച്ചുരുക്കിയിരിക്കുന്നു; ചുരുക്കത്തിൽ, ഇത് പൂജ്യങ്ങൾ (a, Z) അല്ലെങ്കിൽ സ്പെയ്സുകൾ (A) ഉപയോഗിച്ച് പാഡ് ചെയ്തിരിക്കുന്നു. പാക്ക് ചെയ്യുമ്പോൾ, a, Z എന്നിവ തുല്യമാണ്; അൺപാക്ക് ചെയ്യുമ്പോൾ, A സ്ട്രിംഗിൽ നിന്ന് ട്രെയിലിംഗ് സ്‌പെയ്‌സുകളും നൾ ബൈറ്റുകളും നീക്കംചെയ്യുന്നു, Z ആദ്യത്തെ നൾ ബൈറ്റിന് ശേഷം എല്ലാം നീക്കംചെയ്യുന്നു, ഒന്നും നീക്കം ചെയ്യുന്നില്ല.
- ബി, ബി തരങ്ങൾ ഓരോ ഇൻപുട്ട് ബൈറ്റുകളും ഫലത്തിന്റെ ഒരു ബിറ്റാക്കി മാറ്റുന്നു. ഉറവിട ബൈറ്റിന്റെ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള ബിറ്റിന്റെ മൂല്യത്തെ ആശ്രയിച്ച് ഫലമായുണ്ടാകുന്ന ബിറ്റ് 0 അല്ലെങ്കിൽ 1 ആണ്. പാക്ക് ചെയ്യേണ്ട ബൈറ്റുകളുടെ എണ്ണം ആവർത്തന കൗണ്ടർ വ്യക്തമാക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ലഭിച്ച ബിറ്റുകളെ അതിന്റെ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള ബിറ്റിൽ നിന്ന് ആരംഭിച്ച് ഫല ബൈറ്റിലേക്കും ബി അതിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റിലേക്കും പാക്ക് ചെയ്യുന്നു. ഉറവിട സ്ട്രിംഗിന്റെ നീളം 8 കൊണ്ട് ഹരിക്കാനാകില്ലെങ്കിൽ, ഫലം പൂജ്യം ബിറ്റുകളാൽ പാഡ് ചെയ്യപ്പെടും. ഡീകംപ്രഷൻ സമയത്ത്, ഈ അധിക ബിറ്റുകൾ അവഗണിക്കപ്പെടും. ഇൻപുട്ട് സ്ട്രിംഗ് കൗണ്ടറിനേക്കാൾ ദൈർഘ്യമേറിയതാണെങ്കിൽ, അത് വെട്ടിച്ചുരുക്കിയിരിക്കുന്നു. * ആവർത്തിച്ചുള്ള എണ്ണമെന്ന നിലയിൽ ഇൻപുട്ട് ഫീൽഡിന്റെ എല്ലാ ബൈറ്റുകളും ഉപയോഗിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. ഡീകംപ്രസ്സ് ചെയ്യുമ്പോൾ, ബിറ്റുകൾ "0", "1" ബൈറ്റുകളായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു.
- h, H എന്നീ തരങ്ങൾക്ക്, ആവർത്തന എണ്ണം അർത്ഥമാക്കുന്നത് പാക്ക് ചെയ്യേണ്ട ഹെക്സാഡെസിമൽ അക്കങ്ങളുടെ (ടെട്രാഡുകൾ) എണ്ണമാണ്. ഓരോ ഇൻപുട്ട് ബൈറ്റുകളും ഫലത്തിന്റെ ഒരു ടെട്രാഡായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. ഈ സാഹചര്യത്തിൽ, "0""9", "a""f", "A""F" എന്നീ ബൈറ്റുകൾ അനുബന്ധ ഹെക്സാഡെസിമൽ അക്കങ്ങളും ശേഷിക്കുന്ന ബൈറ്റുകൾ അവയുടെ ഏറ്റവും കുറഞ്ഞ ടെട്രാഡും ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ടൈപ്പ് എച്ച്, ഫലമായുണ്ടാകുന്ന ടെട്രാഡുകളെ ഒരു ഫല ബൈറ്റിലേക്ക് പായ്ക്ക് ചെയ്യുന്നു, ഇത് ഏറ്റവും താഴ്ന്ന ടെട്രാഡിൽ നിന്ന് ആരംഭിക്കുന്നു, ഒപ്പം ഏറ്റവും ഉയർന്നത് കൊണ്ട് എച്ച്. യഥാർത്ഥ സ്ട്രിംഗിന്റെ നീളം വിചിത്രമാണെങ്കിൽ, ഫലം പൂജ്യം ടെട്രാഡ് ഉപയോഗിച്ച് പാഡ് ചെയ്യുന്നു. അൺപാക്ക് ചെയ്യുമ്പോൾ, അധിക നോട്ട്ബുക്ക് അവഗണിക്കപ്പെടും. ഇൻപുട്ട് സ്ട്രിംഗ് കൗണ്ടറിനേക്കാൾ ദൈർഘ്യമേറിയതാണെങ്കിൽ, അത് വെട്ടിച്ചുരുക്കിയിരിക്കുന്നു. * ആവർത്തിച്ചുള്ള എണ്ണമെന്ന നിലയിൽ ഇൻപുട്ട് ഫീൽഡിന്റെ എല്ലാ ബൈറ്റുകളും ഉപയോഗിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. അൺപാക്ക് ചെയ്യുമ്പോൾ, ടെട്രാഡുകൾ ഹെക്സാഡെസിമൽ അക്കങ്ങളുടെ ഒരു സ്ട്രിംഗായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു.
- ടൈപ്പ് പി ഒരു പോയിന്റർ പാക്ക് ചെയ്യുന്നു ശൂന്യമായ സ്ട്രിംഗിലേക്ക്, കൂടാതെ പി ഒരു ആവർത്തന എണ്ണത്തിൽ വ്യക്തമാക്കിയ ഒരു നിശ്ചിത നീളമുള്ള ഘടനയിലേക്ക് ഒരു പോയിന്റർ പാക്ക് ചെയ്യുന്നു. അനുബന്ധ പോയിന്ററിന്റെ മൂല്യം ആണെങ്കിൽ undef, അപ്പോൾ പൂജ്യം പാക്ക് ചെയ്യുന്നു.
- ഒരു ആവർത്തന കൗണ്ടറിന് പകരം / ചിഹ്നം അതിന്റെ നീളം ഒരു സ്ട്രിംഗിന് മുന്നിൽ പാക്ക് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, "n/a*" എന്ന പാറ്റേൺ അർത്ഥമാക്കുന്നത്, യഥാർത്ഥ സ്‌ട്രിംഗിന്റെയും സ്‌ട്രിംഗിന്റെയും ദൈർഘ്യം അടങ്ങുന്ന രണ്ട്-ബൈറ്റ് നമ്പർ ഫലത്തിൽ അടങ്ങിയിരിക്കുമെന്നാണ്.
- പാക്ക് ചെയ്യുമ്പോൾ, തത്ഫലമായുണ്ടാകുന്ന മൂല്യങ്ങളുടെ തുല്യത നടപ്പിലാക്കില്ല.
- പാറ്റേണിൽ # പ്രതീകത്തിൽ ആരംഭിച്ച് വരിയുടെ അവസാനം വരെ തുടരുന്ന ഒരു കമന്റ് അടങ്ങിയിരിക്കാം.
- ഒരു ടെംപ്ലേറ്റിന് അതിൽ അടങ്ങിയിരിക്കുന്നതിനേക്കാൾ കൂടുതൽ ആർഗ്യുമെന്റുകൾ ആവശ്യമുണ്ടെങ്കിൽ പട്ടിക, അത് പട്ടിക"" ശൂന്യമായ വരികൾ കൊണ്ട് പാഡ് ചെയ്തിരിക്കുന്നു. ഒരു ടെംപ്ലേറ്റിന് അതിൽ അടങ്ങിയിരിക്കുന്നതിനേക്കാൾ കുറച്ച് ആർഗ്യുമെന്റുകൾ ആവശ്യമുണ്ടെങ്കിൽ പട്ടിക, തുടർന്ന് അധിക വാദങ്ങൾ അവഗണിക്കപ്പെടും.
$foo = പായ്ക്ക് ("CCCC",65,66,67,68); # $foo = "ABCD" $foo = പായ്ക്ക് ("C4",65,66,67,68); # $foo = "ABCD" $foo = പാക്ക്("aaaa","abc","x","y","z"); # $foo = "axyz" $foo = പായ്ക്ക് ("a14","abcdefg"); # "abcdefg\0\0\0\0\0\0\0" $foo = പാക്ക്("s2",1,2); # $foo = IBM PC-യിൽ "\1\0\2\0", Mac-ൽ "\0\1\0\2"
അൺപാക്ക് ഫംഗ്ഷൻ
വാക്യഘടന : അൺപാക്ക് സാമ്പിൾ, ലൈൻ വാദങ്ങൾ: സാമ്പിൾ, ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ ഫലമായി: മൂല്യങ്ങളുടെ നിരഫംഗ്ഷൻ പായ്ക്ക്അൺപാക്ക് ചെയ്യുന്നു ലൈൻ, ഒരു ഫംഗ്ഷൻ പായ്ക്ക് ചെയ്തു. ഇത് ഫലമായുണ്ടാകുന്ന മൂല്യങ്ങളുടെ ഒരു ശ്രേണി നൽകുന്നു (ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ, തിരികെ നൽകിയ ആദ്യ മൂല്യം നൽകുന്നു). അൺപാക്കിംഗ് നിയമങ്ങൾ ലൈൻ വ്യക്തമാക്കുന്നു സാമ്പിൾ, അതിന്റെ ഘടനയ്ക്ക് സമാനമാണ്. കൂടാതെ, അൺപാക്കിംഗ് തരം വ്യക്തമാക്കുന്ന അക്ഷരത്തിന് മുമ്പുള്ള % എന്ന പ്രിഫിക്‌സ് ടെംപ്ലേറ്റിൽ അടങ്ങിയിരിക്കാം. എൻ, അൺപാക്കിംഗിന്റെ ഫലമല്ല, മറിച്ച് അതിന്റെ ഫലമാണ് നമുക്ക് ലഭിക്കാൻ ആഗ്രഹിക്കുന്നതെന്ന് ഇത് സൂചിപ്പിക്കുന്നു എൻ-ബിറ്റ് ചെക്ക്സം. മറ്റ് വിശദാംശങ്ങൾക്ക്, ഫംഗ്ഷൻ വിവരണം കാണുക. ഇനിപ്പറയുന്ന ഉദാഹരണം തെളിയിക്കുന്നു ഫലപ്രദമായ രീതി$mask വേരിയബിളിലെ ഒരു ബിറ്റുകളുടെ എണ്ണം കണക്കാക്കുന്നു:
$setbits = unpack("%32b*", $mask);
vec ഫംഗ്ഷൻ
വാക്യഘടന :vec ആവിഷ്കാരം, പക്ഷപാതം, വീതി വാദങ്ങൾ: ആവിഷ്കാരംസ്ട്രിംഗ് എക്സ്പ്രഷൻ പക്ഷപാതം, വീതിസംഖ്യാ പദപ്രയോഗങ്ങൾ ഫലമായി: സംഖ്യാ മൂല്യംഫംഗ്ഷൻ vecചരടിലേക്ക് നോക്കുന്നു ആവിഷ്കാരംതന്നിരിക്കുന്ന മൂലകങ്ങൾ അടങ്ങുന്ന ഒരു അറേ ആയി വീതിബിറ്റുകളിൽ. ഇത് നൽകിയിട്ടുള്ള മൂലകത്തെ വീണ്ടെടുക്കുന്നു സ്ഥാനമാറ്റാംഅത് തിരികെ നൽകുന്നു. വീതി 1 മുതൽ 32 വരെയുള്ള ശ്രേണിയിൽ 2 പവർ ആയിരിക്കണം (അല്ലെങ്കിൽ 64-ബിറ്റ് പ്ലാറ്റ്‌ഫോമുകളിൽ 64), പക്ഷപാതംഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയായി കണക്കാക്കുന്നു. ഉദാഹരണം:
$x = "\x10\x32\x54"; # $x = (0, 1, 2, 3, 4, 5) 4-ബിറ്റ് നമ്പറുകളുടെ വെക്‌ടറായി പ്രിന്റ് വെക് ($x, 2, 4); # അതിനാൽ നമ്പർ 2 പ്രിന്റ് ചെയ്യപ്പെടും
ഫംഗ്ഷൻ vecഒരു സ്ട്രിംഗിൽ ബിറ്റ്ഗ്രൂപ്പുകളുടെ ഒരു നിര ഉണ്ടാക്കാൻ ഒരു അസൈൻമെന്റ് ഓപ്പറേറ്ററുടെ ഇടതുവശത്ത് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, മുകളിൽ $x എന്ന സ്ട്രിംഗ് ഇതുപോലെ രൂപപ്പെടുത്താം:
ഫംഗ്ഷൻ quotemetaഅല്ലാത്ത ഓരോ പ്രതീകത്തിനും മുമ്പായി ആർഗ്യുമെന്റ് സ്ട്രിംഗിലേക്ക് ഒരു "\" പ്രതീകം ചേർക്കുന്നു ലാറ്റിൻ അക്ഷരംഅല്ലെങ്കിൽ ഒരു സംഖ്യയും റിട്ടേണുകളും പുതിയ വരതൽഫലമായി. ആർഗ്യുമെന്റ് ഒഴിവാക്കിയാൽ, അത് $_ വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണെന്ന് അനുമാനിക്കപ്പെടുന്നു. \Q മെറ്റാക്യാരാക്‌ടർ നടപ്പിലാക്കുന്ന ഒരു ആന്തരിക പ്രവർത്തനമാണിത്. ഉദാഹരണം:
ഉദ്ധരണി "abc123abv" അച്ചടിക്കുക; # "abc123\a\b\c"
സ്പ്ലിറ്റ് ഫംഗ്ഷൻ
വാക്യഘടന : രണ്ടായി പിരിയുക സാമ്പിൾ, ലൈൻ, പരിധി വാദങ്ങൾ: സാമ്പിൾപതിവ് ആവിഷ്കാരം ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ പരിധിസംഖ്യാ പദപ്രയോഗം ഫലമായി: സ്ട്രിംഗുകളുടെ പട്ടികഫംഗ്ഷൻ രണ്ടായി പിരിയുകഒറിജിനൽ വിഭജിക്കുന്നു ലൈൻസബ്‌സ്‌ട്രിംഗുകളിലേക്കും ഈ സബ്സ്ട്രിംഗുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ, ഇത് @_ അറേയിൽ സബ്സ്ട്രിംഗുകളുടെ ഒരു ലിസ്റ്റ് സംഭരിക്കുകയും അതിന്റെ ദൈർഘ്യം നൽകുകയും ചെയ്യുന്നു. എങ്കിൽ ലൈൻഒഴിവാക്കിയിരിക്കുന്നു, തുടർന്ന് അത് $_ എന്ന വേരിയബിളിന്റെ മൂല്യത്തിന് തുല്യമാണെന്ന് അനുമാനിക്കപ്പെടുന്നു. നൽകിയിരിക്കുന്നതുമായി പൊരുത്തപ്പെടുന്ന സ്ഥാനങ്ങളിലാണ് സബ്‌സ്ട്രിംഗുകളായി വിഭജിക്കുന്നത് സാമ്പിൾ; അത് ഒഴിവാക്കിയാൽ, സ്പ്ലിറ്റ് സ്പേസ് ക്യാരക്‌ടറിൽ നിർവ്വഹിക്കുന്നു പ്രമുഖ ഇടങ്ങൾഓരോ ഉപസ്‌ട്രിംഗിലും നീക്കംചെയ്യുന്നു. പാറ്റേണിൽ പരാൻതീസിസുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, പരാൻതീസിസിലെ എക്‌സ്‌പ്രഷനുമായി പൊരുത്തപ്പെടുന്ന സബ്സ്ട്രിംഗുകൾ ഫലമായുണ്ടാകുന്ന പട്ടികയിൽ പ്രത്യേക ഘടകങ്ങളായി ഉൾപ്പെടുത്തും.
എങ്കിൽ പരിധിനൽകപ്പെട്ടതും പോസിറ്റീവായതും, അത് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യേണ്ട പരമാവധി അനുവദനീയമായ സബ്സ്ട്രിംഗുകളുടെ എണ്ണം വ്യക്തമാക്കുന്നു. ഇത് ഒഴിവാക്കുകയോ പൂജ്യത്തിന് തുല്യമോ ആണെങ്കിൽ, ഫലമായുണ്ടാകുന്ന ലിസ്റ്റിൽ ശൂന്യമായ സബ്സ്ട്രിംഗുകൾ ഉൾപ്പെടില്ല. ഇത് നെഗറ്റീവ് ആണെങ്കിൽ, എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്ത എല്ലാ സബ്‌സ്‌ട്രിംഗുകളും തിരികെ നൽകും. ഉദാഹരണങ്ങൾ:
@_ = സ്പ്ലിറ്റ് (/,/, "a,b,c,d,"); # @_ = ("a", "b", "c", "d") @_ = split(/,/, "a,b,c,d,", 3); # @_ = ("a", "b", "c,d,") @_ = split(/,/, "a,b,c,d,", -3); # @_ = ("a", "b", "c", "d", "") @_ = split(/(,)/, "a,b,c,d,"); # @_ = ("a", ",", "b", ",", "c", ",", "d", ",")
പഠന പ്രവർത്തനം
വാക്യഘടന : പഠനം ലൈൻ വാദങ്ങൾ: ലൈൻസ്ട്രിംഗ് എക്സ്പ്രഷൻ ഫലമായി: ഇല്ലഫംഗ്ഷൻ പഠനംസമാഹരിക്കുന്നു ലൈൻ(അല്ലെങ്കിൽ $_ വേരിയബിളിന്റെ മൂല്യം ഒഴിവാക്കിയാൽ) ആന്തരിക പ്രാതിനിധ്യത്തിലേക്ക്. എങ്കിൽ ലൈൻഒരു പാറ്റേണുമായി നിരവധി തവണ പൊരുത്തപ്പെടുത്താൻ ഉദ്ദേശിച്ചുള്ളതാണ്, ഇത് കംപൈൽ ചെയ്യുന്നത് തുടർന്നുള്ള പൊരുത്തപ്പെടുത്തൽ പ്രവർത്തനങ്ങളിൽ സമയം ലാഭിക്കും. ഒരു സമയത്ത് ഒരു വരി മാത്രമേ സമാഹരിക്കാൻ കഴിയൂ; ഫംഗ്ഷൻ ആപ്ലിക്കേഷൻ പഠനംമറ്റൊരു ലൈനിലേക്ക് നിലവിലെ ലൈനിന്റെ സമാഹാരം റദ്ദാക്കുന്നു. ഉദാഹരണം:
അതേസമയം (<>) (പഠനം; /\bme\b/ എങ്കിൽ "എന്റെ\n" എന്ന് അച്ചടിക്കുക; /\by you\b/ എങ്കിൽ "നിങ്ങളുടെ\n" എന്ന് അച്ചടിക്കുക; ...)
പ്രശ്നം
സബ്റൂട്ടീനെ വിളിക്കാൻ നിങ്ങൾ ഒരു ലിങ്ക് സൃഷ്ടിക്കേണ്ടതുണ്ട്. Tk ഫംഗ്ഷനുകൾ എന്ന് പരോക്ഷമായി വിളിക്കുന്ന സിഗ്നൽ ഹാൻഡ്‌ലറുകളും ഫംഗ്ഷൻ ഹാഷുകളിലേക്കുള്ള പോയിന്ററുകളും സൃഷ്‌ടിക്കുമ്പോൾ ഈ പ്രശ്നം ഉണ്ടാകുന്നു.പരിഹാരം
ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു റഫറൻസ് ലഭിക്കുന്നു: $cref = \ $cref = sub (...); റഫറൻസ് പ്രകാരം ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നു: @returned = $cref->(@arguments); @മടങ്ങി = &$cref (@arguments);ഒരു അഭിപ്രായം
ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു റഫറൻസ് ലഭിക്കുന്നതിന്, അതിന്റെ പേര് \& എന്ന് പ്രിഫിക്‌സ് ചെയ്യുക. കൂടാതെ, അജ്ഞാത ഫംഗ്ഷനുകൾ സൃഷ്ടിക്കാൻ ഉപ() ഫോർമുലേഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു അജ്ഞാത ഫംഗ്ഷൻ റഫറൻസ് മറ്റേതൊരു പോലെ സൂക്ഷിക്കാൻ കഴിയും. ഫംഗ്ഷൻ റഫറൻസുകൾ ഡിറഫറൻസിംഗിനായി Perl 5.004 ഒരു പോസ്റ്റ്ഫിക്സ് നൊട്ടേഷൻ അവതരിപ്പിച്ചു. റഫറൻസ് പ്രകാരം ഒരു ഫംഗ്ഷനെ വിളിക്കാൻ, മുമ്പ് നിങ്ങൾ &$funcname (@ARGS) എഴുതേണ്ടതായിരുന്നു, ഇവിടെ $funcname എന്നത് ഫംഗ്ഷന്റെ പേരാണ്. ഒരു ഫംഗ്ഷന്റെ പേര് വേരിയബിളിൽ സംരക്ഷിക്കാനുള്ള കഴിവ് ഇന്നും നിലനിൽക്കുന്നു: $funcname = "thefunc"; &$funcname(); എന്നിരുന്നാലും, പല കാരണങ്ങളാൽ അത്തരമൊരു പരിഹാരം അഭികാമ്യമല്ല. ഒന്നാമതായി, ഇത് യഥാർത്ഥ (ഹാർഡ്) ലിങ്കുകളേക്കാൾ പ്രതീകാത്മകമാണ് ഉപയോഗിക്കുന്നത്, അതിനാൽ കർശനമായ "റെഫൻസ്" നിർദ്ദേശം ഉപയോഗിക്കുമ്പോൾ, അത് ഇനി ആവശ്യമില്ല. സിംബോളിക് ലിങ്കുകൾ സാധാരണയായി ശുപാർശ ചെയ്യുന്നില്ല, കാരണം അവയ്ക്ക് ലെക്സിക്കൽ വേരിയബിളുകൾ ആക്സസ് ചെയ്യാൻ കഴിയില്ല, ആഗോള വേരിയബിളുകൾ മാത്രം, അവയ്ക്ക് റഫറൻസ് കൗണ്ടിംഗ് ഇല്ല. രണ്ടാമതായി, അതിൽ പാക്കേജ് ഡാറ്റ അടങ്ങിയിട്ടില്ല, അതിനാൽ മറ്റൊരു പാക്കേജിലെ ശകലം എക്സിക്യൂട്ട് ചെയ്യുന്നത് വിളിക്കാം തെറ്റായ പ്രവർത്തനം. അവസാനമായി, ഒരു ഘട്ടത്തിൽ ഫംഗ്ഷൻ അസാധുവാക്കപ്പെട്ടിട്ടുണ്ടെങ്കിൽ (ഇത് പലപ്പോഴും സംഭവിക്കുന്നില്ലെങ്കിലും), പ്രതീകാത്മക ലിങ്ക്ബന്ധപ്പെടും നിലവിലെ നിർവചനംഫംഗ്‌ഷനുകൾ, ഒരു ഹാർഡ് ലിങ്ക് പഴയ നിർവചനം നിലനിർത്തും. ഫംഗ്ഷൻ നാമം ഒരു വേരിയബിളിൽ സൂക്ഷിക്കുന്നതിനുപകരം, \ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് അതിനൊരു റഫറൻസ് ഉണ്ടാക്കുക. ഇങ്ങനെയാണ് നിങ്ങൾ ഒരു ഫംഗ്ഷൻ ഒരു വേരിയബിളിൽ സംഭരിക്കുക അല്ലെങ്കിൽ മറ്റൊരു ഫംഗ്ഷനിലേക്ക് കൈമാറേണ്ടത്. പേരിട്ട ഫംഗ്ഷൻ റഫറൻസുകൾ അജ്ഞാത ഫംഗ്ഷൻ റഫറൻസുകളുമായി സംയോജിപ്പിക്കാൻ കഴിയും: % കമാൻഡുകൾ = ("സന്തോഷം" => \&സന്തോഷം, "ദുഃഖം" => \&സുല്ലൻ, "ചെയ്തു" => ഉപ (ഡൈ "സി യാ!"), "ഭ്രാന്തൻ" = > \& ദേഷ്യം,); പ്രിന്റ് "എങ്ങനെയുണ്ട്?"; ചോമ്പ് ($ സ്ട്രിംഗ് =ഒരു മൊഡ്യൂളിന്റെ നെയിംസ്പേസ് മറ്റൊന്നിലേക്ക് തിരുകുന്നു. ഇതൊരു ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനല്ല, മറിച്ച് ഒരു മൊഡ്യൂളിൽ നിന്ന് (MODULE പാരാമീറ്റർ) പാരമ്പര്യമായി ലഭിച്ച ഒരു രീതിയാണ്, അത് മറ്റൊരു മൊഡ്യൂളിലേക്ക് അതിന്റെ പേരുകൾ (LIST പാരാമീറ്റർ) എക്‌സ്‌പോർട്ടുചെയ്യേണ്ടതുണ്ട്.
മൊഡ്യൂൾ ലിസ്റ്റ് ഇറക്കുമതി ചെയ്യുക
പ്രാദേശികമായ
ഒന്നോ അതിലധികമോ വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നതിനും സമാരംഭിക്കുന്നതിനും ലോക്കൽ() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:
പ്രാദേശിക EXPR ലോക്കൽ ($myvar, %myhash); പ്രാദേശിക $pi = 3.14159; ലോക്കൽ ($pi, $exp) = (3.14159, 2.71828);
പക്ഷേ, my() ഫംഗ്ഷനിൽ നിന്ന് വ്യത്യസ്തമായി, ഇത് ലോക്കൽ വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നില്ല, പക്ഷേ ഉള്ളിലെ ആഗോള വേരിയബിളുകൾക്കുള്ള താൽക്കാലിക മൂല്യങ്ങൾ:
- സബ്റൂട്ടീനുകൾ;
- ചുരുണ്ട ബ്രേസുകളിൽ പൊതിഞ്ഞ പ്രസ്താവനകളുടെ ഒരു ബ്ലോക്ക്;
- eval() ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യാൻ പാസ്സായ എക്സ്പ്രഷൻ;
- ഫയൽ;
വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ ലോക്കൽ() ഫംഗ്ഷൻ തന്നെ വിളിക്കുന്ന സ്ഥലത്തെ ആശ്രയിച്ച്. ഒന്നിലധികം വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ ലോക്കൽ() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നുവെങ്കിൽ, അവ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കണം. ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച ഒരു ആഗോള വേരിയബിൾ ഡിക്ലറേഷന് മുമ്പ് മുമ്പ് നേരിടുകയും കുറച്ച് മൂല്യമുണ്ടെങ്കിൽ, ഈ മൂല്യം മറഞ്ഞിരിക്കുന്ന സ്റ്റാക്കിൽ സംഭരിക്കുകയും സബ്റൂട്ടീൻ, ബ്ലോക്ക്, eval() ഫംഗ്ഷൻ അല്ലെങ്കിൽ ഫയലിൽ നിന്ന് പുറത്തുകടന്ന ശേഷം പുനഃസ്ഥാപിക്കുകയും ചെയ്യും. ലോക്കൽ() ഫംഗ്ഷൻ അല്ലെങ്കിൽ കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ അതിന്റെ താത്കാലിക മൂല്യം പ്രഖ്യാപിച്ച ഒരു വേരിയബിൾ, ഡിക്ലറേഷൻ ഉണ്ടാക്കിയിരിക്കുന്ന സബ്റൂട്ടീൻ, ബ്ലോക്ക്, ഇവാൽ() ഫംഗ്ഷൻ അല്ലെങ്കിൽ ഫയലിനുള്ളിൽ വിളിക്കപ്പെടുന്ന ഏത് ഫംഗ്ഷനിലും ലഭ്യമാണ്. അത്തരമൊരു വേരിയബിളിനെ ഡൈനാമിക് എന്നും അതിന്റെ വ്യാപ്തിയെ ഡൈനാമിക് സ്കോപ്പ് എന്നും വിളിക്കുന്നു. ഒരു വേരിയബിളിനെ ആക്സസ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷനിലേക്കുള്ള ഓരോ കോളിലും ഒരു വേരിയബിളിന്റെ വ്യാപ്തി ചലനാത്മകമായി മാറുന്നു എന്ന വസ്തുതയെ ഈ പേര് പ്രതിഫലിപ്പിക്കുന്നു.
ഉദാഹരണം:
ente
ഒന്നോ അതിലധികമോ വേരിയബിളുകൾ ലോക്കൽ ആയി പ്രഖ്യാപിക്കാൻ my() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:
കൂടാതെ അവയുടെ വ്യാപ്തി പരിമിതപ്പെടുത്തുന്നു:
- സബ്റൂട്ടീൻ;
- ചുരുണ്ട ബ്രേസുകളിൽ പൊതിഞ്ഞ പ്രസ്താവനകളുടെ ഒരു ബ്ലോക്ക്;
- eval() ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യാൻ പാസ്സായ എക്സ്പ്രഷൻ;
- ഫയൽ, വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ my() ഫംഗ്ഷൻ തന്നെ വിളിക്കുന്ന സ്ഥലത്തെ ആശ്രയിച്ച്.
EXPR എക്സ്പ്രഷനിൽ വേരിയബിളുകളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അത് പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കണം:
എന്റെ ($myvar, @mylist, %myhash);
ഡിക്ലറേഷനോടൊപ്പം, വേരിയബിളുകൾ ആരംഭിക്കാൻ കഴിയും:
എന്റെ $ പൈ = 3.14159; my ($pi, $exp) = (3.14159, 2.71828);
my() ഫംഗ്ഷൻ ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിളുകൾ അവയുടെ പരിധിയിൽ ആ പരിധിയിൽ നിർവചിച്ചിരിക്കുന്ന ദിനചര്യകൾക്ക് മാത്രമേ ലഭ്യമാകൂ. അതിന് പുറത്ത് നിർവചിച്ചിരിക്കുന്ന ദിനചര്യകൾക്ക് അവ ലഭ്യമല്ല. അത്തരം വേരിയബിളുകളെ ലെക്സിക്കൽ എന്നും സ്കോപ്പിനെ തന്നെ ലെക്സിക്കൽ അല്ലെങ്കിൽ സ്റ്റാറ്റിക് സ്കോപ്പ് എന്നും വിളിക്കുന്നു.
ഉദാഹരണം:
ഉപ f1(ലോക്കൽ ($x) = "aaaa"; my($y) = "bbbb"; പ്രിന്റ്("f1: x = $xn"); പ്രിന്റ്("f1: y = $ynn"); f2() ; പ്രിന്റ് ("f1: x = $xn"); പ്രിന്റ് ("f1: y = $ynn"); ) സബ് എഫ്2("f2: x = $xn"); പ്രിന്റ് ("f2: y = $ynn "); $x = "cccc"; $y = "dddd"; പ്രിന്റ് ("f2: x = $xn"); പ്രിന്റ് ("f2: y = $ynn"); ) f1;
വധശിക്ഷയുടെ ഫലം ഈ ഉദാഹരണംഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാകും:
F1: x = aaaa f1: y = bbbb f2: x = aaaa f2: y = f2: x = cccc f2: y = dddd f1: x = cccc f1: y = bbbb
മുകളിലെ ഫലത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, f1() എന്ന ഫംഗ്ഷനിലെ my() ഫംഗ്ഷൻ ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച $y എന്ന വേരിയബിളിലേക്ക് f2() എന്ന ഫംഗ്ഷന് ആക്സസ് ഇല്ല, മറിച്ച്, $x എന്ന വേരിയബിളിലേക്ക് ആക്സസ് ഉണ്ട്. ലോക്കൽ() എന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് f1() നുള്ളിൽ പ്രഖ്യാപിച്ചു.
പാക്കേജ്
ഒരു പ്രത്യേക ഗ്ലോബൽ നെയിംസ്പേസ് (പാക്കേജ്) നിർവചിക്കുന്നു: നിർവചിക്കാത്ത എല്ലാ ഡൈനാമിക് ഐഡന്റിഫയറുകളും (ലോക്കൽ() വഴി പ്രഖ്യാപിച്ചവ ഉൾപ്പെടെ, എന്നാൽ എന്റെ() അല്ല) അതിൽ സംഭരിക്കപ്പെടും. ഒരു പാക്കേജിന് പുറത്ത് അവ ആക്സസ് ചെയ്യുന്നതിന്, പാക്കേജിന്റെ പേരിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു പ്രിഫിക്‌സ് നിങ്ങൾ വ്യക്തമാക്കണം, തുടർന്ന് രണ്ട് കോളണുകൾ "::". പാക്കേജ് വേരിയബിളുകളുടെ വ്യാപ്തി പാക്കേജ് സ്ഥിതി ചെയ്യുന്ന സ്റ്റേറ്റ്മെന്റ് ബ്ലോക്കിന്റെ അവസാനം വരെ അല്ലെങ്കിൽ ഒരു പുതിയ പാക്കേജ് ഡിക്ലറേഷൻ വരെ നീളുന്നു. പാക്കേജിന്റെ പേര് ഒഴിവാക്കിയാൽ, ഫംഗ്ഷൻ നാമങ്ങൾ ഉൾപ്പെടെ എല്ലാ ഐഡന്റിഫയറുകളും വ്യക്തമാക്കാൻ ഇത് നിർബന്ധിക്കുന്നു.
പാക്കേജ് [PACKAGE_NAME]
ഉപയോഗിക്കുക
കംപൈൽ സമയത്ത് ഒരു മൊഡ്യൂൾ ലോഡ് ചെയ്യുന്നു; മൊഡ്യൂൾ ലഭ്യമല്ലെങ്കിൽ, മുഴുവൻ പ്രോഗ്രാമിന്റെയും സമാഹാരം നിർത്തുന്നു.
മൊഡ്യൂൾ ലിസ്റ്റ് ഉപയോഗിക്കുക മൊഡ്യൂൾ ഉപയോഗിക്കുക മൊഡ്യൂൾ പതിപ്പ് ലിസ്റ്റ് ഉപയോഗിക്കുക പതിപ്പ് ഉപയോഗിക്കുക
