ജമ്പ് സ്റ്റേറ്റ്‌മെന്റുകളും ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യലും

JavaScript ഓപ്പറേറ്റർമാരുടെ മറ്റൊരു വിഭാഗം ജമ്പ് ഓപ്പറേറ്റർമാരാണ്. പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ഈ ഓപ്പറേറ്റർമാർ ജാവാസ്ക്രിപ്റ്റ് ഇന്റർപ്രെറ്ററിനെ പ്രോഗ്രാം കോഡിലെ മറ്റൊരു സ്ഥലത്തേക്ക് മാറ്റുന്നു. ബ്രേക്ക് സ്റ്റേറ്റ്‌മെന്റ്, വ്യാഖ്യാതാവിനെ ഒരു ലൂപ്പിന്റെ അല്ലെങ്കിൽ മറ്റ് പ്രസ്താവനയുടെ അവസാനത്തിലേക്ക് കുതിക്കാൻ കാരണമാകുന്നു. തുടർന്നുള്ള പ്രസ്താവന, ലൂപ്പ് ബോഡിയുടെ ബാക്കി ഭാഗങ്ങൾ ഒഴിവാക്കാനും, ലൂപ്പിന്റെ തുടക്കത്തിലേക്ക് തിരികെ പോകാനും, ഒരു പുതിയ ആവർത്തനം നടപ്പിലാക്കാൻ തുടങ്ങാനും വ്യാഖ്യാതാവിന് കാരണമാകുന്നു. JavaScript-ന് പേരുകൾ ഉപയോഗിച്ച് പ്രസ്താവനകൾ ലേബൽ ചെയ്യാനുള്ള കഴിവുണ്ട്, അതിനാൽ ബ്രേക്ക് ചെയ്ത് തുടരുന്ന പ്രസ്താവനകൾക്ക് അവ ഏത് ലൂപ്പിലോ മറ്റ് പ്രസ്താവനകളിലോ ആണെന്ന് വ്യക്തമായി സൂചിപ്പിക്കാൻ കഴിയും.

റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റ്, വ്യാഖ്യാതാവിനെ വിളിച്ച ഫംഗ്‌ഷനിൽ നിന്ന് അത് വിളിച്ച പോയിന്റിലേക്ക് തിരികെ പോകാനും കോളിന്റെ മൂല്യം തിരികെ നൽകാനും കാരണമാകുന്നു. ത്രോ സ്റ്റേറ്റ്‌മെന്റ് ഒരു അപവാദം ഉയർത്തുന്നു, കൂടാതെ ട്രൈ/ക്യാച്ച്/ഫൈനലി സ്റ്റേറ്റ്‌മെന്റുകളുമായി സംയോജിച്ച് പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു, ഇത് ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യാൻ കോഡിന്റെ ഒരു ബ്ലോക്ക് നിർവ്വചിക്കുന്നു. ഇത് തികച്ചും സങ്കീർണ്ണമായ ഒരു ജമ്പ് ഓപ്പറേറ്ററാണ്: ഒരു അപവാദം സംഭവിക്കുമ്പോൾ, ഇന്റർപ്രെട്ടർ അടുത്തുള്ള എൻക്ലോസിംഗ് എക്‌സെപ്‌ഷൻ ഹാൻഡ്‌ലറിലേക്ക് കുതിക്കുന്നു, അത് ഒരേ ഫംഗ്‌ഷനിലോ അല്ലെങ്കിൽ വിളിക്കുന്ന ഫംഗ്‌ഷന്റെ റിട്ടേൺ സ്റ്റാക്കിൽ ഉയർന്നതോ ആകാം.

ഈ ജമ്പ് ഓപ്പറേറ്റർമാരെല്ലാം ഇനിപ്പറയുന്ന ഉപവിഭാഗങ്ങളിൽ കൂടുതൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു.

പ്രബോധന അടയാളങ്ങൾ

ഏത് നിർദ്ദേശവും ഒരു ഐഡന്റിഫയറും കോളനും ഉപയോഗിച്ച് അടയാളപ്പെടുത്താം:

ഐഡി: നിർദ്ദേശം

ഒരു നിർദ്ദേശം അടയാളപ്പെടുത്തുന്നതിലൂടെ, നിങ്ങൾ അതിന് ഒരു പേര് നൽകുന്നു, അത് പ്രോഗ്രാമിൽ എവിടെയും ഒരു റഫറൻസായി ഉപയോഗിക്കാം. നിങ്ങൾക്ക് ഏത് നിർദ്ദേശവും അടയാളപ്പെടുത്താൻ കഴിയും, എന്നാൽ ലൂപ്പുകളും സോപാധിക പ്രസ്താവനകളും പോലുള്ള ഒരു ബോഡി ഉള്ള നിർദ്ദേശങ്ങൾ അടയാളപ്പെടുത്തുന്നത് അർത്ഥമാക്കുന്നു.

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

Mainloop: while (ടോക്കൺ != null) ( // പ്രോഗ്രാം കോഡ് ഒഴിവാക്കി... മെയിൻലൂപ്പ് തുടരുക; // പേരിട്ടിരിക്കുന്ന ലൂപ്പിന്റെ അടുത്ത ആവർത്തനത്തിലേക്ക് നീങ്ങുക)

ഒരു സ്റ്റേറ്റ്‌മെന്റ് ലേബലായി ഉപയോഗിക്കുന്ന ഐഡന്റിഫയർ ഒരു റിസർവ് ചെയ്‌ത വാക്ക് ഒഴികെയുള്ള സാധുവായ ഏത് ജാവാസ്ക്രിപ്റ്റ് ഐഡന്റിഫയറും ആകാം. ലേബൽ പേരുകൾ വേരിയബിളിൽ നിന്നും ഫംഗ്‌ഷൻ നാമങ്ങളിൽ നിന്നും വേർതിരിച്ചിരിക്കുന്നു, അതിനാൽ വേരിയബിളുമായോ ഫംഗ്‌ഷൻ പേരുകളുമായോ പൊരുത്തപ്പെടുന്ന ഐഡന്റിഫയറുകൾ ലേബലുകളായി ഉപയോഗിക്കാം.

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

ബ്രേക്ക് പ്രസ്താവന

ബ്രേക്ക് സ്റ്റേറ്റ്‌മെന്റ് ഇൻറർമോസ്റ്റ് ലൂപ്പ് അല്ലെങ്കിൽ സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റ് ഉടനടി പുറത്തുകടക്കാൻ കാരണമാകുന്നു. ഒരു സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിനുള്ളിൽ ബ്രേക്ക് സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുന്നതിന്റെ ഉദാഹരണങ്ങൾ ഞങ്ങൾ മുമ്പ് കണ്ടിട്ടുണ്ട്. ലൂപ്പുകളിൽ, ചില കാരണങ്ങളാൽ ലൂപ്പ് അവസാനിപ്പിക്കേണ്ടിവരുമ്പോൾ ലൂപ്പിൽ നിന്ന് ഉടൻ പുറത്തുകടക്കാൻ ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നു.

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

Var arr = ["a","b","c","d","d"], ഫലം; (var i = 0; i

JavaScript-ൽ, ബ്രേക്ക് കീവേഡിന് ശേഷം നിങ്ങൾക്ക് ലേബലിന്റെ പേര് വ്യക്തമാക്കാൻ കഴിയും (ഒരു കോളൺ ഇല്ലാതെ ഐഡന്റിഫയർ):

ബ്രേക്ക് ലേബൽ_നെയിം;

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

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

ഏറ്റവും അടുത്തുള്ള എൻക്ലോസിംഗ് ലൂപ്പ് അല്ലെങ്കിൽ സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റ് അല്ലാത്ത ഒരു പ്രസ്താവനയുടെ നിർവ്വഹണം തടസ്സപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ മാത്രമേ ലേബൽ ചെയ്ത ബ്രേക്ക് സ്റ്റേറ്റ്‌മെന്റ് ആവശ്യമുള്ളൂ.

ഓപ്പറേറ്റർ തുടരുക

തുടർച്ചയായ പ്രസ്താവന ബ്രേക്ക് പ്രസ്താവനയ്ക്ക് സമാനമാണ്. എന്നിരുന്നാലും, ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുന്നതിനുപകരം, Continue Statement ലൂപ്പിന്റെ ഒരു പുതിയ ആവർത്തനം ആരംഭിക്കുന്നു. തുടർച്ചയായ പ്രസ്താവനയുടെ വാക്യഘടന ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റിന്റെ വാക്യഘടന പോലെ ലളിതമാണ്. ഒരു ലേബലിനൊപ്പം തുടരുന്ന പ്രസ്താവനയും ഉപയോഗിക്കാം.

ഒരു ലേബൽ ഇല്ലാതെയും ഒരു ലേബൽ ഉള്ള രൂപത്തിലും തുടരുന്ന പ്രസ്താവന, ഒരു ലൂപ്പിന്റെ ബോഡിയിൽ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. മറ്റെവിടെയെങ്കിലും ഇത് ഉപയോഗിക്കുന്നത് വാക്യഘടന പിശകിന് കാരണമാകുന്നു. Continue Statement എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ലൂപ്പിന്റെ നിലവിലെ ആവർത്തനം തടസ്സപ്പെടുകയും അടുത്തത് ആരംഭിക്കുകയും ചെയ്യുന്നു. വ്യത്യസ്‌ത തരം ലൂപ്പുകൾക്കായി ഇത് വ്യത്യസ്‌ത കാര്യങ്ങൾ അർത്ഥമാക്കുന്നു:

കുറച്ച് സമയത്തിനുള്ളിൽ, ലൂപ്പിന്റെ തുടക്കത്തിൽ വ്യക്തമാക്കിയ എക്സ്പ്രഷൻ വീണ്ടും പരിശോധിക്കുന്നു, അത് ശരിയാണെങ്കിൽ, ലൂപ്പിന്റെ ബോഡി ആദ്യം മുതൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു.

ഒരു do/while ലൂപ്പ് ലൂപ്പിന്റെ അറ്റത്തേക്ക് കുതിക്കുന്നു, അവിടെ വീണ്ടും ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് അവസ്ഥ വീണ്ടും പരിശോധിക്കും.

ഫോർ ലൂപ്പ് ഇൻക്രിമെന്റ് എക്സ്പ്രഷൻ വിലയിരുത്തുകയും അടുത്ത ആവർത്തനം നടത്തണമോ എന്ന് നിർണ്ണയിക്കാൻ ടെസ്റ്റ് എക്സ്പ്രഷൻ വീണ്ടും വിലയിരുത്തുകയും ചെയ്യുന്നു.

ഫോർ/ഇൻ ലൂപ്പിൽ, അടുത്ത പ്രോപ്പർട്ടിയുടെ പേരിലേക്ക് നിർദ്ദിഷ്ട വേരിയബിൾ നൽകി ലൂപ്പ് ആരംഭിക്കുന്നു.

ലൂപ്പുകളിലും ലൂപ്പുകളിലും തുടരുന്ന പ്രസ്താവനയുടെ പെരുമാറ്റത്തിലെ വ്യത്യാസങ്ങൾ ശ്രദ്ധിക്കുക. A while ലൂപ്പ് അതിന്റെ അവസ്ഥയിലേക്ക് നേരിട്ട് മടങ്ങുന്നു, ഒരു ഫോർ ലൂപ്പ് ആദ്യം ഇൻക്രിമെന്റ് എക്സ്പ്രഷൻ വിലയിരുത്തുകയും തുടർന്ന് അവസ്ഥയിലേക്ക് മടങ്ങുകയും ചെയ്യുന്നു. ഇരട്ട സംഖ്യകൾക്കുള്ള നിലവിലെ ലൂപ്പ് ആവർത്തനത്തിൽ നിന്ന് പുറത്തുകടക്കാൻ ഒരു ലേബൽ ഇല്ലാതെ തുടരുന്ന പ്രസ്താവനയുടെ ഉപയോഗം ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു:

വർ സം = 0; // (var i = 0; i എന്നതിനായി 0 - 10 മുതൽ ഒറ്റ സംഖ്യകളുടെ ആകെത്തുക കണക്കാക്കുക

ബ്രേക്ക് പോലെയുള്ള Continue സ്റ്റേറ്റ്‌മെന്റ്, ഒരു ലേബൽ ഉൾപ്പെടുന്ന ഒരു രൂപത്തിൽ നെസ്റ്റഡ് ലൂപ്പുകളിൽ ഉപയോഗിക്കാൻ കഴിയും, തുടർന്ന് പുനരാരംഭിക്കുന്ന ലൂപ്പ് നേരിട്ട് തുടരുന്ന പ്രസ്താവന ഉൾക്കൊള്ളുന്ന ഒരു ലൂപ്പ് ആയിരിക്കണമെന്നില്ല. കൂടാതെ, ബ്രേക്ക് പോലെ, തുടരുന്ന കീവേഡിനും ലേബൽ നാമത്തിനും ഇടയിൽ ലൈൻ ബ്രേക്കുകൾ അനുവദനീയമല്ല.

റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ്

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

ഒരു ഫംഗ്‌ഷന് റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റ് ഇല്ലെങ്കിൽ, അത് വിളിക്കപ്പെടുമ്പോൾ, ഫംഗ്‌ഷന്റെ അവസാനം എത്തുന്നതുവരെ ഇന്റർപ്രെറ്റർ ഫംഗ്‌ഷൻ ബോഡിയിലെ സ്റ്റേറ്റ്‌മെന്റുകൾ ഓരോന്നായി എക്‌സിക്യൂട്ട് ചെയ്യും, തുടർന്ന് അത് വിളിച്ച പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം തിരികെ നൽകും. ഈ സാഹചര്യത്തിൽ, കോളിംഗ് എക്സ്പ്രഷൻ നിർവചിക്കാതെ മടങ്ങിവരും. റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റ് പലപ്പോഴും ഒരു ഫംഗ്‌ഷനിലെ അവസാന പ്രസ്താവനയാണ്, പക്ഷേ ഇത് പൂർണ്ണമായും ഓപ്‌ഷണലാണ്: ഫംഗ്‌ഷൻ ബോഡിയിലെ മറ്റ് സ്‌റ്റേറ്റ്‌മെന്റുകൾ പിന്തുടരുകയാണെങ്കിൽപ്പോലും, റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റിൽ എത്തിയാലുടൻ ഫംഗ്‌ഷൻ കോളിംഗ് പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം തിരികെ നൽകും.

റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റ് ഒരു എക്‌സ്‌പ്രഷൻ ഇല്ലാതെയും ഉപയോഗിക്കാം, ഈ സാഹചര്യത്തിൽ അത് ഫംഗ്‌ഷൻ നിർത്തലാക്കുകയും കോളിംഗ് പ്രോഗ്രാമിലേക്ക് നിർവചിക്കാതെ മടങ്ങുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്:

ഫംഗ്‌ഷൻ myFun(arr) ( // അറേയിൽ നെഗറ്റീവ് നമ്പറുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, (var i = 0; i എന്നതിനായുള്ള പ്രവർത്തനം നിർത്തുക

പ്രസ്താവന എറിയുക

ഏതെങ്കിലും തരത്തിലുള്ള അസാധാരണമായ സാഹചര്യമോ പിശകോ സംഭവിച്ചുവെന്ന് സൂചിപ്പിക്കുന്ന ഒരു സിഗ്നലാണ് ഒരു അപവാദം. ഒരു അപവാദം എറിയുന്നുഅത്തരമൊരു പിശക് അല്ലെങ്കിൽ ഒഴിവാക്കൽ സൂചിപ്പിക്കാനുള്ള ഒരു മാർഗമാണ്. ഒരു അപവാദം പിടിക്കുക എന്നതിനർത്ഥം അത് പ്രോസസ്സ് ചെയ്യുക എന്നാണ്, അതായത്. ഒഴിവാക്കലിൽ നിന്ന് വീണ്ടെടുക്കുന്നതിന് ആവശ്യമായതോ ഉചിതമായതോ ആയ നടപടികൾ സ്വീകരിക്കുക.

JavaScript-ൽ, ഒരു റൺ-ടൈം പിശക് സംഭവിക്കുമ്പോൾ, ഒരു ത്രോ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് പ്രോഗ്രാം അത് വ്യക്തമായി ഉയർത്തുമ്പോൾ ഒഴിവാക്കലുകൾ എറിയപ്പെടുന്നു. പിന്നീട് വിവരിക്കുന്ന, ട്രൈ/ക്യാച്ച്/ഫൈനലി സ്റ്റേറ്റ്‌മെന്റുകൾ ഉപയോഗിച്ചാണ് ഒഴിവാക്കലുകൾ പിടിക്കപ്പെടുന്നത്.

ത്രോ പ്രസ്താവനയ്ക്ക് ഇനിപ്പറയുന്ന വാക്യഘടനയുണ്ട്:

എക്സ്പ്രഷൻ എറിയുക;

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

// നമ്പർ ഫാക്‌ടോറിയൽ ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ ഫാക്‌ടോറിയൽ (നമ്പർ) ( // ഇൻപുട്ട് ആർഗ്യുമെന്റ് സാധുവായ മൂല്യമല്ലെങ്കിൽ, // ഒരു അപവാദം എറിയുന്നു! എങ്കിൽ (നമ്പർ 1; i *= നമ്പർ, നമ്പർ--); /* ശൂന്യമായ ലൂപ്പ് ബോഡി */ തിരികെ i ; ) console.log("5! = ", factorial(5)); console.log("-3! = ", factorial(-3));

ഒരു അപവാദം ഉന്നയിക്കുമ്പോൾ, JavaScript വ്യാഖ്യാതാവ് സാധാരണ പ്രോഗ്രാം നിർവ്വഹണത്തെ ഉടനടി തടസ്സപ്പെടുത്തുകയും അടുത്തുള്ള ഒഴിവാക്കൽ ഹാൻഡ്‌ലറിലേക്ക് കുതിക്കുകയും ചെയ്യുന്നു. ഒഴിവാക്കൽ ഹാൻഡ്‌ലർമാർ അടുത്ത വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്ന ട്രൈ/ക്യാച്ച്/ഫൈനലി ക്യാച്ച് ക്ലോസ് ഉപയോഗിക്കുന്നു.

ഒഴിവാക്കൽ സംഭവിച്ച കോഡ് ബ്ലോക്കിന് അനുബന്ധമായ ഒരു ക്യാച്ച് നിർമ്മാണം ഇല്ലെങ്കിൽ, വ്യാഖ്യാതാവ് അടുത്ത ബാഹ്യ കോഡ് ബ്ലോക്ക് പരിശോധിക്കുകയും ഒരു അപവാദ ഹാൻഡ്‌ലർ അതുമായി ബന്ധപ്പെട്ടിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. ഒരു ഹാൻഡ്‌ലർ കണ്ടെത്തുന്നതുവരെ ഇത് തുടരും.

ഒരു ഫംഗ്‌ഷനിൽ ഒരു അപവാദം എറിയുകയാണെങ്കിൽ, അത് കൈകാര്യം ചെയ്യുന്നതിനായി ഒരു ട്രൈ/ക്യാച്ച്/അവസാനം കൺസ്ട്രക്‌റ്റ് അടങ്ങുന്നില്ല, ഒഴിവാക്കൽ ഫംഗ്‌ഷനെ വിളിക്കുന്ന കോഡ് വരെ വ്യാപിക്കുന്നു. ഈ രീതിയിൽ, കോൾ സ്റ്റാക്കിലെ ജാവാസ്ക്രിപ്റ്റ് രീതികളുടെ ലെക്സിക്കൽ ഘടനയിലൂടെ ഒഴിവാക്കലുകൾ പ്രചരിപ്പിക്കപ്പെടുന്നു. ഒരു ഒഴിവാക്കൽ ഹാൻഡ്‌ലർ ഒരിക്കലും കണ്ടെത്തിയില്ലെങ്കിൽ, ഒഴിവാക്കൽ ഒരു പിശകായി കണക്കാക്കുകയും ഉപയോക്താവിനെ അറിയിക്കുകയും ചെയ്യും.

ശ്രമിക്കുക/പിടിക്കുക/അവസാനം നിർമ്മിക്കുക

ശ്രമിക്കുക/പിടിക്കുക/അവസാനം നിർമ്മിക്കുക എന്നത് JavaScript-ൽ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ സംവിധാനം നടപ്പിലാക്കുന്നു. ഈ കൺസ്ട്രക്‌റ്റിലെ ട്രൈ സ്റ്റേറ്റ്‌മെന്റ്, ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്ന കോഡിന്റെ ഒരു ബ്ലോക്ക് നിർവ്വചിക്കുന്നു. ട്രൈ ബ്ലോക്കിന് ശേഷം, ട്രൈ ബ്ലോക്കിൽ എവിടെയെങ്കിലും ഒരു അപവാദം സംഭവിച്ചാൽ വിളിക്കപ്പെടുന്ന പ്രസ്താവനകളുടെ ഒരു ബ്ലോക്ക് ഉള്ള ഒരു ക്യാച്ച് സ്റ്റേറ്റ്‌മെന്റ് വരുന്നു. ക്യാച്ച് സ്റ്റേറ്റ്‌മെന്റിന് ശേഷം ഒരു ഫൈനൽ ബ്ലോക്ക് വരുന്നു, അതിൽ ട്രൈ ബ്ലോക്കിൽ എന്ത് സംഭവിച്ചാലും പ്രവർത്തിക്കുമെന്ന് ഉറപ്പുനൽകുന്ന അന്തിമ കോഡ് അടങ്ങിയിരിക്കുന്നു.

ക്യാച്ച് ബ്ലോക്കും ഫൈനൽ ബ്ലോക്കും ഓപ്ഷണലാണ്, എന്നാൽ ട്രൈ ബ്ലോക്കിന് ശേഷം അവയിലൊന്നെങ്കിലും ഉണ്ടായിരിക്കണം. ശ്രമിക്കുക, പിടിക്കുക, ഒടുവിൽ ബ്ലോക്കുകൾ ആരംഭിക്കുന്നതും അവസാനിക്കുന്നതും ചുരുണ്ട ബ്രേസുകളോടെയാണ്. ഇത് വാക്യഘടനയുടെ ആവശ്യമായ ഭാഗമാണ്, അതിനിടയിൽ ഒരു നിർദ്ദേശം മാത്രമേ ഉള്ളൂവെങ്കിലും ഇത് ഒഴിവാക്കാനാവില്ല.

ട്രൈ/ക്യാച്ച്/അവസാനം നിർമ്മിക്കുന്നതിന്റെ വാക്യഘടനയും ഉദ്ദേശ്യവും ഇനിപ്പറയുന്ന സ്‌നിപ്പറ്റ് വ്യക്തമാക്കുന്നു:

ശ്രമിക്കുക (// ഈ കോഡ് സാധാരണയായി തുടക്കം മുതൽ അവസാനം വരെ സുഗമമായി പ്രവർത്തിക്കുന്നു. // എന്നാൽ ചില ഘട്ടങ്ങളിൽ ഇത് ഒരു അപവാദം എറിഞ്ഞേക്കാം // ഒന്നുകിൽ നേരിട്ട് ത്രോ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ പരോക്ഷമായോ // ഒഴിവാക്കൽ എറിയുന്ന ഒരു രീതിയെ വിളിച്ച്. ) പിടിക്കുക ( ഉദാ) ( // ട്രൈ ബ്ലോക്കിൽ // ഒരു അപവാദം ഉണ്ടായാൽ മാത്രമേ ഈ ബ്ലോക്കിലെ സ്റ്റേറ്റ്‌മെന്റുകൾ എക്‌സിക്യൂട്ട് ചെയ്യൂ. ഈ പ്രസ്താവനകൾക്ക് ലോക്കൽ വേരിയബിൾ ഉപയോഗിക്കാം, അത് // ഒരു പിശക് ഒബ്‌ജക്റ്റിനെ അല്ലെങ്കിൽ ത്രോയിൽ വ്യക്തമാക്കിയ മറ്റൊരു മൂല്യത്തെ സൂചിപ്പിക്കുന്നു. പ്രസ്താവന. // ഈ ബ്ലോക്കിന് ഏതെങ്കിലും വിധത്തിൽ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാൻ കഴിയും, // മറ്റെന്തെങ്കിലും ചെയ്യുമ്പോൾ അത് അവഗണിക്കുക, അല്ലെങ്കിൽ ഒഴിവാക്കൽ വീണ്ടും എറിയുക // ഒരു ത്രോ പ്രസ്താവന ഉപയോഗിച്ച്. ) ഒടുവിൽ ( // ഈ ബ്ലോക്കിൽ എല്ലായ്പ്പോഴും നടപ്പിലാക്കുന്ന പ്രസ്താവനകൾ അടങ്ങിയിരിക്കുന്നു. , പരിഗണിക്കാതെ , // ട്രൈ ബ്ലോക്കിൽ എന്ത് സംഭവിച്ചു എന്നത് ട്രൈ ബ്ലോക്ക് പൂർത്തിയായാൽ അവ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും: // 1) പതിവ് പോലെ, ബ്ലോക്കിന്റെ അവസാനത്തിൽ എത്തിക്കഴിഞ്ഞാൽ // 2) ഒരു ഇടവേള കാരണം, തുടരുക അല്ലെങ്കിൽ പ്രസ്താവന തിരികെ നൽകുക / / 3) മുകളിലുള്ള ക്യാച്ച് ബ്ലോക്കിലുള്ള ഒരാൾ കൈകാര്യം ചെയ്യുന്ന ഒഴികെ // 4) പിടിക്കപ്പെടാത്ത ഒരു ഒഴിവാക്കലിനൊപ്പം // ഉയർന്ന തലങ്ങളിലേക്ക് പ്രചരിപ്പിക്കുന്നത് തുടരുന്നു)

ക്യാച്ച് കീവേഡിന് ശേഷം പരാൻതീസിസിൽ ഒരു ഐഡന്റിഫയർ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക. ഈ ഐഡന്റിഫയർ ഒരു ഫംഗ്ഷൻ പാരാമീറ്ററിന് സമാനമാണ്. ഒരു അപവാദം പിടിക്കപ്പെടുമ്പോൾ, ഈ പരാമീറ്റർ ഒഴിവാക്കലിലേക്ക് അസൈൻ ചെയ്യപ്പെടും (ഉദാഹരണത്തിന്, ഒരു പിശക് ഒബ്ജക്റ്റ്). ഒരു സാധാരണ വേരിയബിളിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു ക്യാച്ച് സ്റ്റേറ്റ്മെന്റുമായി ബന്ധപ്പെട്ട ഐഡന്റിഫയർ ക്യാച്ച് ബ്ലോക്കിന്റെ ബോഡിയിൽ മാത്രമേ നിലനിൽക്കുന്നുള്ളൂ.

ഒരു ട്രൈ/ക്യാച്ച് നിർമ്മിതിയുടെ കൂടുതൽ റിയലിസ്റ്റിക് ഉദാഹരണമാണ് ഇനിപ്പറയുന്നത്. മുമ്പത്തെ ഉദാഹരണത്തിൽ നിർവചിച്ചിരിക്കുന്ന ഫാക്‌ടോറിയൽ() രീതിയെയും ഇൻപുട്ടും ഔട്ട്‌പുട്ടും ഓർഗനൈസുചെയ്യുന്നതിനുള്ള ക്ലയന്റ് JavaScript പ്രോംപ്റ്റ്() ഉം അലേർട്ട് () രീതികളെയും ഇത് വിളിക്കുന്നു:

ശ്രമിക്കുക ( // ഒരു സംഖ്യയ്ക്കായി ഉപയോക്താവിനോട് ആവശ്യപ്പെടുക var n = നമ്പർ(പ്രോംപ്റ്റ്("ഒരു പോസിറ്റീവ് നമ്പർ നൽകുക", "")); // ഇൻപുട്ട് ശരിയാണെന്ന് കരുതി // ഒരു സംഖ്യയുടെ ഫാക്‌ടോറിയൽ കണക്കാക്കുക var f = ഫാക്‌ടോറിയൽ (n); // ഫല അലേർട്ട് പ്രിന്റ് ചെയ്യുക(n + "! = " + f); ) ക്യാച്ച് (ഉദാഹരണം) ( // ഡാറ്റ തെറ്റാണെങ്കിൽ, നിയന്ത്രണം ഇവിടെ കൈമാറും മുന്നറിയിപ്പ് (ഉദാ); // ഉപയോക്താവിനെ അറിയിക്കുക തെറ്റിനെക്കുറിച്ച്)

ഉപയോക്താവ് ഒരു നെഗറ്റീവ് നമ്പർ നൽകിയാൽ, ഒരു മുന്നറിയിപ്പ് സന്ദേശം ദൃശ്യമാകും:

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

ഒരു സാധാരണ സാഹചര്യത്തിൽ, നിയന്ത്രണം ട്രൈ ബ്ലോക്കിന്റെ അവസാനത്തിൽ എത്തുന്നു, തുടർന്ന് അവസാന ബ്ലോക്കിലേക്ക് നീങ്ങുന്നു, അത് ആവശ്യമായ അന്തിമ പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു. ഒരു റിട്ടേൺ, തുടരുക അല്ലെങ്കിൽ ബ്രേക്ക് പ്രസ്താവനയുടെ ഫലമായി ഒരു ട്രൈ ബ്ലോക്കിൽ നിന്ന് നിയന്ത്രണം പുറത്തുകടക്കുകയാണെങ്കിൽ, നിയന്ത്രണം മറ്റെവിടെയെങ്കിലും കൈമാറുന്നതിന് മുമ്പ് അവസാനം ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.

ഒരു ട്രൈ ബ്ലോക്കിൽ ഒരു അപവാദം സംഭവിക്കുകയും അത് കൈകാര്യം ചെയ്യാൻ അനുയോജ്യമായ ഒരു ക്യാച്ച് ബ്ലോക്ക് ഉണ്ടെങ്കിൽ, നിയന്ത്രണം ആദ്യം ക്യാച്ച് ബ്ലോക്കിലേക്കും പിന്നീട് അവസാന ബ്ലോക്കിലേക്കും കടന്നുപോകുന്നു. ലോക്കൽ ക്യാച്ച് ബ്ലോക്ക് ഇല്ലെങ്കിൽ, നിയന്ത്രണം ആദ്യം ഫൈനൽ ബ്ലോക്കിലേക്ക് കടന്നുപോകുന്നു, തുടർന്ന് ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും അടുത്തുള്ള ബാഹ്യ ക്യാച്ച് ബ്ലോക്കിലേക്ക് നീങ്ങുന്നു.

റിട്ടേൺ, തുടരുക, ബ്രേക്ക്, അല്ലെങ്കിൽ ത്രോ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ ഒരു അപവാദം എറിയുന്ന ഒരു രീതി വിളിക്കുന്നതിലൂടെയോ അവസാനം ബ്ലോക്ക് തന്നെ നിയന്ത്രണം കൈമാറുകയാണെങ്കിൽ, തീർച്ചപ്പെടുത്താത്ത ട്രാൻസ്ഫർ കമാൻഡ് റദ്ദാക്കുകയും പുതിയൊരെണ്ണം എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, അവസാനമായി ഒരു ബ്ലോക്ക് ഒരു അപവാദം എറിയുകയാണെങ്കിൽ, ആ ഒഴിവാക്കൽ മുമ്പ് എറിഞ്ഞ ഏതെങ്കിലും ഒഴിവാക്കലിനെ മാറ്റിസ്ഥാപിക്കും.

കമ്പ്യൂട്ടർ സയൻസ് പ്രതിഭകൾക്കുള്ള ഒരു കലയാണെന്ന് ആളുകൾ കരുതുന്നു. വാസ്തവത്തിൽ, ഇത് നേരെ മറിച്ചാണ് - ചെറിയ ഉരുളൻ കല്ലുകൾ കൊണ്ട് ഒരു മതിൽ ഉണ്ടാക്കുന്നതുപോലെ, പരസ്പരം മുകളിൽ നിൽക്കുന്ന കാര്യങ്ങൾ നിർമ്മിക്കുന്ന ധാരാളം ആളുകൾ.

ഡൊണാൾഡ് നൂത്ത്

അലേർട്ട് പോലുള്ള ഫംഗ്‌ഷനുകളിലേക്കുള്ള കോളുകൾ നിങ്ങൾ ഇതിനകം കണ്ടിട്ടുണ്ട്. ജാവാസ്ക്രിപ്റ്റ് പ്രോഗ്രാമിംഗിന്റെ ബ്രെഡും ബട്ടറും ആണ് ഫംഗ്ഷനുകൾ. പ്രോഗ്രാമിന്റെ ഒരു ഭാഗം പൊതിഞ്ഞ് അതിനെ ഒരു വേരിയബിൾ എന്ന് വിളിക്കുക എന്ന ആശയം വളരെ ജനപ്രിയമാണ്. വലിയ പ്രോഗ്രാമുകൾ രൂപപ്പെടുത്തുന്നതിനും ആവർത്തനം കുറയ്ക്കുന്നതിനും സബ്റൂട്ടീനുകൾക്ക് പേരിടുന്നതിനും സബ്റൂട്ടീനുകളെ പരസ്പരം വേർതിരിച്ചെടുക്കുന്നതിനുമുള്ള ഒരു ഉപകരണമാണിത്.

ഫംഗ്ഷനുകളുടെ ഏറ്റവും വ്യക്തമായ ഉപയോഗം ഒരു പുതിയ നിഘണ്ടു സൃഷ്ടിക്കുക എന്നതാണ്. സാധാരണ മനുഷ്യ ഗദ്യത്തിന് വാക്കുകൾ കണ്ടുപിടിക്കുന്നത് മോശം രൂപമാണ്. പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ഇത് ആവശ്യമാണ്.

മുതിർന്ന റഷ്യൻ സ്പീക്കർക്ക് ഏകദേശം 10,000 വാക്കുകൾ അറിയാം. ഒരു അപൂർവ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ 10,000 ബിൽറ്റ്-ഇൻ കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു. ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെ പദാവലി കൂടുതൽ വ്യക്തമായി നിർവചിച്ചിരിക്കുന്നു, അതിനാൽ ഇത് മനുഷ്യനെക്കാൾ വഴക്കമുള്ളതാണ്. അതിനാൽ, അനാവശ്യമായ ആവർത്തനങ്ങൾ ഒഴിവാക്കാൻ സാധാരണയായി നമ്മുടെ സ്വന്തം വാക്കുകൾ അതിൽ ചേർക്കണം.

ഫംഗ്ഷൻ ഡെഫനിഷൻ ഒരു ഫംഗ്ഷൻ ഡെഫനിഷൻ ഒരു സാധാരണ വേരിയബിൾ ഡെഫനിഷൻ ആണ്, അവിടെ വേരിയബിളിന് ലഭിക്കുന്ന മൂല്യം ഒരു ഫംഗ്ഷൻ ആണ്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ് ഒരു വേരിയബിൾ സ്ക്വയർ നിർവചിക്കുന്നു, അത് തന്നിരിക്കുന്ന സംഖ്യയുടെ വർഗ്ഗം കണക്കാക്കുന്ന ഒരു ഫംഗ്ഷനെ സൂചിപ്പിക്കുന്നു:

Var സ്ക്വയർ = ഫംഗ്ഷൻ(x) (റിട്ടേൺ x * x; ); console.log(ചതുരം(12)); // → 144

ഫംഗ്‌ഷൻ കീവേഡിൽ ആരംഭിക്കുന്ന ഒരു എക്‌സ്‌പ്രഷൻ ഉപയോഗിച്ചാണ് ഒരു ഫംഗ്‌ഷൻ സൃഷ്‌ടിക്കുന്നത്. ഫംഗ്‌ഷനുകൾക്ക് ഒരു കൂട്ടം പാരാമീറ്ററുകൾ ഉണ്ട് (ഈ സാഹചര്യത്തിൽ, x മാത്രം), ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ എക്‌സിക്യൂട്ട് ചെയ്യേണ്ട നിർദ്ദേശങ്ങൾ അടങ്ങിയ ഒരു ബോഡി. ഒരു ഫംഗ്‌ഷന്റെ ബോഡി എല്ലായ്‌പ്പോഴും ചുരുണ്ട ബ്രേസുകളിൽ ഘടിപ്പിച്ചിരിക്കുന്നു, അതിൽ ഒരൊറ്റ പ്രസ്താവന അടങ്ങിയിട്ടുണ്ടെങ്കിലും.

ഒരു ഫംഗ്‌ഷന് നിരവധി പാരാമീറ്ററുകൾ ഉണ്ടായിരിക്കാം അല്ലെങ്കിൽ ഒന്നുമില്ല. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, makeNoise-ന് പാരാമീറ്ററുകളുടെ ഒരു ലിസ്റ്റ് ഇല്ല, എന്നാൽ പവർ രണ്ട് ഉണ്ട്:

Var makeNoise = ഫങ്ഷൻ() ( console.log("Shit!"); ); ശബ്ദം ഉണ്ടാക്കുക(); // → ക്ര്യ! var പവർ = ഫംഗ്‌ഷൻ (ബേസ്, എക്‌സ്‌പോണന്റ്) (var ഫലം = 1; എന്നതിന് (var count = 0; count< exponent; count++) result *= base; return result; }; console.log(power(2, 10)); // → 1024

ചില ഫംഗ്‌ഷനുകൾ പവർ, സ്‌ക്വയർ എന്നിവ പോലെയുള്ള ഒരു മൂല്യം നൽകുന്നു, മറ്റുള്ളവ, makeNoise പോലെയല്ല, ഇത് ഒരു പാർശ്വഫലം മാത്രം സൃഷ്‌ടിക്കുന്നു. റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റ് ഫംഗ്‌ഷൻ നൽകിയ മൂല്യം വ്യക്തമാക്കുന്നു. പ്രോഗ്രാം പ്രോസസ്സിംഗ് ഈ നിർദ്ദേശത്തിൽ എത്തുമ്പോൾ, അത് ഉടൻ തന്നെ ഫംഗ്ഷനിൽ നിന്ന് പുറത്തുകടക്കുകയും ഫംഗ്ഷൻ വിളിച്ച കോഡിലെ സ്ഥലത്തേക്ക് ഈ മൂല്യം തിരികെ നൽകുകയും ചെയ്യുന്നു. ഒരു പദപ്രയോഗം കൂടാതെ മടങ്ങുക.

പരാമീറ്ററുകളും സ്കോപ്പ് ഫംഗ്ഷൻ പാരാമീറ്ററുകളും ഒരേ വേരിയബിളുകളാണ്, എന്നാൽ ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ അവയുടെ പ്രാരംഭ മൂല്യങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു, അല്ലാതെ അതിന്റെ കോഡിലല്ല.

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

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

ഇനിപ്പറയുന്ന കോഡ് ഇത് വ്യക്തമാക്കുന്നു. x എന്ന വേരിയബിളിന് ഒരു മൂല്യം നൽകുന്ന രണ്ട് ഫംഗ്ഷനുകളെ ഇത് നിർവചിക്കുകയും വിളിക്കുകയും ചെയ്യുന്നു. ആദ്യത്തേത് ലോക്കൽ ആയി പ്രഖ്യാപിക്കുന്നു, അതുവഴി ലോക്കൽ വേരിയബിൾ മാത്രം മാറ്റുന്നു. രണ്ടാമത്തേത് പ്രഖ്യാപിക്കുന്നില്ല, അതിനാൽ ഫംഗ്‌ഷനുള്ളിൽ x ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഉദാഹരണത്തിന്റെ തുടക്കത്തിൽ നിർവചിച്ചിരിക്കുന്ന ആഗോള വേരിയബിളിനെ സൂചിപ്പിക്കുന്നു x.

Var x = "പുറത്ത്"; var f1 = ഫംഗ്‌ഷൻ() (var x = "f1 ഉള്ളിൽ"; ); f1(); console.log(x); // → പുറത്ത് var f2 = ഫംഗ്‌ഷൻ() ( x = "അകത്ത് f2"; ); f2(); console.log(x); // → f2 ഉള്ളിൽ

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

നെസ്റ്റഡ് സ്കോപ്പിംഗ് JavaScript ആഗോള, പ്രാദേശിക വേരിയബിളുകൾക്കിടയിൽ മാത്രമല്ല കൂടുതൽ വേർതിരിക്കുന്നത്. ഫംഗ്ഷനുകൾക്കുള്ളിൽ ഫംഗ്‌ഷനുകൾ നിർവചിക്കാനാകും, ഇത് പ്രാദേശികതയുടെ ഒന്നിലധികം തലങ്ങളിൽ കലാശിക്കുന്നു.

ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന അർത്ഥശൂന്യമായ ഫംഗ്ഷനിൽ രണ്ടെണ്ണം കൂടി അടങ്ങിയിരിക്കുന്നു:

Var ലാൻഡ്‌സ്‌കേപ്പ് = ഫംഗ്‌ഷൻ() ( var ഫലം = ""; var ഫ്ലാറ്റ് = ഫംഗ്‌ഷൻ (വലിപ്പം) ( (var count = 0; count< size; count++) result += "_"; }; var mountain = function(size) { result += "/"; for (var count = 0; count < size; count++) result += """; result += "\\"; }; flat(3); mountain(4); flat(6); mountain(1); flat(1); return result; }; console.log(landscape()); // → ___/""""\______/"\_

ഫ്ലാറ്റ്, മൗണ്ടൻ ഫംഗ്‌ഷനുകൾ ഫല വേരിയബിളിനെ കാണുന്നു, കാരണം അവ അതിനെ നിർവചിക്കുന്ന ഫംഗ്‌ഷനുള്ളിലാണ്. എന്നാൽ ഒരു ഫംഗ്‌ഷന്റെ വേരിയബിളുകൾ മറ്റൊന്നിന്റെ പരിധിക്ക് പുറത്തായതിനാൽ അവർക്ക് പരസ്പരം കൗണ്ട് വേരിയബിളുകൾ കാണാൻ കഴിയില്ല. ലാൻഡ്‌സ്‌കേപ്പ് ഫംഗ്‌ഷന് പുറത്തുള്ള പരിസ്ഥിതി ഈ ഫംഗ്‌ഷനിൽ നിർവചിച്ചിരിക്കുന്ന വേരിയബിളുകളൊന്നും കാണുന്നില്ല.

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

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾ പഠിച്ച ആളുകൾ, ചുരുണ്ട ബ്രേസുകളിൽ ഘടിപ്പിച്ചിരിക്കുന്ന ഏത് ബ്ലോക്കും അതിന്റേതായ പ്രാദേശിക അന്തരീക്ഷം സൃഷ്ടിക്കുമെന്ന് ചിന്തിച്ചേക്കാം. എന്നാൽ ജാവാസ്ക്രിപ്റ്റിൽ, ഫംഗ്ഷനുകൾ മാത്രമേ സ്കോപ്പ് സൃഷ്ടിക്കൂ. നിങ്ങൾക്ക് ഫ്രീസ്റ്റാൻഡിംഗ് ബ്ലോക്കുകൾ ഉപയോഗിക്കാം:

Var എന്തെങ്കിലും = 1; ( var എന്തോ = 2; // എന്തെങ്കിലും വേരിയബിൾ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക... ) // ബ്ലോക്കിൽ നിന്ന് പുറത്തുകടന്നു...

എന്നാൽ ബ്ലോക്കിനുള്ളിലെ എന്തോ ഒന്ന് പുറത്തുള്ള അതേ വേരിയബിൾ ആണ്. അത്തരം ബ്ലോക്കുകൾ അനുവദനീയമാണെങ്കിലും, if സ്റ്റേറ്റ്‌മെന്റുകൾക്കും ലൂപ്പുകൾക്കും മാത്രമേ അവ ഉപയോഗിക്കുന്നത് അർത്ഥമാക്കൂ.

ഇത് നിങ്ങൾക്ക് വിചിത്രമായി തോന്നുകയാണെങ്കിൽ, നിങ്ങൾ മാത്രമല്ല അങ്ങനെ ചിന്തിക്കുന്നത്. JavaScript 1.7 ലെറ്റ് കീവേഡ് അവതരിപ്പിച്ചു, അത് var പോലെ പ്രവർത്തിക്കുന്നു, എന്നാൽ ഫംഗ്ഷനിൽ മാത്രമല്ല, ഏത് ബ്ലോക്കിലും പ്രാദേശികമായ വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നു.

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

എന്നാൽ ഇവ രണ്ട് വ്യത്യസ്ത കാര്യങ്ങളാണ്. ഒരു ഫംഗ്ഷൻ കോൾ ഒരു ലളിതമായ വേരിയബിൾ പോലെ ഉപയോഗിക്കാം - ഉദാഹരണത്തിന്, ഏത് എക്സ്പ്രഷനിലും ഉപയോഗിക്കുന്നു. ഒരു ഫംഗ്‌ഷൻ കോൾ ഒരു പുതിയ വേരിയബിളിൽ സംഭരിക്കാനും മറ്റൊരു ഫംഗ്‌ഷനിലേക്ക് ഒരു പാരാമീറ്ററായി കൈമാറാനും മറ്റും സാധ്യമാണ്. കൂടാതെ, ഫംഗ്‌ഷൻ കോൾ സംഭരിക്കുന്ന വേരിയബിൾ ഒരു സാധാരണ വേരിയബിളായി തുടരുകയും അതിന്റെ മൂല്യം മാറ്റുകയും ചെയ്യാം:

Var ലോഞ്ച് മിസൈലുകൾ = പ്രവർത്തനം (മൂല്യം) ( missileSystem.launch ("അല്ലെങ്കിൽ!"); ); എങ്കിൽ (സേഫ്മോഡ്) ലോഞ്ച് മിസൈലുകൾ = ഫംഗ്ഷൻ (മൂല്യം) (/* റദ്ദാക്കുക */);

അദ്ധ്യായം 5-ൽ, മറ്റ് ഫംഗ്‌ഷനുകളിലേക്ക് ഫംഗ്‌ഷൻ കോളുകൾ കൈമാറുന്നതിലൂടെ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന അത്ഭുതകരമായ കാര്യങ്ങളെക്കുറിച്ച് ഞങ്ങൾ ചർച്ച ചെയ്യും.

ഫംഗ്‌ഷനുകൾ പ്രഖ്യാപിക്കുന്നു “var സ്ക്വയർ = ഫംഗ്‌ഷൻ...” എന്ന പദപ്രയോഗത്തിന്റെ ഒരു ചെറിയ പതിപ്പുണ്ട്. ഒരു പ്രസ്താവനയുടെ തുടക്കത്തിൽ ഫംഗ്ഷൻ കീവേഡ് ഉപയോഗിക്കാം:

ഫംഗ്ഷൻ സ്ക്വയർ(x) (റിട്ടേൺ x * x; )

ഇതൊരു ഫംഗ്‌ഷൻ പ്രഖ്യാപനമാണ്. സ്റ്റേറ്റ്മെന്റ് സ്ക്വയർ വേരിയബിളിനെ നിർവചിക്കുകയും അതിന് നൽകിയിരിക്കുന്ന ഫംഗ്ഷൻ നൽകുകയും ചെയ്യുന്നു. ഇതുവരെ വളരെ നല്ലതായിരുന്നു. അത്തരമൊരു നിർവചനത്തിൽ ഒരേയൊരു പോരായ്മ മാത്രമേയുള്ളൂ.

Console.log("ഭാവി പറയുന്നു:", ഭാവി()); ഫംഗ്ഷൻ ഫ്യൂച്ചർ() ("ഞങ്ങൾക്ക് ഇപ്പോഴും പറക്കുന്ന കാറുകളൊന്നുമില്ല" എന്ന് മടങ്ങുക;)

ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്ന കോഡിന് താഴെയായി പ്രഖ്യാപിച്ചിട്ടുണ്ടെങ്കിലും ഈ കോഡ് പ്രവർത്തിക്കുന്നു. കാരണം, ഫംഗ്‌ഷൻ ഡിക്ലറേഷനുകൾ സാധാരണ ടോപ്പ്-ഡൗൺ പ്രോഗ്രാം എക്‌സിക്യൂഷന്റെ ഭാഗമല്ല. അവ അവരുടെ വ്യാപ്തിയുടെ മുകളിലേക്ക് "നീക്കപ്പെട്ടു", ആ സ്കോപ്പിലെ ഏത് കോഡ് ഉപയോഗിച്ചും അവരെ വിളിക്കാം. ചില സമയങ്ങളിൽ ഇത് സൗകര്യപ്രദമാണ്, കാരണം അവ ഉപയോഗിക്കുന്ന സ്ഥലത്തിന് മുകളിലുള്ള എല്ലാ ഫംഗ്‌ഷനുകളും നിർവചിക്കേണ്ടതില്ല എന്നതിനെക്കുറിച്ച് വിഷമിക്കാതെ നിങ്ങൾക്ക് ഏറ്റവും അർത്ഥവത്തായ ക്രമത്തിൽ കോഡ് എഴുതാൻ കഴിയും.

ഒരു സോപാധിക ബ്ലോക്കിലോ ലൂപ്പിനോ ഉള്ളിൽ നമ്മൾ ഒരു ഫംഗ്ഷൻ ഡിക്ലറേഷൻ നൽകിയാൽ എന്ത് സംഭവിക്കും? നിങ്ങൾ അത് ചെയ്യേണ്ടതില്ല. ചരിത്രപരമായി, വ്യത്യസ്ത JavaScript പ്രവർത്തിക്കുന്ന പ്ലാറ്റ്‌ഫോമുകൾ ഇത്തരം കേസുകൾ വ്യത്യസ്തമായി കൈകാര്യം ചെയ്തിട്ടുണ്ട്, നിലവിലെ ഭാഷാ നിലവാരം ഇത് നിരോധിക്കുന്നു. നിങ്ങളുടെ പ്രോഗ്രാമുകൾ തുടർച്ചയായി പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, മറ്റ് ഫംഗ്ഷനുകളിലോ പ്രധാന പ്രോഗ്രാമിലോ മാത്രം ഫംഗ്ഷൻ ഡിക്ലറേഷനുകൾ ഉപയോഗിക്കുക.

ഫംഗ്‌ഷൻ ഉദാഹരണം() ( ഫംഗ്‌ഷൻ a() () // (എന്തെങ്കിലും) ആണെങ്കിൽ സാധാരണ (ഫംഗ്ഷൻ b() () // Ay-yay-yay! ) )

കോൾ സ്റ്റാക്ക് ഫംഗ്‌ഷനുകൾക്കൊപ്പം എക്‌സിക്യൂഷൻ ഓർഡർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് സൂക്ഷ്മമായി പരിശോധിക്കുന്നത് സഹായകരമാണ്. കുറച്ച് ഫംഗ്ഷൻ കോളുകളുള്ള ഒരു ലളിതമായ പ്രോഗ്രാം ഇതാ:

ഫംഗ്ഷൻ ഗ്രീറ്റ്(ആരാണ്) ( console.log("ഹലോ, " + ആരാണ്); )ഗ്രീറ്റ്("സെമിയോൺ"); console.log("പോക്കെഡ");

ഇത് ഇതുപോലെയാണ് പ്രോസസ്സ് ചെയ്യുന്നത്: ആശംസകൾ വിളിക്കുന്നത് പാസ് ഫംഗ്ഷന്റെ തുടക്കത്തിലേക്ക് കുതിക്കാൻ കാരണമാകുന്നു. ഇത് ബിൽറ്റ്-ഇൻ console.log ഫംഗ്‌ഷനെ വിളിക്കുന്നു, അത് നിയന്ത്രണത്തെ തടസ്സപ്പെടുത്തുകയും അതിന്റെ കാര്യം ചെയ്യുകയും നിയന്ത്രണം തിരികെ നൽകുകയും ചെയ്യുന്നു. തുടർന്ന് അവൻ അഭിവാദനത്തിന്റെ അവസാനത്തിലെത്തി, അവനെ വിളിച്ച സ്ഥലത്തേക്ക് മടങ്ങുന്നു. അടുത്ത വരി വീണ്ടും console.log എന്ന് വിളിക്കുന്നു.

ഇത് സ്കീമാറ്റിക്കായി ഇതുപോലെ കാണിക്കാം:

ടോപ്പ് ഗ്രീറ്റ് കൺസോൾ.ലോഗ് ഗ്രീറ്റ് ടോപ്പ് കൺസോൾ.ലോഗ് ടോപ്പ്

ഫംഗ്ഷൻ അത് വിളിച്ച സ്ഥലത്തേക്ക് മടങ്ങേണ്ടതിനാൽ, ഏത് സന്ദർഭത്തിൽ നിന്നാണ് ഫംഗ്ഷൻ വിളിച്ചതെന്ന് കമ്പ്യൂട്ടർ ഓർക്കണം. ഒരു സാഹചര്യത്തിൽ, console.log വീണ്ടും ആശംസകൾ അറിയിക്കണം. മറ്റൊന്നിൽ, അവൾ പ്രോഗ്രാമിന്റെ അവസാനത്തിലേക്ക് മടങ്ങുന്നു.

കമ്പ്യൂട്ടർ സന്ദർഭം ഓർക്കുന്ന സ്ഥലത്തെ സ്റ്റാക്ക് എന്ന് വിളിക്കുന്നു. ഓരോ തവണയും ഒരു ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, നിലവിലെ സന്ദർഭം സ്റ്റാക്കിന്റെ മുകളിലേക്ക് തള്ളപ്പെടും. ഫംഗ്‌ഷൻ തിരികെ വരുമ്പോൾ, അത് സ്റ്റാക്കിൽ നിന്ന് മുകളിലെ സന്ദർഭം പോപ്പ് ചെയ്യുകയും പ്രവർത്തിക്കുന്നത് തുടരാൻ അത് ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

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

ഫംഗ്ഷൻ ചിക്കൻ() (റിട്ടേൺ എഗ്(); ) ഫംഗ്ഷൻ മുട്ട() (റിട്ടേൺ ചിക്കൻ(); ) console.log(ചിക്കൻ() + "ആദ്യം വന്നു."); // → ??

ഓപ്ഷണൽ ആർഗ്യുമെന്റുകൾ ഇനിപ്പറയുന്ന കോഡ് പൂർണ്ണമായും നിയമപരവും പ്രശ്നങ്ങളില്ലാതെ പ്രവർത്തിക്കുന്നതുമാണ്:

മുന്നറിയിപ്പ്("ഹലോ", "ഗുഡ് ഈവനിംഗ്", "എല്ലാവർക്കും ഹലോ!");

ഔദ്യോഗികമായി, ഫംഗ്ഷൻ ഒരു വാദം എടുക്കുന്നു. എന്നിരുന്നാലും, ഇങ്ങനെ വെല്ലുവിളിക്കുമ്പോൾ അവൾ പരാതിപ്പെടുന്നില്ല. അവൾ ബാക്കിയുള്ള വാദങ്ങൾ അവഗണിക്കുകയും "ഹലോ" കാണിക്കുകയും ചെയ്യുന്നു.

ഒരു ഫംഗ്‌ഷനിലേക്ക് കൈമാറിയ ആർഗ്യുമെന്റുകളുടെ എണ്ണത്തെക്കുറിച്ച് JavaScript വളരെ പ്രത്യേകമാണ്. നിങ്ങൾ വളരെയധികം കൈമാറുകയാണെങ്കിൽ, അധികമുള്ളവ അവഗണിക്കപ്പെടും. വളരെ കുറച്ച്, ഇല്ലാത്തവയ്ക്ക് നിർവചിക്കാത്ത മൂല്യം നൽകും.

ഈ സമീപനത്തിന്റെ പോരായ്മ, ആരും പരാതിപ്പെടാതെ തന്നെ ഒരു ഫംഗ്‌ഷനിലേക്ക് തെറ്റായ ആർഗ്യുമെന്റുകൾ കൈമാറുന്നത് സാധ്യമാണ് - മാത്രമല്ല സാധ്യതയുമുണ്ട്.

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

ഫംഗ്‌ഷൻ പവർ (ബേസ്, എക്‌സ്‌പോണന്റ്) (എങ്കിൽ (എക്‌സ്‌പോണന്റ് == നിർവചിക്കാത്തത്) എക്‌സ്‌പോണന്റ് = 2; var ഫലം = 1; (var count = 0; count< exponent; count++) result *= base; return result; } console.log(power(4)); // → 16 console.log(power(4, 3)); // → 64

അടുത്ത അധ്യായത്തിൽ, ഒരു ഫംഗ്‌ഷന്റെ ബോഡിയിൽ അതിലേക്ക് കൈമാറിയ ആർഗ്യുമെന്റുകളുടെ കൃത്യമായ എണ്ണം നിങ്ങൾക്ക് എങ്ങനെ കണ്ടെത്താമെന്ന് ഞങ്ങൾ നോക്കാം. ഇത് ഉപയോഗപ്രദമാണ് കാരണം... എത്ര ആർഗ്യുമെന്റുകളും എടുക്കുന്ന ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, console.log ഈ പ്രോപ്പർട്ടി ഉപയോഗിക്കുകയും അതിലേക്ക് അയച്ച എല്ലാ ആർഗ്യുമെന്റുകളും പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു:

Console.log("R", 2, "D", 2); // → R 2 D 2

ക്ലോഷറുകൾ ഫംഗ്‌ഷൻ കോളുകൾ വേരിയബിളുകളായി ഉപയോഗിക്കാനുള്ള കഴിവും, ഓരോ തവണ ഫംഗ്‌ഷൻ വിളിക്കുമ്പോഴും ലോക്കൽ വേരിയബിളുകൾ പുതുതായി സൃഷ്‌ടിക്കപ്പെടുമെന്ന വസ്തുതയും രസകരമായ ഒരു ചോദ്യത്തിലേക്ക് നമ്മെ നയിക്കുന്നു. ഒരു ഫംഗ്‌ഷൻ പ്രവർത്തിക്കുന്നത് നിർത്തുമ്പോൾ ലോക്കൽ വേരിയബിളുകൾക്ക് എന്ത് സംഭവിക്കും?

ഇനിപ്പറയുന്ന ഉദാഹരണം ഈ പ്രശ്നം വ്യക്തമാക്കുന്നു. ഇത് ഒരു ലോക്കൽ വേരിയബിൾ സൃഷ്ടിക്കുന്ന wrapValue ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നു. ഈ ലോക്കൽ വേരിയബിൾ വായിക്കുകയും അതിന്റെ മൂല്യം നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ അത് തിരികെ നൽകുന്നു.

ഫംഗ്ഷൻ wrapValue(n) (var localVariable = n; റിട്ടേൺ ഫംഗ്ഷൻ() (റിട്ടേൺ ലോക്കൽ വേരിയബിൾ; ); ) var wrap1 = wrapValue(1); var wrap2 = wrapValue(2); console.log(wrap1()); // → 1 console.log(wrap2()); //→ 2

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

ഒരു ലോക്കൽ വേരിയബിളിന്റെ ഒരു ഉദാഹരണം ഉപയോഗിച്ച് പ്രവർത്തിക്കാനുള്ള ഈ കഴിവിനെ ഒരു ക്ലോഷർ എന്ന് വിളിക്കുന്നു. ലോക്കൽ വേരിയബിളുകൾ അടയ്ക്കുന്ന ഒരു ഫംഗ്ഷനെ ക്ലോഷർ എന്ന് വിളിക്കുന്നു. വേരിയബിൾ ലൈഫ്ടൈമുകളെക്കുറിച്ചുള്ള ആകുലതകളിൽ നിന്ന് ഇത് നിങ്ങളെ മോചിപ്പിക്കുക മാത്രമല്ല, ഫംഗ്ഷനുകൾ ക്രിയാത്മകമായി ഉപയോഗിക്കാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഒരു ചെറിയ പരിഷ്‌ക്കരണത്തോടെ, നൽകിയിരിക്കുന്ന ഏതെങ്കിലും സംഖ്യകൊണ്ട് സംഖ്യകളെ ഗുണിക്കുന്ന ഒരു ഫംഗ്‌ഷനാക്കി ഞങ്ങൾ ഉദാഹരണം മാറ്റുന്നു.

ഫംഗ്ഷൻ മൾട്ടിപ്ലയർ(ഘടകം) (റിട്ടേൺ ഫംഗ്‌ഷൻ(നമ്പർ) (റിട്ടേൺ നമ്പർ * ഫാക്ടർ;); ) var double = മൾട്ടിപ്ലയർ(2); console.log(രണ്ടുതവണ(5)); //→ 10

wrapValue ഉദാഹരണത്തിൽ നിന്ന് ലോക്കൽ വേരിയബിൾ പോലെയുള്ള ഒരു പ്രത്യേക വേരിയബിൾ ഇനി ആവശ്യമില്ല. പരാമീറ്റർ തന്നെ ഒരു ലോക്കൽ വേരിയബിൾ ആയതിനാൽ.

ഇങ്ങനെ ചിന്തിച്ചു തുടങ്ങാൻ പരിശീലിക്കേണ്ടിവരും. ഒരു ഫംഗ്‌ഷൻ അതിന്റെ ശരീരത്തിലെ കോഡിനെ മരവിപ്പിച്ച് ഒരു പാക്കേജിൽ പൊതിയുന്നു എന്ന് സങ്കൽപ്പിക്കുക എന്നതാണ് നല്ല മാനസിക മാതൃക. നിങ്ങൾ റിട്ടേൺ ഫംഗ്‌ഷൻ (...) (...) കാണുമ്പോൾ, പിന്നീടുള്ള ഉപയോഗത്തിനായി ഫ്രീസുചെയ്‌ത ഒരു കോഡിന്റെ ഒരു നിയന്ത്രണ പാനലായി ഇത് കരുതുക.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, മൾട്ടിപ്ലയർ ഒരു ഫ്രീസുചെയ്ത കോഡ് തിരികെ നൽകുന്നു, അത് ഞങ്ങൾ ഇരട്ടി വേരിയബിളിൽ സംഭരിക്കുന്നു. അവസാന വരി വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന ഫംഗ്‌ഷനെ വിളിക്കുന്നു, ഇത് സംഭരിച്ച കോഡ് സജീവമാക്കുന്നതിന് കാരണമാകുന്നു (റിട്ടേൺ നമ്പർ * ഘടകം;). മൾട്ടിപ്ലയർ വിളിക്കുമ്പോൾ നിർവചിച്ചിട്ടുള്ള ഫാക്ടർ വേരിയബിളിലേക്ക് ഇതിന് ഇപ്പോഴും ആക്‌സസ് ഉണ്ട്, കൂടാതെ ഡിഫ്രോസ്റ്റ് (5) സമയത്ത് ഒരു ന്യൂമറിക് പാരാമീറ്ററായി പാസ്സാക്കിയ ആർഗ്യുമെന്റിലേക്കും ഇതിന് ആക്‌സസ് ഉണ്ട്.

സ്റ്റാക്ക് കവിഞ്ഞൊഴുകാതിരിക്കാൻ ശ്രദ്ധിക്കുന്നിടത്തോളം, റിക്കർഷൻ എ ഫംഗ്‌ഷൻ സ്വയം വിളിച്ചേക്കാം. ഈ ഫംഗ്‌ഷനെ റികർസീവ് എന്ന് വിളിക്കുന്നു. എക്‌സ്‌പോണൻഷ്യേഷന്റെ ഇതര നടപ്പാക്കലിന്റെ ഒരു ഉദാഹരണം ഇതാ:

ഫംഗ്‌ഷൻ പവർ(ബേസ്, എക്‌സ്‌പോണന്റ്) (എക്‌സ്‌പോണന്റ് == 0) റിട്ടേൺ 1; അല്ലെങ്കിൽ റിട്ടേൺ ബേസ് * പവർ (ബേസ്, എക്‌സ്‌പോണന്റ് - 1); ) console.log(power(2, 3)); //→ 8

ഗണിതശാസ്ത്രജ്ഞർ എക്‌സ്‌പോണൻഷ്യേഷനെ ഏകദേശം ഇങ്ങനെയാണ് നിർവചിക്കുന്നത്, ഒരുപക്ഷേ ഇത് ഒരു സൈക്കിളിനേക്കാൾ മനോഹരമായി ഈ ആശയത്തെ വിവരിക്കുന്നു. ഒന്നിലധികം ഗുണനങ്ങൾ നേടുന്നതിന് ഫംഗ്ഷൻ പലതവണ വ്യത്യസ്ത ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് സ്വയം വിളിക്കുന്നു.

എന്നിരുന്നാലും, ഈ നടപ്പാക്കലിന് ഒരു പ്രശ്നമുണ്ട് - ഒരു സാധാരണ JavaScript പരിതസ്ഥിതിയിൽ ഇത് ഒരു ലൂപ്പുള്ള പതിപ്പിനേക്കാൾ 10 മടങ്ങ് വേഗത കുറവാണ്. ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നതിനേക്കാൾ വിലകുറഞ്ഞതാണ് ഒരു ലൂപ്പിലൂടെ നടക്കുന്നത്.

സ്പീഡ് വേഴ്സസ് എലഗൻസ് ഡിലമ വളരെ രസകരമാണ്. മനുഷ്യർക്കുള്ള സൗകര്യവും യന്ത്രങ്ങളുടെ സൗകര്യവും തമ്മിൽ ഒരു നിശ്ചിത അന്തരമുണ്ട്. ഏത് പ്രോഗ്രാമും വലുതും കൂടുതൽ സങ്കീർണ്ണവുമാക്കി വേഗത്തിലാക്കാം. പ്രോഗ്രാമർ ഉചിതമായ ബാലൻസ് കണ്ടെത്തേണ്ടതുണ്ട്.

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

ഒന്നിലധികം തവണ ആവർത്തിച്ചിട്ടുള്ളതും ഞാൻ പൂർണ്ണമായും സമ്മതിക്കുന്നതുമായ അടിസ്ഥാന നിയമം, പ്രോഗ്രാം മന്ദഗതിയിലാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പാകുന്നതുവരെ പ്രകടനത്തെക്കുറിച്ച് വിഷമിക്കേണ്ടതില്ല എന്നതാണ്. അങ്ങനെയാണെങ്കിൽ, ഏറ്റവും ദൈർഘ്യമേറിയ ഭാഗങ്ങൾ കണ്ടെത്തി അവിടെ കാര്യക്ഷമതയ്ക്കായി ചാരുത കണ്ടെത്തുക.

തീർച്ചയായും, ഞങ്ങൾ ഉടൻ തന്നെ പ്രകടനത്തെ പൂർണ്ണമായും അവഗണിക്കരുത്. പല സന്ദർഭങ്ങളിലും, എക്സ്പോണൻഷ്യേഷൻ പോലെ, ഗംഭീരമായ പരിഹാരങ്ങളിൽ നിന്ന് നമുക്ക് വളരെ ലാളിത്യം ലഭിക്കുന്നില്ല. ലളിതമായ സമീപനം ഒരിക്കലും വേണ്ടത്ര വേഗതയുള്ളതല്ലെന്ന് ചിലപ്പോൾ പരിചയസമ്പന്നനായ ഒരു പ്രോഗ്രാമർക്ക് പെട്ടെന്ന് കാണാൻ കഴിയും.

ഞാൻ ഇത് ചൂണ്ടിക്കാണിക്കുന്നത് കാരണം നിരവധി പുതിയ പ്രോഗ്രാമർമാർ ചെറിയ കാര്യങ്ങളിൽ പോലും കാര്യക്ഷമതയിൽ ശ്രദ്ധാലുക്കളാണ്. ഫലം വലുതും കൂടുതൽ സങ്കീർണ്ണവും പലപ്പോഴും പിശകുകളില്ലാത്തതുമാണ്. അത്തരം പ്രോഗ്രാമുകൾ എഴുതാൻ കൂടുതൽ സമയമെടുക്കും, പക്ഷേ അവ പലപ്പോഴും കൂടുതൽ വേഗത്തിൽ പ്രവർത്തിക്കില്ല.

എന്നാൽ ആവർത്തനം എല്ലായ്പ്പോഴും ലൂപ്പുകൾക്കുള്ള കാര്യക്ഷമത കുറഞ്ഞ ബദൽ മാത്രമല്ല. ചില പ്രശ്നങ്ങൾ ആവർത്തനത്തിലൂടെ പരിഹരിക്കാൻ എളുപ്പമാണ്. മിക്കപ്പോഴും ഇത് ഒരു മരത്തിന്റെ നിരവധി ശാഖകളുടെ ഒരു യാത്രയാണ്, അവയിൽ ഓരോന്നിനും ശാഖകൾ ഉണ്ടാകാം.

ഇതാ ഒരു കടങ്കഥ: സംഖ്യ 1-ൽ തുടങ്ങി, 5 കൂട്ടിയോ 3 കൊണ്ട് ഗുണിച്ചോ നിങ്ങൾക്ക് അനന്തമായ സംഖ്യകൾ ലഭിക്കും. ഒരു സംഖ്യ നൽകിയാൽ, കൂട്ടിച്ചേർക്കലുകളുടെയും ഗുണനങ്ങളുടെയും ക്രമം കണ്ടെത്താൻ ശ്രമിക്കുന്ന ഒരു ഫംഗ്ഷൻ എങ്ങനെ എഴുതാം. അത് ഒരു നിശ്ചിത സംഖ്യയിലേക്ക് നയിക്കുമോ? ഉദാഹരണത്തിന്, ആദ്യം 1-നെ 3 കൊണ്ട് ഗുണിച്ചാൽ 5-നെ രണ്ടുതവണ കൂട്ടിയാൽ 13 എന്ന സംഖ്യ ലഭിക്കും. 15 എന്ന സംഖ്യ ഈ രീതിയിൽ ലഭിക്കില്ല.

ആവർത്തന പരിഹാരം:

ഫംഗ്‌ഷൻ ഫൈൻഡ്‌സൊല്യൂഷൻ(ടാർഗെറ്റ്) ( ഫംഗ്‌ഷൻ കണ്ടെത്തൽ (ആരംഭിക്കുക, ചരിത്രം) ( (ആരംഭിക്കുക == ടാർഗെറ്റ്) ചരിത്രം തിരികെ നൽകുക; അല്ലെങ്കിൽ (ആരംഭിക്കുക > ടാർഗെറ്റ്) അസാധുവായി നൽകുക; അല്ലെങ്കിൽ കണ്ടെത്തുക (ആരംഭം + 5, "(" + ചരിത്രം + " +" 5)") || കണ്ടെത്തുക(ആരംഭിക്കുക * 3, "(" + ചരിത്രം + " * 3)"); ) റിട്ടേൺ ഫൈൻഡ്(1, "1"); ) console.log(findSolution(24)); // → (((1 * 3) + 5) * 3)

ഈ ഉദാഹരണം ഏറ്റവും ചെറിയ പരിഹാരം കണ്ടെത്തണമെന്നില്ല - അത് ഏതെങ്കിലുമൊരു സംതൃപ്‌തമാണ്. പ്രോഗ്രാം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾ പെട്ടെന്ന് മനസ്സിലാക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നില്ല. എന്നാൽ ആവർത്തന ചിന്തയിലെ ഈ മഹത്തായ വ്യായാമം നമുക്ക് മനസ്സിലാക്കാം.

ആന്തരിക ഫംഗ്‌ഷൻ കണ്ടെത്തൽ ആവർത്തനം ചെയ്യുന്നു. ഇതിന് രണ്ട് ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ് - നിലവിലെ നമ്പറും ഞങ്ങൾ ഈ നമ്പറിൽ എങ്ങനെ എത്തി എന്നതിന്റെ റെക്കോർഡ് അടങ്ങുന്ന ഒരു സ്ട്രിംഗും. അത് ഒന്നുകിൽ ഞങ്ങളുടെ ഘട്ടങ്ങളുടെ ക്രമം കാണിക്കുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു, അല്ലെങ്കിൽ ശൂന്യമാണ്.

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

ഫംഗ്‌ഷൻ അതിന്റെ ആവശ്യമുള്ള പ്രഭാവം എങ്ങനെ കൈവരിക്കുന്നുവെന്ന് നന്നായി മനസിലാക്കാൻ, 13 എന്ന നമ്പറിന് ഒരു പരിഹാരം കണ്ടെത്താൻ അത് ചെയ്യുന്ന കോളുകൾ നോക്കാം.

കണ്ടെത്തുക(1, "1") കണ്ടെത്തുക(6, "(1 + 5)") കണ്ടെത്തുക(11, "((1 + 5) + 5)") കണ്ടെത്തുക(16, "((1 + 5) + 5 ) + 5)") വളരെ വലിയ കണ്ടെത്തൽ(33, "(((1 + 5) + 5) * 3)") വളരെ വലിയ കണ്ടെത്തൽ(18, "((1 + 5) * 3)") വളരെ വലിയ കണ്ടെത്തൽ( 3, "(1 * 3)") കണ്ടെത്തുക(8, "((1 * 3) + 5)") കണ്ടെത്തുക(13, "(((1 * 3) + 5) + 5)") കണ്ടെത്തി!

ഇൻഡന്റേഷൻ കോൾ സ്റ്റാക്കിന്റെ ആഴം കാണിക്കുന്നു. ആദ്യമായി, (1 + 5), (1 * 3) എന്നിവയിൽ ആരംഭിക്കുന്ന പരിഹാരങ്ങൾ പരിശോധിക്കാൻ ഫൈൻഡ് ഫംഗ്ഷൻ സ്വയം രണ്ട് തവണ വിളിക്കുന്നു. ആദ്യ കോൾ (1 + 5) എന്നതിൽ ആരംഭിക്കുന്ന ഒരു പരിഹാരത്തിനായി തിരയുകയും ആവശ്യമായ സംഖ്യയേക്കാൾ കുറവോ തുല്യമോ ആയ സംഖ്യ ഉൽപ്പാദിപ്പിക്കുന്ന എല്ലാ പരിഹാരങ്ങളും പരിശോധിക്കാൻ ആവർത്തനം ഉപയോഗിക്കുന്നു. അത് കണ്ടെത്താനായില്ല, അസാധുവായി തിരികെ നൽകുന്നു. അപ്പോൾ ഓപ്പറേറ്റർ || കൂടാതെ (1 * 3) ഓപ്ഷൻ പരിശോധിക്കുന്ന ഒരു ഫംഗ്ഷൻ കോളിലേക്ക് നീങ്ങുന്നു. ഞങ്ങൾ ഇവിടെ ഭാഗ്യവാന്മാരാണ്, കാരണം മൂന്നാമത്തെ ആവർത്തന കോളിൽ നമുക്ക് 13 ലഭിക്കുന്നു. ഈ കോൾ ഒരു സ്ട്രിംഗ് നൽകുന്നു, കൂടാതെ ഓരോന്നിനും || വഴിയിൽ, അത് ഈ ലൈൻ ഉയരത്തിൽ കടന്നുപോകുന്നു, അതിന്റെ ഫലമായി ഒരു പരിഹാരം ലഭിക്കും.

ഗ്രോയിംഗ് ഫംഗ്‌ഷനുകൾ ഒരു പ്രോഗ്രാമിലേക്ക് ഫംഗ്‌ഷനുകൾ അവതരിപ്പിക്കുന്നതിന് രണ്ടോ അതിലധികമോ സ്വാഭാവിക വഴികളുണ്ട്.

ആദ്യത്തേത് നിങ്ങൾ സമാനമായ കോഡ് നിരവധി തവണ എഴുതുന്നു എന്നതാണ്. ഇത് ഒഴിവാക്കണം - കൂടുതൽ കോഡ് അർത്ഥമാക്കുന്നത് പിശകുകൾക്കുള്ള കൂടുതൽ ഇടവും പ്രോഗ്രാം മനസ്സിലാക്കാൻ ശ്രമിക്കുന്നവർക്ക് കൂടുതൽ വായനാ സാമഗ്രികളും എന്നാണ്. അതിനാൽ ഞങ്ങൾ ഒരു ആവർത്തന പ്രവർത്തനം എടുക്കുകയും അതിന് നല്ല പേര് നൽകുകയും ഒരു ഫംഗ്ഷനിൽ ഇടുകയും ചെയ്യുന്നു.

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

ഒരു ഫംഗ്‌ഷന്റെ പേര് നൽകുന്നത് എത്ര ബുദ്ധിമുട്ടാണ് എന്നത് അതിന്റെ പ്രവർത്തനക്ഷമത നിങ്ങൾ എത്ര നന്നായി മനസ്സിലാക്കുന്നു എന്ന് കാണിക്കുന്നു. നമുക്ക് ഒരു ഉദാഹരണം എടുക്കാം. ഫാമിലെ പശുക്കളുടേയും കോഴികളുടേയും എണ്ണം, പശുക്കൾ, കോഴികൾ എന്നിങ്ങനെ രണ്ട് അക്കങ്ങൾ പ്രിന്റ് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഞങ്ങൾ എഴുതേണ്ടതുണ്ട്. മുന്നിലുള്ള അക്കങ്ങളിൽ പൂജ്യങ്ങൾ ചേർക്കേണ്ടതുണ്ട്, അങ്ങനെ ഓരോന്നും കൃത്യമായി മൂന്ന് സ്ഥാനങ്ങൾ ഉൾക്കൊള്ളുന്നു.

007 പശുക്കൾ 011 കോഴികൾ

വ്യക്തമായും, നമുക്ക് രണ്ട് ആർഗ്യുമെന്റുകളുള്ള ഒരു ഫംഗ്ഷൻ ആവശ്യമാണ്. നമുക്ക് കോഡിംഗ് ആരംഭിക്കാം.
// പ്രിന്റ് ഫാംഇൻവെന്ററി ഫംഗ്‌ഷൻ പ്രിന്റ്ഫാംഇൻവെന്ററി (പശുക്കൾ, കോഴികൾ) ( var cowString = സ്ട്രിംഗ് (പശുക്കൾ); അതേസമയം (cowString.length< 3) cowString = "0" + cowString; console.log(cowString + " Коров"); var chickenString = String(chickens); while (chickenString.length < 3) chickenString = "0" + chickenString; console.log(chickenString + " Куриц"); } printFarmInventory(7, 11);

ഒരു സ്ട്രിംഗിൽ .length ചേർത്താൽ നമുക്ക് അതിന്റെ നീളം ലഭിക്കും. 3 പ്രതീകങ്ങളുടെ ഒരു വരി ലഭിക്കുന്നതുവരെ, ലൂപ്പുകൾ അക്കങ്ങളിലേക്ക് ലീഡിംഗ് പൂജ്യങ്ങൾ ചേർക്കുന്നുവെന്ന് ഇത് മാറുന്നു.

തയ്യാറാണ്! എന്നാൽ ഞങ്ങൾ കർഷകന് കോഡ് അയയ്‌ക്കാൻ പോകുമ്പോൾ (തീർച്ചയായും ഒരു കനത്ത പരിശോധനയ്‌ക്കൊപ്പം), അവൻ വിളിച്ച് തന്റെ ഫാമിൽ പന്നികളുണ്ടെന്ന് ഞങ്ങളോട് പറയുന്നു, കൂടാതെ നമുക്ക് പന്നികളുടെ എണ്ണത്തിന്റെ ഒരു ഡിസ്‌പ്ലേ ചേർക്കാമോ? പ്രോഗ്രാം?

തീർച്ചയായും അത് സാധ്യമാണ്. എന്നാൽ ഈ നാല് വരികളിൽ നിന്ന് കോഡ് പകർത്തി ഒട്ടിക്കാൻ തുടങ്ങുമ്പോൾ, നമ്മൾ നിർത്തുകയും ചിന്തിക്കുകയും ചെയ്യണമെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു. ഇതിലും നല്ല വഴിയുണ്ടാകണം. ഞങ്ങൾ പ്രോഗ്രാം മെച്ചപ്പെടുത്താൻ ശ്രമിക്കുന്നു:

// ഔട്ട്‌പുട്ട് പൂജ്യങ്ങളും ലേബലുകളും ഫംഗ്‌ഷൻ പ്രിന്റ്‌സീറോപാഡഡ്‌വിത്ത്‌ലേബൽ(നമ്പർ, ലേബൽ) (var numberString = String(നമ്പർ); അതേസമയം (numberString.length< 3) numberString = "0" + numberString; console.log(numberString + " " + label); } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { printZeroPaddedWithLabel(cows, "Коров"); printZeroPaddedWithLabel(chickens, "Куриц"); printZeroPaddedWithLabel(pigs, "Свиней"); } printFarmInventory(7, 11, 3);

പ്രവർത്തിക്കുന്നു! എന്നാൽ printZeroPaddedWithLabel എന്ന പേര് അൽപ്പം വിചിത്രമാണ്. ഇത് മൂന്ന് കാര്യങ്ങൾ സംയോജിപ്പിക്കുന്നു - ഔട്ട്പുട്ട്, പൂജ്യങ്ങൾ ചേർക്കൽ, ഒരു ലേബൽ - ഒരു ഫംഗ്ഷനിലേക്ക്. ഒരു ഫംഗ്ഷനിലേക്ക് ആവർത്തിച്ചുള്ള മുഴുവൻ ശകലവും ചേർക്കുന്നതിനുപകരം, നമുക്ക് ഒരു ആശയം ഹൈലൈറ്റ് ചെയ്യാം:

// സീറോ ഫംഗ്‌ഷൻ zeroPad (നമ്പർ, വീതി) ചേർക്കുക ( var string = String(number); while (string.length< width) string = "0" + string; return string; } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { console.log(zeroPad(cows, 3) + " Коров"); console.log(zeroPad(chickens, 3) + " Куриц"); console.log(zeroPad(pigs, 3) + " Свиней"); } printFarmInventory(7, 16, 3);

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

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

ഉപയോഗപ്രദമാകുമെന്ന് നിങ്ങൾക്കറിയാവുന്ന പ്രവർത്തനം മാത്രം ചേർക്കുക എന്നതാണ് ഒരു നല്ല നിയമം. ഓരോ ചെറിയ ആവശ്യത്തിനും പൊതുവായ-ഉദ്ദേശ്യ ചട്ടക്കൂടുകൾ സൃഷ്ടിക്കാൻ ചിലപ്പോൾ അത് പ്രലോഭിപ്പിക്കുന്നു. അവനെ ചെറുക്കുക. നിങ്ങൾ ഒരിക്കലും ജോലി പൂർത്തിയാക്കില്ല, ആരും ഉപയോഗിക്കാത്ത ഒരു കൂട്ടം കോഡ് എഴുതുന്നത് നിങ്ങൾ അവസാനിപ്പിക്കും.

ഫംഗ്ഷനുകളും പാർശ്വഫലങ്ങളും പ്രവർത്തനങ്ങളെ അവയുടെ പാർശ്വഫലങ്ങൾക്കായി വിളിക്കപ്പെടുന്നവയും ചില മൂല്യങ്ങൾ ലഭിക്കാൻ വിളിക്കപ്പെടുന്നവയുമായി ഏകദേശം വിഭജിക്കാം. തീർച്ചയായും, ഈ ഗുണങ്ങളെ ഒരു ഫംഗ്ഷനിൽ സംയോജിപ്പിക്കാനും കഴിയും.

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

ഒരു പ്യുവർ ഫംഗ്‌ഷൻ എന്നത് ഒരു പ്രത്യേക തരം മൂല്യ-റിട്ടേണിംഗ് ഫംഗ്‌ഷനാണ്, അത് പാർശ്വഫലങ്ങളൊന്നുമില്ലെന്ന് മാത്രമല്ല, ബാക്കിയുള്ള കോഡിന്റെ പാർശ്വഫലങ്ങളെ ആശ്രയിക്കുന്നില്ല - ഉദാഹരണത്തിന്, ആകസ്മികമായി സംഭവിക്കാവുന്ന ആഗോള വേരിയബിളുകളിൽ ഇത് പ്രവർത്തിക്കില്ല. മറ്റെവിടെയോ മാറ്റി. ഒരു ശുദ്ധമായ ഫംഗ്‌ഷൻ, ഒരേ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ, അതേ ഫലം നൽകുന്നു (മറ്റൊന്നും ചെയ്യുന്നില്ല) - ഇത് വളരെ നല്ലതാണ്. അവൾക്കൊപ്പം പ്രവർത്തിക്കാൻ എളുപ്പമാണ്. അത്തരമൊരു ഫംഗ്ഷനിലേക്കുള്ള ഒരു കോൾ കോഡിന്റെ അർത്ഥം മാറ്റാതെ തന്നെ അതിന്റെ പ്രവർത്തനത്തിന്റെ ഫലമായി മാനസികമായി മാറ്റിസ്ഥാപിക്കാം. നിങ്ങൾക്ക് അത്തരമൊരു ഫംഗ്ഷൻ പരീക്ഷിക്കാൻ താൽപ്പര്യപ്പെടുമ്പോൾ, നിങ്ങൾക്ക് അതിനെ വിളിക്കാം, കൂടാതെ ഇത് ഒരു പ്രത്യേക സന്ദർഭത്തിൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, അത് ഏത് സന്ദർഭത്തിലും പ്രവർത്തിക്കുമെന്ന് ഉറപ്പാക്കുക. കുറച്ച് ശുദ്ധമായ ഫംഗ്‌ഷനുകൾ പല ഘടകങ്ങളെ ആശ്രയിച്ച് വ്യത്യസ്‌ത ഫലങ്ങൾ നൽകിയേക്കാം, കൂടാതെ പരിശോധിക്കാനും കണക്കാക്കാനും ബുദ്ധിമുട്ടുള്ള പാർശ്വഫലങ്ങൾ ഉണ്ടാകാം.

എന്നിരുന്നാലും, പൂർണ്ണമായും ശുദ്ധമല്ലാത്ത ഫംഗ്‌ഷനുകൾ എഴുതുന്നതിനോ അത്തരം ഫംഗ്‌ഷനുകളുടെ ഒരു വിശുദ്ധ കോഡ് ശുദ്ധീകരിക്കുന്നതിനോ നിങ്ങൾ ലജ്ജിക്കേണ്ടതില്ല. പാർശ്വഫലങ്ങൾ പലപ്പോഴും ഗുണം ചെയ്യും. Console.log ഫംഗ്‌ഷന്റെ ക്ലീൻ പതിപ്പ് എഴുതാൻ ഒരു മാർഗവുമില്ല, ഈ ഫംഗ്‌ഷൻ വളരെ ഉപയോഗപ്രദമാണ്. ചില പ്രവർത്തനങ്ങൾ പാർശ്വഫലങ്ങൾ ഉപയോഗിച്ച് പ്രകടിപ്പിക്കാൻ എളുപ്പമാണ്.

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

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

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

ExercisesMinimum മുമ്പത്തെ അധ്യായത്തിൽ, Math.min ഫംഗ്‌ഷൻ ഞങ്ങൾ പരാമർശിച്ചു, അത് അതിന്റെ ഏറ്റവും ചെറിയ ആർഗ്യുമെന്റുകൾ നൽകുന്നു. ഇപ്പോൾ നമുക്ക് അത്തരമൊരു ഫംഗ്ഷൻ സ്വയം എഴുതാം. രണ്ട് ആർഗ്യുമെന്റുകൾ എടുക്കുകയും അവയിൽ ഏറ്റവും കുറഞ്ഞത് നൽകുകയും ചെയ്യുന്ന ഒരു മിനിറ്റ് ഫംഗ്ഷൻ എഴുതുക.

Console.log(മിനിറ്റ്(0, 10)); // → 0 console.log(മിനിറ്റ്(0, -10)); // → -10

ആവർത്തനം ഒരു സംഖ്യ (%2) തുല്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ % (മോഡ്യൂളോ) ഓപ്പറേറ്റർ ഉപയോഗിക്കാമെന്ന് ഞങ്ങൾ കണ്ടു. ഇത് നിർവചിക്കുന്നതിനുള്ള മറ്റൊരു മാർഗം ഇതാ:

പൂജ്യം തുല്യമാണ്.
യൂണിറ്റ് വിചിത്രമാണ്.
ഏത് സംഖ്യയും N നും N-2 ന്റെ സമാന തുല്യതയുണ്ട്.

ഈ നിയമങ്ങൾക്കനുസൃതമായി ഒരു ആവർത്തന പ്രവർത്തനം എഴുതുക. ഇത് ഒരു സംഖ്യ സ്വീകരിക്കുകയും ഒരു ബൂളിയൻ മൂല്യം നൽകുകയും വേണം.

ഇത് 50-ലും 75-ലും പരീക്ഷിക്കുക. -1 നൽകാൻ ശ്രമിക്കുക. എന്തുകൊണ്ടാണ് അവൾ ഇങ്ങനെ പെരുമാറുന്നത്? എങ്ങനെയെങ്കിലും ശരിയാക്കാൻ കഴിയുമോ?

50-ലും 75-ലും ഇത് പരീക്ഷിക്കുക. -1-ൽ ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണുക. എന്തുകൊണ്ട്? ഇത് പരിഹരിക്കാനുള്ള ഒരു വഴി നിങ്ങൾക്ക് ആലോചിക്കാമോ?

Console.log(isEven(50)); // → true console.log(isEven(75)); // → false console.log(isEven(-1)); // → ??

ബീൻസ് എണ്ണുന്നു.

ഒരു സ്‌ട്രിംഗിന്റെ N എന്ന പ്രതീക നമ്പർ .charAt(N) (“string”.charAt(5)) ചേർത്തുകൊണ്ട് ലഭിക്കും - .length ഉപയോഗിച്ച് ഒരു സ്‌ട്രിംഗിന്റെ നീളം നേടുന്നതിന് സമാനമായി. റിട്ടേൺ മൂല്യം ഒരു പ്രതീകം അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് ആയിരിക്കും (ഉദാഹരണത്തിന്, "k"). ഒരു സ്ട്രിംഗിന്റെ ആദ്യ പ്രതീകത്തിന് സ്ഥാനം 0 ഉണ്ട്, അതായത് അവസാന പ്രതീകത്തിന് സ്ഥാനം string.length - 1. മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, രണ്ട് പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗിന് നീളം 2 ഉണ്ട്, അതിന്റെ പ്രതീക സ്ഥാനങ്ങൾ 0 ഉം 1 ഉം ആയിരിക്കും.

ഒരു സ്ട്രിംഗ് ഒരു ആർഗ്യുമെന്റായി എടുക്കുകയും സ്‌ട്രിംഗിൽ അടങ്ങിയിരിക്കുന്ന "B" പ്രതീകങ്ങളുടെ എണ്ണം നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ കൗണ്ട്ബികൾ എഴുതുക.

തുടർന്ന് കൗണ്ട്‌ചാർ എന്ന ഫംഗ്‌ഷൻ എഴുതുക, അത് കൗണ്ട്‌ബികൾ പോലെ പ്രവർത്തിക്കുന്നു, എന്നാൽ രണ്ടാമത്തെ പാരാമീറ്റർ എടുക്കുന്നു - സ്‌ട്രിംഗിൽ നമ്മൾ തിരയുന്ന പ്രതീകം ("ബി" പ്രതീകങ്ങളുടെ എണ്ണം കണക്കാക്കുന്നതിന് പകരം). ഇത് ചെയ്യുന്നതിന്, countBs ഫംഗ്ഷൻ വീണ്ടും വർക്ക് ചെയ്യുക.

JavaScript-ലെ കോഡിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട നിർമ്മാണ ബ്ലോക്കുകളിൽ ഒന്നാണ് ഫംഗ്ഷനുകൾ.

ഫംഗ്‌ഷനുകളിൽ ഒരു കൂട്ടം കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു, സാധാരണയായി ഒരു നിർദ്ദിഷ്ട ചുമതല നിർവഹിക്കുന്നു (ഉദാഹരണത്തിന്, സംഖ്യകൾ സംഗ്രഹിക്കുക, വേരുകൾ കണക്കാക്കൽ മുതലായവ).

ഒരു ഫംഗ്‌ഷനിൽ സ്ഥാപിച്ചിരിക്കുന്ന കോഡ് ഈ ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു വ്യക്തമായ കോളിന് ശേഷം മാത്രമേ എക്‌സിക്യൂട്ട് ചെയ്യുകയുള്ളൂ.

പ്രവർത്തന പ്രഖ്യാപനം

1. വാക്യഘടന:

//ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ നാമത്തിന്റെ പ്രഖ്യാപനം(ln1, ln2)( ഫംഗ്‌ഷൻ കോഡ്) //ഫംഗ്‌ഷൻ ഫംഗ്‌ഷന്റെ പേര് (ln1,lr2);

2. വാക്യഘടന:

//ഫംഗ്‌ഷൻ var ഫംഗ്‌ഷന്റെ പേര്=ഫംഗ്‌ഷൻ(ln1, ln2)(ഫംഗ്‌ഷൻ കോഡ്) //ഫംഗ്‌ഷൻ ഫംഗ്‌ഷന്റെ പേര് (ln1,lr2) വിളിക്കുന്നു;

functionname ഫംഗ്ഷന്റെ പേര് വ്യക്തമാക്കുന്നു. പേജിലെ ഓരോ ഫംഗ്ഷനും ഒരു അദ്വിതീയ നാമം ഉണ്ടായിരിക്കണം. ഫംഗ്‌ഷൻ നാമം ലാറ്റിൻ അക്ഷരങ്ങളിൽ വ്യക്തമാക്കിയിരിക്കണം കൂടാതെ അക്കങ്ങളിൽ ആരംഭിക്കരുത്.

ln1, ln2 എന്നിവ ഫംഗ്ഷനിലേക്ക് കൈമാറാൻ കഴിയുന്ന വേരിയബിളുകൾ അല്ലെങ്കിൽ മൂല്യങ്ങളാണ്. ഓരോ ഫംഗ്ഷനിലേക്കും പരിധിയില്ലാത്ത വേരിയബിളുകൾ കൈമാറാൻ കഴിയും.

ദയവായി ശ്രദ്ധിക്കുക: ഫംഗ്‌ഷനിലേക്ക് വേരിയബിളുകളൊന്നും കൈമാറിയില്ലെങ്കിലും, ഫംഗ്‌ഷന്റെ പേരിന് ശേഷം "()" പരാൻതീസിസ് ചേർക്കാൻ മറക്കരുത്.

JavaScript-ലെ ഫംഗ്‌ഷൻ പേരുകൾ കേസ് സെൻസിറ്റീവ് ആണെന്നത് ശ്രദ്ധിക്കുക.

ഉദാഹരണം JavaScript ഫംഗ്ഷൻ

ചുവടെയുള്ള ഉദാഹരണത്തിലെ മെസ്സേജ് റൈറ്റ്() ഫംഗ്‌ഷൻ ബട്ടൺ ക്ലിക്കുചെയ്‌തതിനുശേഷം മാത്രമേ എക്‌സിക്യൂട്ട് ചെയ്യുകയുള്ളൂ.

ഈ ഉദാഹരണം ഓൺക്ലിക്ക് ഇവന്റ് ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. ജാവാസ്ക്രിപ്റ്റ് ഇവന്റുകൾ പിന്നീട് ഈ ട്യൂട്ടോറിയലിൽ വിശദമായി ഉൾപ്പെടുത്തും.

// ഫംഗ്‌ഷൻ പേജ് ഫംഗ്‌ഷനിലേക്ക് ടെക്‌സ്‌റ്റ് എഴുതുന്നു മെസേജ്Write() (document.write("ഈ വാചകം JavaScript ഉപയോഗിച്ചാണ് പേജിലേക്ക് എഴുതിയത്!"); )

ഫംഗ്ഷനുകളിലേക്ക് വേരിയബിളുകൾ കൈമാറുന്നു

നിങ്ങൾക്ക് ഫംഗ്ഷനുകളിലേക്ക് പരിധിയില്ലാത്ത വേരിയബിളുകൾ കൈമാറാൻ കഴിയും.

ദയവായി ശ്രദ്ധിക്കുക: ഫംഗ്ഷനുകൾക്കുള്ളിലെ വേരിയബിളുകളുള്ള എല്ലാ കൃത്രിമത്വങ്ങളും യഥാർത്ഥത്തിൽ നടപ്പിലാക്കുന്നത് വേരിയബിളുകളിലല്ല, മറിച്ച് അവയുടെ പകർപ്പിലാണ്, അതിനാൽ ഫംഗ്ഷനുകൾ നടപ്പിലാക്കുന്നതിന്റെ ഫലമായി വേരിയബിളുകളുടെ ഉള്ളടക്കം തന്നെ മാറില്ല.

/* പാസ്സായ വേരിയബിളിലേക്ക് 10 ചേർക്കുകയും ഫലം */ ഫംഗ്‌ഷൻ പ്ലസ്(എ)( a=a+10; document.write("ഫംഗ്ഷൻ ഔട്ട്‌പുട്ട്: " + a+") എന്ന പേജിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ നമുക്ക് നിർവചിക്കാം.
"); ) var a=25; document.write("ഫംഗ്‌ഷൻ കോളിന് മുമ്പുള്ള വേരിയബിളിന്റെ മൂല്യം: "+a+"
"); // വേരിയബിൾ a പ്ലസ്(a) പാസ്സാക്കി ഫംഗ്‌ഷനെ വിളിക്കുക; document.write("ഫംഗ്‌ഷനെ വിളിച്ചതിന് ശേഷം വേരിയബിളിന്റെ മൂല്യം: "+a+"
");

പെട്ടെന്നുള്ള കാഴ്ച

ഒരു ഫംഗ്‌ഷന്റെ പകർപ്പിന് പകരം ഒരു ഗ്ലോബൽ വേരിയബിൾ ആക്‌സസ് ചെയ്യുന്നതിന്, window.variable_name ഉപയോഗിക്കുക.

ഫംഗ്ഷൻ പ്ലസ്(എ)( window.a=a+10; ) var a=25; document.write("ഫംഗ്‌ഷൻ കോളിന് മുമ്പുള്ള വേരിയബിളിന്റെ മൂല്യം: "+a+"
"); പ്ലസ്(a); document.write("ഫംഗ്‌ഷൻ വിളിച്ചതിന് ശേഷം വേരിയബിളിന്റെ മൂല്യം: "+a+"
");

പെട്ടെന്നുള്ള കാഴ്ച

റിട്ടേൺ കമാൻഡ്

റിട്ടേൺ കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഫംഗ്ഷനുകളിൽ നിന്ന് മൂല്യങ്ങൾ തിരികെ നൽകാം.

//സം ഫംഗ്‌ഷൻ അതിലേക്ക് കൈമാറിയ വേരിയബിളുകളുടെ ആകെത്തുക ഫംഗ്‌ഷൻ സം(v1,v2)(റിട്ടേൺ v1+v2; ) document.write("5+6=" + sum(5,6) + "
"); document.write("10+4=" + sum(10,4) + "
");

പെട്ടെന്നുള്ള കാഴ്ച

അന്തർനിർമ്മിത പ്രവർത്തനങ്ങൾ

ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്ഷനുകൾക്ക് പുറമേ, JavaScript-ഉം ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ഉണ്ട്.

ഉദാഹരണത്തിന്, പാസായ മൂല്യം സാധുവായ സംഖ്യയാണോ എന്ന് പരിശോധിക്കാൻ ബിൽറ്റ്-ഇൻ isFinite ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു.

Document.write(isFinite(40)+"
"); document.write(isFinite(-590)+"
"); document.write(isFinite(90.33)+"
"); document.write(isFinite(NaN)+"
"); document.write(isFinite("ഇതൊരു സ്ട്രിംഗ് ആണ്")+"
");

പെട്ടെന്നുള്ള കാഴ്ച

ദയവായി ശ്രദ്ധിക്കുക: ബിൽറ്റ്-ഇൻ JavaScript ഫംഗ്‌ഷനുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് നിങ്ങൾക്ക് ഞങ്ങളുടെ ൽ കണ്ടെത്താനാകും.

പ്രാദേശികവും ആഗോളവുമായ വേരിയബിളുകൾ

ഫംഗ്ഷനുകൾക്കുള്ളിൽ സൃഷ്ടിക്കുന്ന വേരിയബിളുകളെ ലോക്കൽ വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു. അത്തരം വേരിയബിളുകൾ നിർവചിച്ചിരിക്കുന്ന ഫംഗ്ഷനുകൾക്കുള്ളിൽ മാത്രമേ നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയൂ.

ഫംഗ്‌ഷൻ കോഡ് എക്‌സിക്യൂഷൻ പൂർത്തിയാക്കിയ ശേഷം, അത്തരം വേരിയബിളുകൾ നശിപ്പിക്കപ്പെടും. ഒരേ പേരിലുള്ള വേരിയബിളുകൾ വ്യത്യസ്ത ഫംഗ്ഷനുകളിൽ നിർവചിക്കാമെന്നാണ് ഇതിനർത്ഥം.

ഫംഗ്‌ഷൻ കോഡിന് പുറത്ത് സൃഷ്‌ടിക്കുന്ന വേരിയബിളുകളെ ആഗോള വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു; അത്തരം വേരിയബിളുകൾ കോഡിൽ എവിടെ നിന്നും ആക്‌സസ് ചെയ്യാൻ കഴിയും.

നിങ്ങൾ ഒരു ഫംഗ്ഷനിൽ var ഇല്ലാതെ ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുകയാണെങ്കിൽ, അതും ആഗോളമായി മാറുന്നു.

പേജ് അടച്ചതിനുശേഷം മാത്രമേ ഗ്ലോബൽ വേരിയബിളുകൾ നശിപ്പിക്കപ്പെടുകയുള്ളൂ.

//ആഗോള വേരിയബിളുകൾ var1, var2 var var1 = "var1 നിലവിലുണ്ട്"; var var2; ഫംഗ്‌ഷൻ func1() ( //func1 var var2 = "var2 നിലവിലുണ്ട്" എന്ന ഫംഗ്‌ഷന്റെ ഉള്ളിൽ var2 ഒരു മൂല്യം നൽകുക; ) //മറ്റൊരു ഫംഗ്‌ഷനിൽ നിന്ന്, var1, var2 എന്നീ വേരിയബിളിന്റെ ഉള്ളടക്കങ്ങൾ പേജ് ഫംഗ്‌ഷനിലേക്ക് func2() പ്രിന്റ് ചെയ്യുക ( //Print var1 document.write (var1 + " എന്ന വേരിയബിളിന്റെ ഉള്ളടക്കം
"); //വേരിയബിളിന്റെ ഉള്ളടക്കം var2 document.write(var2); )

പെട്ടെന്നുള്ള കാഴ്ച

സ്‌ക്രീനിൽ പ്രിന്റ് ചെയ്യുമ്പോൾ, var2 ന് ഒരു ശൂന്യമായ മൂല്യം ഉണ്ടായിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക, കാരണം func1 var2 ന്റെ പ്രാദേശിക "പതിപ്പിൽ" പ്രവർത്തിക്കുന്നു.

അജ്ഞാത പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു

പ്രഖ്യാപിക്കുമ്പോൾ പേരില്ലാത്ത ഫംഗ്‌ഷനുകളെ അജ്ഞാതമെന്ന് വിളിക്കുന്നു.

അജ്ഞാത ഫംഗ്‌ഷനുകൾ അടിസ്ഥാനപരമായി സാധാരണ ഫംഗ്‌ഷനുകൾ പോലെയുള്ള കോഡിൽ നിന്ന് വിളിക്കപ്പെടുന്നതല്ല, മറിച്ച് ഒരു പാരാമീറ്ററായി മറ്റ് ഫംഗ്‌ഷനുകളിലേക്ക് കൈമാറാൻ പ്രഖ്യാപിക്കപ്പെടുന്നു.

ഫംഗ്ഷൻ arrMap(arr,func)( var res=പുതിയ അറേ; (var i=0;i