ലേഖനം വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്നു!

ഒരു ഫംഗ്ഷൻ എന്താണെന്നും അതോടൊപ്പം പ്രവർത്തിക്കുന്നതിൻ്റെ പരമ്പരാഗത (ക്ലാസിക്) പതിപ്പും ഞങ്ങൾ പരിഗണിക്കുന്ന ഒരു ലേഖനം. കൂടാതെ, ഫംഗ്ഷൻ്റെയും റിട്ടേൺ ഓപ്പറേറ്ററുടെയും ആർഗ്യുമെൻ്റുകൾ (പാരാമീറ്ററുകൾ) എന്താണെന്ന് ഞങ്ങൾ വിശകലനം ചെയ്യും.

ഒരു ഫംഗ്ഷൻ എന്താണ്?

പ്രോഗ്രാമിൽ എവിടെനിന്നും ഒരു പേര് നൽകാനും ആ പേരിൽ ആക്സസ് ചെയ്യാനും കഴിയുന്ന നിർദ്ദേശങ്ങളുടെ ഒരു കൂട്ടമാണ് ഫംഗ്ഷൻ.

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

ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് JavaScript-ൽ ചില ടാസ്‌ക്കുകളുടെ നിർവ്വഹണം എങ്ങനെ സംഘടിപ്പിക്കാം? ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ സാധാരണയായി ഇത് ചെയ്യുക:

• ചുമതല അതിൻ്റെ ഘടക ഭാഗങ്ങളായി (ഉപടാസ്കുകൾ) വിഭജിക്കുക;
• ഉപടാസ്കുകൾ ഫംഗ്ഷനുകളിലൂടെ ഔപചാരികമാക്കുന്നു;
• സൃഷ്ടിച്ച ഫംഗ്ഷനുകളിലേക്കുള്ള കോളുകൾ ഉപയോഗിച്ച് പ്രധാന കോഡ് വികസിപ്പിക്കുക.

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

ഒരു ചടങ്ങ് പ്രഖ്യാപിക്കുകയും വിളിക്കുകയും ചെയ്യുന്നു

JavaScript-ൽ ഒരു ഫംഗ്ഷനുള്ള പ്രവർത്തനങ്ങളെ 2 ഘട്ടങ്ങളായി തിരിക്കാം:

• ഒരു പ്രവർത്തനത്തിൻ്റെ പ്രഖ്യാപനം (സൃഷ്ടി).
• ഈ ഫംഗ്‌ഷൻ വിളിക്കുക (നിർവ്വഹിക്കുക).

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

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ someName ഫംഗ്‌ഷൻ someName() (അലേർട്ട്("നിങ്ങൾ ഫംഗ്‌ഷൻ ചിലതിൻ്റെ പേര് എന്ന് വിളിച്ചു!"); ) JavaScript - ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ വാക്യഘടന

ജാവാസ്ക്രിപ്റ്റിലെ ഇത്തരത്തിലുള്ള ഫംഗ്‌ഷനുകളെ ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ സ്റ്റേറ്റ്‌മെൻ്റുകൾ എന്ന് വിളിക്കുന്നു. ഈ തരത്തിന് പുറമേ, ഫംഗ്‌ഷൻ ഡെഫനിഷൻ എക്‌സ്‌പ്രഷനും ആരോ ഫംഗ്‌ഷൻ എക്‌സ്‌പ്രഷൻ ഫംഗ്‌ഷനുകളും തമ്മിൽ JavaScript വേർതിരിക്കുന്നു.

വേരിയബിൾ നാമത്തിൻ്റെ അതേ നിയമങ്ങൾക്കനുസൃതമായാണ് ഫംഗ്ഷൻ നാമം നിർമ്മിച്ചിരിക്കുന്നത്. ആ. അതിൽ അക്ഷരങ്ങൾ, അക്കങ്ങൾ (0-9), "$", "_" എന്നീ ചിഹ്നങ്ങൾ അടങ്ങിയിരിക്കാം. ഇംഗ്ലീഷ് അക്ഷരമാലയിലെ (a-z, A-Z) അക്ഷരങ്ങൾ മാത്രം അക്ഷരങ്ങളായി ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. ഒരു വേരിയബിളിൻ്റെ പേര് പോലെ ഒരു ഫംഗ്ഷൻ്റെ പേരും ഒരു സംഖ്യയിൽ ആരംഭിക്കാൻ കഴിയില്ല.

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

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

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

// മുമ്പത്തെ ഉദാഹരണത്തിൽ നൽകിയ ഫംഗ്‌ഷനെ വിളിക്കുക someName(); JavaScript - ഫംഗ്ഷൻ കോൾ സിൻ്റാക്സ്

JavaScript-ൽ ഒരു ഫംഗ്‌ഷൻ ഒരു വസ്തുവാണോ?

ജാവാസ്ക്രിപ്റ്റിലെ പ്രവർത്തനങ്ങൾ ഒബ്ജക്റ്റുകളാണ്. ജാവാസ്ക്രിപ്റ്റിൽ, ആറ് ഒഴികെ എല്ലാം ഒരു വസ്തുവാണ് പ്രാകൃത തരങ്ങൾഡാറ്റ. ഫംഗ്‌ഷൻ ഒരു ഒബ്‌ജക്‌റ്റ് ആണെങ്കിൽ, അതിനുള്ള ഒരു റഫറൻസ് ഒരു വേരിയബിളിൽ സൂക്ഷിക്കാം.

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ someName function someName() (അലേർട്ട്("നിങ്ങൾ ചില പേര് ഫംഗ്‌ഷൻ എന്ന് വിളിച്ചു!"); ) var റഫറൻസ് = someName;

ഇതിനുശേഷം, നിങ്ങൾക്ക് ഫംഗ്‌ഷനെ ഇതുപോലെ വിളിക്കാം:

റഫറൻസ്();

ഫംഗ്ഷൻ പാരാമീറ്ററുകളും ആർഗ്യുമെൻ്റുകളും

ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റുകൾ എന്നത് ഒരു ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ അതിലേക്ക് കൈമാറുന്ന മൂല്യങ്ങളാണ്. കോമ ഉപയോഗിച്ച് ആർഗ്യുമെൻ്റുകൾ പരസ്പരം വേർതിരിക്കുന്നു.

// sayWelcome ഫംഗ്‌ഷനെ വിളിക്കുക, അതിലേക്ക് രണ്ട് ആർഗ്യുമെൻ്റുകൾ നൽകി വെൽകം("ഇവാൻ", "ഇവാനോവ്"); // സേ വെൽകം ഫംഗ്‌ഷനിലേക്കുള്ള മറ്റൊരു കോൾ, വെൽകം ("പെറ്റ്ർ", "പെട്രോവ്");

ഒരു ഫംഗ്‌ഷനിൽ ആർഗ്യുമെൻ്റുകൾ ആക്‌സസ് ചെയ്യാൻ കഴിയുന്ന JavaScript-ലെ ഒരു മാർഗമാണ് ഫംഗ്‌ഷൻ പാരാമീറ്ററുകൾ. ഫംഗ്ഷൻ്റെ പ്രഖ്യാപനത്തിൻ്റെ ഘട്ടത്തിലെ പരാമീറ്ററുകൾ പരാൻതീസിസിൽ വിവരിച്ചിരിക്കുന്നു.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഫംഗ്ഷൻ സമാരംഭിക്കുമ്പോൾ യാന്ത്രികമായി സൃഷ്ടിക്കപ്പെടുന്ന ലോക്കൽ വേരിയബിളുകളാണ് ഫംഗ്ഷൻ പാരാമീറ്ററുകൾ. പാരാമീറ്ററുകൾ അതിൻ്റെ കോൾ സമയത്ത് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്ന അനുബന്ധ ആർഗ്യുമെൻ്റുകൾ മൂല്യങ്ങളായി സ്വീകരിക്കുന്നു. ഈ ഫംഗ്ഷനിൽ മാത്രമേ നിങ്ങൾക്ക് പാരാമീറ്ററുകൾ ആക്സസ് ചെയ്യാൻ കഴിയൂ; അതിന് പുറത്ത് അവ നിലവിലില്ല.

// ഒരു ഫംഗ്‌ഷൻ്റെ പ്രഖ്യാപനം sayWelcome, അതിൽ രണ്ട് പാരാമീറ്ററുകൾ ഉണ്ട് വെൽകം (userFirstName, userLastName) ( // “userFirstName”, “userLastName” എന്നീ പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ കൺസോൾ കൺസോളിലേക്ക് പ്രദർശിപ്പിക്കുന്ന ഒരു നിർദ്ദേശം.log,("Welcome " + userLastName + " " + userFirstName );)

JavaScript-ൽ, ഒരു ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ, ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം പാരാമീറ്ററുകളുടെ എണ്ണത്തിന് തുല്യമായിരിക്കണമെന്നില്ല. വിളിക്കുമ്പോൾ മൂല്യത്തിലേക്ക് സജ്ജീകരിക്കാത്ത പാരാമീറ്ററുകൾ നിർവചിക്കാത്തതിന് തുല്യമായിരിക്കും.

ഉദാഹരണത്തിന്, ഒന്നോ രണ്ടോ പാരാമീറ്ററുകൾ വ്യക്തമാക്കാതെ, മുകളിലുള്ള ഉദാഹരണത്തിൽ നിന്ന് ഫംഗ്ഷനെ വിളിക്കാം:

// sayWelcome ഫംഗ്‌ഷനെ വിളിക്കുകയും അതിലേക്ക് ഒരു ആർഗ്യുമെൻ്റ് കൈമാറുകയും ചെയ്യുന്നു sayWelcome("പീറ്റർ"); // സ്വാഗതം, നിർവചിക്കാത്ത പീറ്റർ // വാദങ്ങളൊന്നും നൽകാതെ സേ വെൽകം ഫംഗ്‌ഷനെ വിളിക്കുന്നു sayWelcome(); // സ്വാഗതം, നിർവചിക്കാത്ത നിർവചിക്കപ്പെട്ടിട്ടില്ല

ബ്രൗസർ കൺസോളിലേക്ക് അയച്ച ആർഗ്യുമെൻ്റുകൾ ലളിതമായി ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ്റെ ഉദാഹരണം:

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ ഫംഗ്‌ഷൻ ഔട്ട്‌പുട്ട്‌പാരം(പരം1, പാരം2, പാരം3) (കൺസോൾ.ലോഗ്(പരം1 + "; " + പാരം2 + "; " + പാരം3); ) // ഔട്ട്‌പുട്ട്പാരം അത് കടന്നുപോകുന്ന ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുന്നു വ്യത്യസ്ത അളവുകൾപരാമീറ്ററുകൾ ഔട്ട്പുട്ട്പാരം("മഴ","മഞ്ഞ്","മൂടൽമഞ്ഞ്"); // മഴ; മഞ്ഞ്; മൂടൽമഞ്ഞ് ഔട്ട്പുട്ട്പാരം(17); // 17; നിർവചിക്കാത്തത്; നിർവചിക്കാത്ത ഔട്ട്പുട്ട്പാരം(24,33); // 24; 33; നിർവചിക്കാത്ത outputParam(); // നിർവചിക്കാത്തത്; നിർവചിക്കാത്തത്; നിർവചിക്കാത്തത്

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

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ തുക ഫംഗ്‌ഷൻ തുക(സംഖ്യ1, സംഖ്യ2) ( /* സംഖ്യ1 അല്ലെങ്കിൽ ആർഗ്യുമെൻ്റുകൾ - ആർഗ്യുമെൻ്റ് 1 നം2 അല്ലെങ്കിൽ ആർഗ്യുമെൻ്റുകളുടെ മൂല്യം നേടുക - ആർഗ്യുമെൻ്റിൻ്റെ മൂല്യം നേടുക 2 */ var sum1 = num1 + num2, തുക2 = ആർഗ്യുമെൻ്റുകൾ + ആർഗ്യുമെൻ്റുകൾ; റിട്ടേൺ "ഒന്നാം രീതിയിലൂടെ ലഭിച്ച തുക, " + സം1 + " എന്നതിന് തുല്യമാണ്; രണ്ടാമത്തെ രീതിയിലൂടെ ലഭിച്ച തുക " + സം2 ആണ്; ) /* സം ഫംഗ്‌ഷൻ്റെ ഫലം കൺസോൾ 7-ലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യുക - ആദ്യ ആർഗ്യുമെൻ്റ് (ഇത് num1 എന്ന പേരിലോ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ചോ ആക്‌സസ് ചെയ്യാൻ കഴിയും) 4 - രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് (ഇത് num2 എന്ന പേരിലോ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ചോ ആക്‌സസ് ചെയ്യാം) */ console.log(sum(7,4));

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

ആർഗ്യുമെൻ്റുകൾ സ്വീകരിക്കുന്നതിനു പുറമേ, ആർഗ്യുമെൻ്റ് ഒബ്ജക്റ്റ് അവയുടെ നമ്പർ അറിയാനും നിങ്ങളെ അനുവദിക്കുന്നു. ദൈർഘ്യമുള്ള പ്രോപ്പർട്ടി ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്.

ഫംഗ്‌ഷനിലേക്ക് കൈമാറിയ ആർഗ്യുമെൻ്റുകൾ നിങ്ങൾക്ക് ആവർത്തിക്കാം, ഉദാഹരണത്തിന്, ഉപയോഗിച്ച് ലൂപ്പിനായിഅല്ലെങ്കിൽ .

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ സം ഫംഗ്‌ഷൻ സം() ( var i = 0; console.log("ഒരു ഫോർ ലൂപ്പ് ഉപയോഗിച്ച് എല്ലാ ആർഗ്യുമെൻ്റുകളും ഔട്ട്‌പുട്ട് ചെയ്യുക"); (i; i< arguments.length; i++) { console.log(i + 1 + " аргумент равен " + arguments[i]); } console.log("Вывод всех аргументов с помощью цикла for...of"); for (arg of arguments) { console.log(arg); } } // вызов функции sum sum(7, 4, 3, 1);

കൺസോളിലേക്ക് അയച്ച എല്ലാ ആർഗ്യുമെൻ്റുകളും അവയുടെ നമ്പറും പ്രദർശിപ്പിക്കുന്ന ഒരു ഫംഗ്ഷൻ:

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ ഫംഗ്‌ഷൻ myFunction () ( var i; console.log("പാസാക്കിയ പാരാമീറ്ററുകളുടെ എണ്ണം = " + arguments.length); // (i = 0; i എന്നതിനായുള്ള ലൂപ്പ് ഉപയോഗിച്ച് എല്ലാ പാരാമീറ്ററുകളും നോക്കാം< arguments.length; i++) { console.log(i + " параметр = " + arguments[i]); } } // вызовы функции myFunction myFunction(3, 7, 27, "JavaScript"); myFunction(); myFunction("Яблоки", "Груши", "Апельсины");

അതിലേക്ക് കൈമാറിയ എല്ലാ ആർഗ്യുമെൻ്റുകളുടെയും കൂട്ടിച്ചേർക്കൽ നിർവ്വഹിക്കുന്ന ഒരു ഫംഗ്ഷൻ (അവയുടെ നമ്പർ മുൻകൂട്ടി അറിയില്ല):

// ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ var myCalc = ഫംഗ്‌ഷൻ() ( // for loop var i ഉപയോഗിച്ച് എല്ലാ പാരാമീറ്ററുകളിലൂടെയും പോകാം, sum = 0; (i = 0; i lt; arguments.length; i++) ( sum += ആർഗ്യുമെൻ്റുകൾ [i] ; ) // ഫലമായി തുക തിരികെ നൽകുക;

തൽഫലമായി, ആർഗ്യുമെൻ്റ് ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഫംഗ്ഷൻ ബോഡിയിൽ ഇനിപ്പറയുന്നവ നടപ്പിലാക്കാൻ കഴിയും:

• പാസായ ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം പരിശോധിക്കുന്നു;
• എത്ര പാരാമീറ്ററുകൾ വേണമെങ്കിലും പ്രോസസ്സ് ചെയ്യുന്നു.

ഫംഗ്‌ഷനുപുറമെ, അതിൽ സ്ഥിതിചെയ്യുന്ന മറ്റ് ഫംഗ്‌ഷനുകൾക്കും കോൾ ഘട്ടത്തിൽ കൈമാറുന്ന ആർഗ്യുമെൻ്റുകളിലേക്ക് ആക്‌സസ് ഉണ്ട്.

ഫംഗ്ഷൻ mainF(p1, p2) (ഫംഗ്ഷൻ ChildF() (console.log("p1 = " + p1 + "; p2 = " + p2); ) childF(); ) mainF(3, 5); // p1 = 3; p2 = 5 mainF(4, 7); // p1 = 4; p2 = 7

സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ

ECMAScript 2015 (6) മുതൽ, ഒരു ഫംഗ്ഷൻ പാരാമീറ്റർ അതിൻ്റെ സ്ഥിര മൂല്യത്തിലേക്ക് സജ്ജമാക്കാൻ കഴിയും.

ഉദാഹരണത്തിന്, "#009688" എന്നതിന് തുല്യമായ "നിറം" പാരാമീറ്റർ അതിൻ്റെ സ്ഥിര മൂല്യത്തിലേക്ക് സജ്ജമാക്കാം:

ഫംഗ്ഷൻ setBGColor(നിറം = "#009688") (document.body.style.backgroundColor = color; ) setBGColor(); // പശ്ചാത്തല നിറം #009688 setBGColor ("ചുവപ്പ്") ആയിരിക്കും; // പശ്ചാത്തല നിറം ചുവപ്പായിരിക്കും

ECMAScript 2015-ന് മുമ്പ്, നിങ്ങൾക്ക് പാരാമീറ്റർ അതിൻ്റെ സ്ഥിര മൂല്യത്തിലേക്ക് സജ്ജീകരിക്കാം, ഉദാഹരണത്തിന്, ഇതുപോലെ:

ഫംഗ്‌ഷൻ setBGColor(നിറം) ( നിറം = നിറം !== നിർവചിക്കപ്പെടാത്തത് ? നിറം: "#009688"; // "#009688" ൻ്റെ സ്ഥിര മൂല്യത്തിലേക്ക് നിറം സജ്ജമാക്കുക document.body.style.backgroundColor = color; )

ശേഷിക്കുന്ന പാരാമീറ്ററുകൾ

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

// ...സംഖ്യകൾ - ബാക്കിയുള്ള പരാമീറ്ററുകൾ, ഈ സാഹചര്യത്തിൽ nums ഫംഗ്ഷൻ doMath (mathAction, ...nums) എന്ന പേരിൽ ആക്സസ് ചെയ്യാൻ കഴിയും ( var ഫലം = 0; nums.forEach (function (value) ( ​​സ്വിച്ച് ( mathAction) (കേസ് "സം": ഫലം += മൂല്യം; ബ്രേക്ക്; കേസ് "സംക്യൂബ്": ഫലം += മൂല്യം**3; ബ്രേക്ക്; കേസ് "സംസ്‌ക്വയർ": ഫലം += മൂല്യം**2; ബ്രേക്ക്; ഡിഫോൾട്ട്: ഫലം = 0 ; ) ) ) ഫലം നൽകുന്നു; ) console.log(doMath("സം", 3, 4, 21, -4)); // 24 (3 + 4 + 21 + (-4)) console.log(doMath("sumSquare", 1, 4)); // 17 (1^2 + 4^2) console.log(doMath("sumCube", 3, 2, 4)); // 99 (3^3 + 2^3 + 4^3)

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

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

റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റ് ഉപയോഗിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്നത് പരിഗണിക്കാതെ തന്നെ JavaScript-ലെ ഒരു ഫംഗ്‌ഷൻ എല്ലായ്പ്പോഴും ഒരു ഫലം നൽകുന്നു.

// ഫല ഫംഗ്‌ഷൻ sayWelcome (userFirstName, userLastName) ((!userFirstName) അജ്ഞാത ഉപയോക്താവ്"; അല്ലാത്തപക്ഷം "സ്വാഗതം, " + userLastName + " " + userFirstName; ) // വേരിയബിൾ വ്യക്തിയെ പ്രഖ്യാപിക്കുക var വ്യക്തി; ); ; // ഫംഗ്‌ഷൻ്റെ ഫലം കൺസോളിലേക്ക് പ്രിൻറ് ചെയ്യുന്ന നിർദ്ദേശം sayWelcome console.log(sayWelcome("Sidorov")); JavaScript - പരാമീറ്റർ പരിശോധിക്കുന്ന ഫംഗ്‌ഷൻ

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

// 1. ഫല ഫംഗ്‌ഷനുകളൊന്നും നൽകാത്ത ഫംഗ്‌ഷൻ sayWelcome (userFirstName, userLastName) ( console.log("സ്വാഗതം, " + userLastName + " " + userFirstName); ) // ഒരു ഫംഗ്‌ഷനിൽ നിന്ന് ഫലം ലഭിക്കാൻ ശ്രമിക്കാം ഒന്നും തിരികെ നൽകില്ല കൺസോൾ .ലോഗ്(sayWelcome("ഇവാൻ", "ഇവാനോവ്")); // 2. വാല്യൂ ഫംഗ്‌ഷൻ sayDay (day) ഇല്ലാത്ത ഒരു റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റ് അടങ്ങിയ ഫംഗ്‌ഷൻ (ദിവസം = "ഇന്ന്," + ദിവസം; റിട്ടേൺ; //ഈ നിർദ്ദേശം നടപ്പിലാക്കില്ല, കാരണം ഇത് റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റിന് ശേഷം വരുന്നതാണ് console.log(day) ; ) // മൂല്യം കൺസോൾ ഇല്ലാതെ റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റ് അടങ്ങിയ ഒരു ഫംഗ്‌ഷനിൽ നിന്ന് ഫലം നേടാൻ ശ്രമിക്കാം.log(sayDay("ഫെബ്രുവരി 21, 2016")); JavaScript - ഒന്നും നൽകാത്ത ഒരു ഫംഗ്ഷനിൽ നിന്ന് മൂല്യം നേടുക

റിട്ടേൺ സ്റ്റേറ്റ്‌മെൻ്റ് ഒരു റിട്ടേൺ മൂല്യം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ അതേ ഫലം ലഭിക്കും.

JavaScript-ൽ ഓവർലോഡിംഗ് പ്രവർത്തനം

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

JavaScript ഭാഷ നടപ്പിലാക്കിയിരിക്കുന്ന അതേ രീതിയിൽ ഫംഗ്‌ഷൻ ഓവർലോഡിംഗിനെ പിന്തുണയ്ക്കുന്നില്ല, ഉദാഹരണത്തിന്, C-പോലുള്ള ഭാഷകളിൽ. ആ. JavaScript-ൽ, ഒരേ സ്കോപ്പിലുള്ള ഒരേ പേരുകളുള്ള ഒന്നിലധികം ഫംഗ്ഷനുകൾ നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയില്ല.

ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ ഉപയോഗിച്ച് ജാവാസ്ക്രിപ്റ്റിൽ സമാനമായ പ്രവർത്തനം നടപ്പിലാക്കാൻ കഴിയും:

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

ഉദാഹരണത്തിന്, ഒന്നോ രണ്ടോ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് വിളിക്കാവുന്ന ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കാം:

//നിറം മാറ്റുന്ന ഒരു ഫംഗ്‌ഷൻ്റെ പ്രഖ്യാപനം പശ്ചാത്തലംഎലമെൻ്റുകളുടെ ഫംഗ്‌ഷൻ setBgColor(bgColor,elements) ( //കോൾ ചെയ്യുമ്പോൾ എലമെൻ്റുകളുടെ പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ (മൂലകങ്ങൾ=== നിർവചിച്ചിട്ടില്ല) ( //പിന്നെ അതിൻ്റെ മൂല്യം "div" ഘടകങ്ങൾ = "div" എന്ന് സജ്ജമാക്കുക; ) //എല്ലാം നേടുക മൂലക ഘടകങ്ങൾ = $(ഘടകങ്ങൾ); //എല്ലാ ഘടകങ്ങളിലൂടെയും ആവർത്തിച്ച് അവയെ നിർദ്ദിഷ്ട പശ്ചാത്തല വർണ്ണ ഘടകങ്ങളിലേക്ക് സജ്ജമാക്കുക.each(function())( $(this).css("background-color",bgColor); ); ) /*ഒരു പാരാമീറ്റർ വ്യക്തമാക്കി setBgColor ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുക. കാരണം 2 പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടില്ല, തുടർന്ന് ഈ ഫംഗ്‌ഷൻ എല്ലാ ഡിവി എലമെൻ്റുകളുടെയും പശ്ചാത്തല നിറം മാറ്റും.*/ setBgColor("പച്ച"); /*2 പാരാമീറ്ററുകൾ വ്യക്തമാക്കി setBgColor ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുക. കാരണം 2 പാരാമീറ്റർ വ്യക്തമാക്കിയിരിക്കുന്നു, തുടർന്ന് ഈ പ്രവർത്തനംബട്ടൺ ഘടകങ്ങളുടെ പശ്ചാത്തല നിറം മാത്രം മാറ്റും.*/ setBgColor("#ff0000","ബട്ടൺ");

മുകളിലെ കോഡിൽ ചില മാറ്റങ്ങൾ വരുത്താം. അതായത്, രണ്ടാമത്തെ പാരാമീറ്ററിനായി ഞങ്ങൾ സ്ഥിരസ്ഥിതി മൂല്യം വ്യക്തമാക്കുന്നു:

//ഘടകങ്ങളുടെ പശ്ചാത്തല നിറം മാറ്റുന്ന ഒരു ഫംഗ്‌ഷൻ്റെ പ്രഖ്യാപനം //മൂലകങ്ങളുടെ പാരാമീറ്ററിന് ഡിഫോൾട്ട് ഫംഗ്‌ഷൻ സെറ്റ്BgColor(bgColor,elements = "div") എന്ന മൂല്യം "div" ഉണ്ട് ( //എല്ലാ ഘടകങ്ങളുടെയും ഘടകങ്ങൾ നേടുക = $(ഘടകങ്ങൾ); //എല്ലാ ഘടകങ്ങളും ആവർത്തിച്ച് നിർദ്ദിഷ്ട പശ്ചാത്തല വർണ്ണ ഘടകങ്ങളിലേക്ക് സജ്ജമാക്കുക.each(function())( $(this).css("background-color",bgColor); )); //setBgColor ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുക, വ്യക്തമാക്കുക ഒരു പാരാമീറ്റർ setBgColor("പച്ച" ); //setBgColor ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുക, 2 പാരാമീറ്ററുകൾ setBgColor ("#ff0000","ബട്ടൺ") വ്യക്തമാക്കുന്നു;

ഒരു വ്യക്തിക്ക് പ്രതിദിനം ആവശ്യമായ കലോറികളുടെ എണ്ണം കണക്കാക്കുന്ന "ഓവർലോഡഡ്" ഫംഗ്‌ഷൻ JavaScript-ൽ നിങ്ങൾക്ക് എങ്ങനെ നടപ്പിലാക്കാം എന്നതിൻ്റെ ഒരു ഉദാഹരണം:

// ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ്റെ വിവരണം countCal(ലിംഗം, ഉയരം) ( // പരാമീറ്ററുകൾ: ലിംഗം (ലിംഗം), ഉയരം (ഉയരം) var ഫലം; എങ്കിൽ ((ലിംഗം === 0) || (ലിംഗം === "പുരുഷൻ") ) (ഫലം = (ഉയരം - 100) * 20; ) അല്ലെങ്കിൽ ((സെക്സ് === 1) || (സെക്സ് === "സ്ത്രീ")) (ഫലം = (ഉയരം - 105) * 19; ) എങ്കിൽ (ഫലം ) ( // ആർഗ്യുമെൻ്റുകൾ - പ്രവർത്തന നില എങ്കിൽ (ആർഗ്യുമെൻ്റുകൾ) (ഫലം *= ആർഗ്യുമെൻ്റുകൾ; ) console.log("സാധാരണ ജീവിതത്തിനായുള്ള kcal-ൻ്റെ അളവ്: " + ഫലം); ) else ( console.log("അസാധുവായ പാരാമീറ്ററുകൾ"); ) ) / * ഒരു ഫംഗ്‌ഷൻ വിളിച്ച് അതിലേക്ക് 2 ആർഗ്യുമെൻ്റുകൾ കൈമാറുന്നു (1 - "മാൻ", ഇത് സെക്‌സ്, ആർഗ്യുമെൻ്റുകൾ എന്ന പേര് ഉപയോഗിച്ച് ആക്‌സസ് ചെയ്യാൻ കഴിയും; 2 - മൂല്യം 185, സെക്‌സ്, ആർഗ്യുമെൻ്റുകൾ എന്ന പേര് ഉപയോഗിച്ച് ഇത് ആക്‌സസ് ചെയ്യാൻ കഴിയും) */ countCal ("മനുഷ്യൻ", 185); /* ഒരു ഫംഗ്‌ഷൻ വിളിക്കുകയും അതിലേക്ക് 3 പാരാമീറ്ററുകൾ കൈമാറുകയും ചെയ്യുന്നു, എന്നിരുന്നാലും ഫംഗ്‌ഷൻ വിവരണത്തിൽ 2 മാത്രമേ ഉള്ളൂ (ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് മൂന്നാം പാരാമീറ്ററിൻ്റെ മൂല്യം ആർഗ്യുമെൻ്റുകളായി മാത്രമേ ലഭിക്കൂ) */ countCal(0, 185, 2);

ആവർത്തനം

ആവർത്തനം എന്നത് ശരീരത്തിനുള്ളിൽ തന്നെ ചില പ്രവർത്തനങ്ങളുടെ ഒരു കോളാണ്.

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

ഫംഗ്ഷൻ വസ്തുത (n) ( എങ്കിൽ (n === 1) (റിട്ടേൺ 1; ) വസ്തുത (n-1) * n; ) console.log(fact(5)); // 120

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

ബിൽറ്റ്-ഇൻ (സ്റ്റാൻഡേർഡ്) ഫംഗ്ഷനുകൾ എന്തൊക്കെയാണ്?

JavaScript-ന് ബിൽറ്റ്-ഇൻ (സ്റ്റാൻഡേർഡ്) ഫംഗ്‌ഷനുകളുടെ ഒരു വലിയ കൂട്ടം ഉണ്ട്. ഈ പ്രവർത്തനങ്ങൾ ഇതിനകം തന്നെ ബ്രൗസർ എഞ്ചിനിൽ വിവരിച്ചിട്ടുണ്ട്. മിക്കവാറും എല്ലാം ഒരു വസ്തുവിൻ്റെ അല്ലെങ്കിൽ മറ്റൊന്നിൻ്റെ രീതികളാണ്.

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

// അലേർട്ട് ഫംഗ്‌ഷൻ അലേർട്ടിലേക്ക് വിളിക്കുന്നു ("ചില വാചകം"); JavaScript - അലേർട്ട് ഫംഗ്‌ഷനെ വിളിക്കുന്നു

മെയ് 24, 2011 01:13 ഒരു ഫംഗ്‌ഷൻ വിളിക്കാനുള്ള അഞ്ച് വഴികൾ

• ജാവാസ്ക്രിപ്റ്റ്

• വിവർത്തനം

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

ആദ്യ ഘട്ടങ്ങളിൽ ജാവാസ്ക്രിപ്റ്റ് പഠിക്കുന്നുതുടക്കക്കാർ സാധാരണയായി വിചാരിക്കുന്നത് അതിൻ്റെ പ്രവർത്തനങ്ങൾ സി# പോലെ തന്നെ പ്രവർത്തിക്കുമെന്നാണ്. എന്നാൽ JavaScript-ൽ ഫംഗ്‌ഷനുകൾ വിളിക്കുന്നതിനുള്ള സംവിധാനങ്ങൾക്ക് നിരവധിയുണ്ട് പ്രധാനപ്പെട്ട വ്യത്യാസങ്ങൾ, അവയെക്കുറിച്ചുള്ള അജ്ഞത കണ്ടെത്തുന്നത് എളുപ്പമല്ലാത്ത പിശകുകളിലേക്ക് നയിച്ചേക്കാം.

നമുക്ക് എഴുതാം ലളിതമായ പ്രവർത്തനം, ഇത് മൂന്ന് ഘടകങ്ങളുടെ ഒരു ശ്രേണി നൽകുന്നു - ഈ മൂല്യവും ഫംഗ്‌ഷനിലേക്ക് കൈമാറിയ രണ്ട് ആർഗ്യുമെൻ്റുകളും.
ഫംഗ്‌ഷൻ makeArray(arg1, arg2)( മടങ്ങുക [ഇത്, arg1, arg2 ]; )

ഏറ്റവും സാധാരണമായ മാർഗ്ഗം: മുകളിലെ ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ആഗോള കോൾ തുടക്കക്കാർ പലപ്പോഴും ഫംഗ്ഷനുകൾ പ്രഖ്യാപിക്കുന്നു. ഈ ഫംഗ്‌ഷൻ വിളിക്കുന്നത് എളുപ്പമാണ്:
makeArray("ഒന്ന്", "രണ്ട്"); // => [ജാലകം, "ഒന്ന്", "രണ്ട്" ]
കാത്തിരിക്കൂ. വിൻഡോ ഒബ്‌ജക്റ്റ് എവിടെ നിന്ന് വരുന്നു? എന്തുകൊണ്ട് ഇത് വിൻഡോയ്ക്ക് തുല്യമാണ്?

JavaScript-ൽ, ബ്രൗസറിലോ മറ്റൊരു പരിതസ്ഥിതിയിലോ സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂട്ട് ചെയ്‌താലും, അത് എല്ലായ്‌പ്പോഴും നിർവചിക്കപ്പെടുന്നു ആഗോള വസ്തു. നമ്മുടെ സ്‌ക്രിപ്റ്റിലെ ഏതൊരു കോഡും "ബന്ധിതമല്ലാത്ത" ഒന്നിലും (അതായത്, ഒബ്‌ജക്റ്റ് ഡിക്ലറേഷന് പുറത്ത്) യഥാർത്ഥത്തിൽ ആഗോള വസ്തുവിൻ്റെ പശ്ചാത്തലത്തിലാണ്. ഞങ്ങളുടെ കാര്യത്തിൽ, makeArray എന്നത് സ്വന്തമായി ഒരു "നടത്തം" മാത്രമല്ല. വാസ്തവത്തിൽ, makeArray എന്നത് ഗ്ലോബൽ ഒബ്ജക്റ്റിൻ്റെ ഒരു രീതിയാണ് (ബ്രൗസറിലെ കോഡ് എക്സിക്യൂഷൻ്റെ കാര്യത്തിൽ) വിൻഡോ . തെളിയിക്കാൻ എളുപ്പമാണ്:
അലേർട്ട് (ജാലകത്തിൻ്റെ തരം.മെത്തോഡ്അത് നിലവിലുള്ളത്); // => നിർവചിക്കാത്ത അലേർട്ട് (typeof window.makeArray); // => പ്രവർത്തനം
അതായത്, makeArray ("ഒന്ന്", "രണ്ട്") എന്ന് വിളിക്കുന്നു; window.makeArray("ഒന്ന്", "രണ്ട്") എന്ന് വിളിക്കുന്നതിന് തുല്യമാണ്; .

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

ഫംഗ്‌ഷൻ കോളിംഗ് റൂൾ #1: ഒരു ഒബ്‌ജക്റ്റ് വ്യക്തമാക്കാതെ ഒരു ഫംഗ്‌ഷൻ നേരിട്ട് വിളിക്കുകയാണെങ്കിൽ (ഉദാഹരണത്തിന്, myFunction()), ഇതിൻ്റെ മൂല്യം ആഗോള ഒബ്‌ജക്റ്റായിരിക്കും (ബ്രൗസറിൽ കോഡ് എക്‌സിക്യൂട്ട് ചെയ്‌താൽ വിൻഡോ).

ഒരു രീതി വിളിക്കുന്നു നമുക്ക് ഒരു ലളിതമായ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് അതിൻ്റെ രീതി makeArray ആക്കാം. അക്ഷരീയ നൊട്ടേഷൻ ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് പ്രഖ്യാപിക്കാം, തുടർന്ന് ഞങ്ങളുടെ രീതിയെ വിളിക്കാം:
// ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക var arrayMaker = ( someProperty: "some value", make: makeArray ); // make() രീതി arrayMaker.make("ഒന്ന്", "രണ്ട്") വിളിക്കുക; // => [അറേ മേക്കർ, "ഒന്ന്", "രണ്ട്" ] // ഇതര വാക്യഘടന, സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുക arrayMaker["make"]("one", " two"); // => [അറേമേക്കർ, "ഒന്ന്", "രണ്ട്" ]
നിങ്ങൾ വ്യത്യാസം കാണുന്നുണ്ടോ? ഈ കേസിൽ ഇതിൻ്റെ മൂല്യം വസ്തുവാണ്. ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ മാറിയിട്ടില്ലാത്തതിനാൽ, മുമ്പത്തെ കാര്യത്തിലെന്നപോലെ എന്തുകൊണ്ട് വിൻഡോ പാടില്ല? JavaScript-ൽ ഫംഗ്‌ഷനുകൾ എങ്ങനെ കൈമാറുന്നു എന്നതാണ് രഹസ്യം. പ്രവർത്തനം സ്റ്റാൻഡേർഡ് ആണ് ജാവാസ്ക്രിപ്റ്റ് തരം, യഥാർത്ഥത്തിൽ ഒരു ഒബ്ജക്റ്റ് ആണ്, മറ്റേതൊരു ഒബ്ജക്റ്റും പോലെ, ഫംഗ്ഷനുകൾ കൈമാറാനും പകർത്താനും കഴിയും. ഈ സാഹചര്യത്തിൽ, ആർഗ്യുമെൻ്റ് ലിസ്റ്റും ബോഡിയും ഉൾപ്പെടെ മുഴുവൻ ഫംഗ്ഷനും ഞങ്ങൾ പ്രധാനമായും പകർത്തി, തത്ഫലമായുണ്ടാകുന്ന ഒബ്‌ജക്റ്റ് അറേമേക്കർ ഒബ്‌ജക്റ്റിൻ്റെ മേക്ക് പ്രോപ്പർട്ടിയിലേക്ക് അസൈൻ ചെയ്‌തു. ഇത് ഇതുപോലുള്ള ഒരു പ്രഖ്യാപനത്തിന് തുല്യമാണ്:
var arrayMaker = ( ചില പ്രോപ്പർട്ടി: "ചില മൂല്യം"; നിർമ്മിക്കുക: ഫംഗ്‌ഷൻ (arg1, arg2) ( മടങ്ങുക [ഇത്, arg1, arg2]; ) );
ഫംഗ്‌ഷൻ കോളിംഗ് റൂൾ #2: obj.myFunction() അല്ലെങ്കിൽ obj["myFunction"]() പോലുള്ള മെത്തേഡ് കോൾ സിൻ്റാക്സ് ഉപയോഗിച്ച് വിളിക്കുന്ന ഒരു ഫംഗ്ഷനിൽ, ഇതിന് obj മൂല്യം ഉണ്ടായിരിക്കും.

ഇവൻ്റുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ സാധാരണയായി ഈ ലളിതമായ തത്വത്തിൻ്റെ തെറ്റിദ്ധാരണ പലപ്പോഴും പിശകുകളിലേക്ക് നയിക്കുന്നു:
ഫംഗ്ഷൻ ബട്ടൺ ക്ലിക്ക് ചെയ്തു())( var ടെക്സ്റ്റ് = (ഇത് === വിൻഡോ) ? "വിൻഡോ" : this.id; അലർട്ട്(ടെക്സ്റ്റ്); ) var button1 = document.getElementById("btn1"); var ബട്ടൺ2 = document.getElementById("btn2"); button1.onclick = buttonClicked; button2.onclick = function())( buttonClicked(); );
ആദ്യത്തെ ബട്ടണിൽ ക്ലിക്കുചെയ്യുന്നത് ഒരു സന്ദേശം കാണിക്കും "btn1"കാരണം ഈ സാഹചര്യത്തിൽ നമ്മൾ ഒരു ഫംഗ്‌ഷനെ ഒരു മെത്തേഡ് ആയി വിളിക്കുന്നു, കൂടാതെ ഫംഗ്‌ഷനുള്ളിൽ ഈ രീതി ഉൾപ്പെടുന്ന ഒബ്‌ജക്റ്റിൻ്റെ മൂല്യം ലഭിക്കും. രണ്ടാമത്തെ ബട്ടണിൽ ക്ലിക്ക് ചെയ്താൽ ലഭിക്കും "ജാലകം"കാരണം ഈ സാഹചര്യത്തിൽ നമ്മൾ നേരിട്ട് ബട്ടൺ ക്ലിക്ക് ചെയ്യുകയാണ് വിളിക്കുന്നത് (അതായത് obj.buttonClicked() പോലെയല്ല). മൂന്നാമത്തെ ബട്ടണിൻ്റെ കാര്യത്തിലെന്നപോലെ, എലമെൻ്റ് ടാഗിലേക്ക് ഒരു ഇവൻ്റ് ഹാൻഡ്‌ലർ നൽകുമ്പോഴും ഇതുതന്നെ സംഭവിക്കുന്നു. മൂന്നാമത്തെ ബട്ടണിൽ ക്ലിക്കുചെയ്യുന്നത് രണ്ടാമത്തേതിന് സമാനമായ സന്ദേശം കാണിക്കും.

jQuery പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ ഇതിനെക്കുറിച്ച് ചിന്തിക്കേണ്ടതില്ല. ഇവൻ്റ് ഹാൻഡ്‌ലറിൽ ഈ മൂല്യം മാറ്റിയെഴുതാൻ jQuery ശ്രദ്ധിക്കും, അതുവഴി ഇവൻ്റ് ഉയർത്തിയ ഘടകമാണ് ഈ മൂല്യം:
// jQuery ഉപയോഗിക്കുക $("#btn1").click(function() ( alert(this.id); // jQuery "ഇത്" ഒരു ബട്ടണാണെന്ന് ഉറപ്പാക്കും ));
ഇതിൻ്റെ മൂല്യം മാറ്റാൻ jQuery എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു? താഴെ വായിക്കുക.

രണ്ട് വഴികൾ കൂടി: പ്രയോഗിക്കുക () കൂടാതെ കോൾ () നിങ്ങൾ കൂടുതൽ തവണ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്തോറും അവ കൈമാറുകയും വ്യത്യസ്ത സന്ദർഭങ്ങളിൽ വിളിക്കുകയും ചെയ്യേണ്ടത് യുക്തിസഹമാണ്. പലപ്പോഴും ഇതിൻ്റെ മൂല്യം മറികടക്കേണ്ടി വരും. നിങ്ങൾ ഓർക്കുന്നുണ്ടെങ്കിൽ, JavaScript-ലെ പ്രവർത്തനങ്ങൾ ഒബ്ജക്റ്റുകളാണ്. പ്രായോഗികമായി, ഫംഗ്ഷനുകൾക്ക് മുൻകൂട്ടി നിശ്ചയിച്ച രീതികൾ ഉണ്ടെന്നാണ് ഇതിനർത്ഥം. പ്രയോഗിക്കുക(), കോൾ() എന്നിവ അവയിൽ രണ്ടാണ്. ഈ മൂല്യം അസാധുവാക്കാൻ അവർ നിങ്ങളെ അനുവദിക്കുന്നു:
var കാർ = (വർഷം: 2008, മോഡൽ: "ഡോഡ്ജ് ബെയ്‌ലൗട്ട്" ); makeArray.apply(കാർ, [ "ഒന്ന്", "രണ്ട്" ]); // => [കാർ, "ഒന്ന്", "രണ്ട്" ] makeArray.call(കാർ, "ഒന്ന്", "രണ്ട്"); // => [കാർ, "ഒന്ന്", "രണ്ട്" ]
ഈ രണ്ട് രീതികളും വളരെ സമാനമാണ്. ആദ്യ പാരാമീറ്റർ ഇതിനെ മറികടക്കുന്നു. അവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ തുടർന്നുള്ള ആർഗ്യുമെൻ്റുകളിലാണ്: Function.apply() ഫംഗ്‌ഷനിലേക്ക് കൈമാറുന്ന മൂല്യങ്ങളുടെ ഒരു നിര സ്വീകരിക്കുന്നു, അതേസമയം Function.call() ആർഗ്യുമെൻ്റുകൾ പ്രത്യേകം സ്വീകരിക്കുന്നു. പ്രായോഗികമായി, എൻ്റെ അഭിപ്രായത്തിൽ, പ്രയോഗിക്കാൻ കൂടുതൽ സൗകര്യപ്രദമാണ് () .

ഫംഗ്‌ഷൻ കോളിംഗ് റൂൾ #3: മറ്റൊരു ഒബ്‌ജക്‌റ്റിലേക്ക് ഫംഗ്‌ഷൻ പകർത്താതെ ഇതിൻ്റെ മൂല്യം അസാധുവാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് myFunction.apply(obj) അല്ലെങ്കിൽ myFunction.call(obj) ഉപയോഗിക്കാം.

കൺസ്ട്രക്‌റ്റർമാർ JavaScript-ൽ ഇഷ്‌ടാനുസൃത തരങ്ങൾ പ്രഖ്യാപിക്കുന്നതിനെക്കുറിച്ച് ഞാൻ വിശദമായി പറയില്ല, പക്ഷേ JavaScript-ൽ ക്ലാസുകളൊന്നുമില്ലെന്നും ഏത് ഇഷ്‌ടാനുസൃത തരത്തിനും ഒരു കൺസ്‌ട്രക്‌ടർ ആവശ്യമാണെന്നും നിങ്ങളെ ഓർമ്മിപ്പിക്കേണ്ടത് പ്രധാനമാണെന്ന് ഞാൻ കരുതുന്നു. കൂടാതെ, രീതികൾ ഇഷ്ടാനുസൃത തരംപ്രോട്ടോടൈപ്പ് ഉപയോഗിച്ച് ഇത് പ്രഖ്യാപിക്കുന്നതാണ് നല്ലത്, ഇത് കൺസ്ട്രക്റ്റർ ഫംഗ്ഷൻ്റെ ഒരു സ്വത്താണ്. നമുക്ക് നമ്മുടെ സ്വന്തം തരം സൃഷ്ടിക്കാം:
// കൺസ്ട്രക്റ്റർ ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക ArrayMaker(arg1, arg2) ( this.someProperty = "സാരമില്ല"; this.theArray = [ഇത്, arg1, arg2 ]; ) // രീതികൾ പ്രഖ്യാപിക്കുക ArrayMaker.prototype = (ചില രീതി: പ്രവർത്തനം () ( മുന്നറിയിപ്പ് ("ചില രീതി ഉപയോഗിച്ച് വിളിക്കുന്നു"); ), getArray: ഫംഗ്ഷൻ () (ഇത്.theArray തിരികെ നൽകുക; ) ); var am = പുതിയ ArrayMaker("ഒന്ന്", "രണ്ട്"); var other = new ArrayMaker("ആദ്യം", "രണ്ടാം"); am.getArray(); // => [ am, "ഒന്ന്", "രണ്ട്" ]
ഈ ഉദാഹരണത്തിലെ പ്രധാന കാര്യം ഫംഗ്ഷൻ കോളിന് മുമ്പായി പുതിയ ഓപ്പറേറ്ററുടെ സാന്നിധ്യമാണ്. അത് ഇല്ലായിരുന്നുവെങ്കിൽ, അത് ഒരു ആഗോള കോളായിരിക്കും, കൂടാതെ കൺസ്ട്രക്റ്ററിൽ സൃഷ്ടിക്കപ്പെട്ട ഗുണങ്ങൾ ആഗോള ഒബ്‌ജക്റ്റിൻ്റേതായിരിക്കും. ഞങ്ങൾക്ക് അത് ആവശ്യമില്ല. കൂടാതെ, കൺസ്ട്രക്‌ടർമാർ സാധാരണയായി മൂല്യങ്ങൾ വ്യക്തമായി നൽകില്ല. പുതിയ ഓപ്പറേറ്റർ ഇല്ലെങ്കിൽ കൺസ്‌ട്രക്‌റ്റർ നിർവചിക്കാതെ മടങ്ങും, അതോടൊപ്പം ഇത് തിരികെ നൽകുന്നു. നല്ല ശൈലിനിർമ്മാതാക്കളുടെ പേരുകൾ പരിഗണിക്കുന്നു വലിയ അക്ഷരം; പുതിയ ഓപ്പറേറ്ററുടെ ആവശ്യകതയെക്കുറിച്ച് ഇത് നിങ്ങളെ ഓർമ്മിപ്പിക്കും.

അല്ലെങ്കിൽ, കൺസ്‌ട്രക്‌ടറിനുള്ളിലെ കോഡ് നിങ്ങൾ മറ്റൊരു ഭാഷയിൽ എഴുതുന്ന കോഡിന് സമാനമായിരിക്കും. ഈ കേസിൽ ഇതിൻ്റെ മൂല്യം നിങ്ങൾ സൃഷ്ടിക്കുന്ന പുതിയ വസ്തുവാണ്.

ഫംഗ്‌ഷൻ കോളിംഗ് റൂൾ നമ്പർ 4: ഒരു ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ ഓപ്പറേറ്റർ പുതിയത്, ഇതിൻ്റെ മൂല്യം JavaScript റൺടൈം സൃഷ്‌ടിച്ച ഒരു പുതിയ ഒബ്‌ജക്‌റ്റായിരിക്കും. ഈ ഫംഗ്‌ഷൻ ഏതെങ്കിലും ഒബ്‌ജക്റ്റ് വ്യക്തമായി നൽകുന്നില്ലെങ്കിൽ, ഇത് പരോക്ഷമായി തിരികെ നൽകും.

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

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

ഒരു JavaScript ഫംഗ്‌ഷൻ പ്രഖ്യാപിക്കുകയും വിളിക്കുകയും ചെയ്യുന്നു

JavaScript ഫംഗ്‌ഷൻ വാക്യഘടന ഇപ്രകാരമാണ്:

ഫംഗ്‌ഷൻ ""പേര്"" (""argument1"", ""argument2"", ""argument3"" ...) ( ""ഓപ്പറേറ്റർമാർ"" തിരികെ ""മൂല്യം"" )

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

ഇനിപ്പറയുന്ന ഉദാഹരണം ഒരു HTML പേജിൻ്റെ വിഭാഗത്തിൽ നിർവചിച്ചിരിക്കുന്നതും വിഭാഗത്തിൽ വിളിക്കപ്പെടുന്നതുമായ ഒരു ഫംഗ്ഷൻ കാണിക്കുന്നു:

ഫംഗ്‌ഷൻ sayHello() (അലേർട്ട്("ഹലോ!"); )SayHello();

ഒരു ഫംഗ്ഷനിലേക്ക് ആർഗ്യുമെൻ്റുകൾ കൈമാറുന്നു

മുകളിലുള്ള ഉദാഹരണത്തിൽ (സ്ക്രിപ്റ്റ് ടൈപ്പ് ടെക്സ്റ്റ് ജാവാസ്ക്രിപ്റ്റ് ഫംഗ്ഷൻ), ഫംഗ്ഷനിലേക്ക് ആർഗ്യുമെൻ്റുകളൊന്നും കൈമാറില്ല. സാധാരണയായി ഒരു ഫംഗ്‌ഷൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് നിരവധി ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് ചില പ്രവർത്തനങ്ങൾ നടത്താൻ വേണ്ടിയാണ്:

ഒരു ജാവാസ്ക്രിപ്റ്റ് ഫംഗ്‌ഷൻ സേഹെല്ലോ(ദിവസം, മാസം) (അലേർട്ട് ("ഹലോ! ഇന്ന് " + ദിവസം + " ഹലോ ("1", "ഓഗസ്റ്റ്"); ഹലോ ("24", "മെയ്");

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

ഒരു ഫംഗ്ഷനിൽ നിന്ന് ഒരു മൂല്യം നൽകുന്നു

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

ഒരു ലളിതമായ JavaScript ഫംഗ്‌ഷൻ ഉദാഹരണം var ഫലം = addValues(10, 20) document.write("ഫലം = " + ഫലം);

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ 10, 20 മൂല്യങ്ങൾ addValues ​​ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു. addValues ​​ഫംഗ്ഷൻ ഈ രണ്ട് മൂല്യങ്ങളും ചേർത്ത് ഫലം നൽകുന്നു. റിട്ടേൺ സ്റ്റേറ്റ്മെൻ്റ് ഫലം വേരിയബിളിലേക്ക് നൽകുന്നു, അത് HTML പേജിൽ അച്ചടിച്ച ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു.

JavaScript ഫംഗ്‌ഷൻ കോൾ ചെയ്യാനാകും പല സ്ഥലങ്ങൾ. ഉദാഹരണത്തിന്, ഒരു വേരിയബിളിൻ്റെ മൂല്യമായി ഫലം നൽകേണ്ടതില്ല. document.write എന്ന് വിളിക്കുമ്പോൾ നിങ്ങൾക്കത് നേരിട്ട് ഒരു വാദമായി ഉപയോഗിക്കാം.

ഒരു ഫംഗ്ഷന് ഒരു മൂല്യം മാത്രമേ നൽകാനാകൂ എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്:

ഒരു JavaScript ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ്റെ ലളിതമായ ഉദാഹരണം addValues(value1, value2) ( value1 + value2 തിരികെ നൽകുക; ) document.write("ഫലം = " + addValues(10, 20)); ജാവാസ്ക്രിപ്റ്റ് ഓൺക്ലിക്ക് ഫംഗ്ഷനുകൾ സോപാധിക പ്രസ്താവനകളിലും ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്: ഒരു JavaScript ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ്റെ ഒരു ലളിതമായ ഉദാഹരണം addValues(value1, value2) ( value1 + value2; ) തിരികെ നൽകുക (addValues(10, 20) > 20) (document.write("ഫലം > 20"); ) വേറെ ( document.write ( "ഫലം< 20"); }

പ്രവർത്തന പ്രഖ്യാപനങ്ങൾ എവിടെ സ്ഥാപിക്കണം

സ്ഥാപിക്കാൻ ശുപാർശ ചെയ്യുന്ന രണ്ട് സ്ഥലങ്ങളുണ്ട് JavaScript പ്രഖ്യാപനങ്ങൾഫംഗ്‌ഷൻ റിട്ടേൺ: ഒരു HTML ഡോക്യുമെൻ്റിൻ്റെ ഒരു വിഭാഗത്തിനകത്തോ ഉള്ളിലോ ബാഹ്യ ഫയൽ.js. രണ്ടാമത്തെ ഓപ്ഷൻ ഏറ്റവും ഇഷ്ടപ്പെട്ട സ്ഥലമായി കണക്കാക്കപ്പെടുന്നു, കാരണം ഇത് ഏറ്റവും വലിയ വഴക്കം നൽകുന്നു.

ഫംഗ്‌ഷനുകൾ സൃഷ്‌ടിക്കുന്നതിൻ്റെ ലക്ഷ്യം പുനരുപയോഗം പരമാവധിയാക്കുന്നതിന് അവയെ കഴിയുന്നത്ര പൊതുവായതാക്കുക എന്നതാണ്.

"ജാവാസ്ക്രിപ്റ്റ് ഫംഗ്ഷനുകൾ മനസ്സിലാക്കുന്നു" എന്ന ലേഖനത്തിൻ്റെ വിവർത്തനം തയ്യാറാക്കിയത് സൗഹൃദ പ്രോജക്റ്റ് ടീമാണ്.

നല്ല ചീത്ത

ഒരു വെബ് റിസോഴ്‌സിൽ ഉള്ളടക്കം ചലനാത്മകമായി സൃഷ്ടിക്കുന്നതിനുള്ള ആശയങ്ങൾ ഒരു മാനദണ്ഡമായി മാറിയിരിക്കുന്നു. സ്റ്റാറ്റിക് പേജുകൾടെംപ്ലേറ്റ് വെബ്‌സൈറ്റ് നിർമ്മാണവും ഒടുവിൽ അവരുടെ ദൗത്യം പൂർത്തിയാക്കി.

എന്നിരുന്നാലും, ഒരു ആധുനിക വെബ് റിസോഴ്‌സിനെ സെർവർ സൃഷ്‌ടിച്ചതും ബ്രൗസർ (JS+AJAX) അപ്‌ഡേറ്റ് ചെയ്യുന്നതുമായ ഒരു കൂട്ടം പേജുകൾ പ്രതിനിധീകരിക്കണമെന്നില്ല.

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

വിവരണത്തിൻ്റെ സ്ഥലവും പ്രവർത്തനങ്ങളുടെ സത്തയും

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

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

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

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

ഫങ്ഷണൽ ഡൈനാമിക്സ്

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

പേജിലെ പ്രവർത്തനം അതിൻ്റെ ഘടകങ്ങളെയും അതിലെ സന്ദർശകൻ്റെ പെരുമാറ്റത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. മൗസ് ചലനങ്ങൾ, കീബോർഡ് ബട്ടണുകൾ, ക്ലിക്കുകൾ, എലമെൻ്റ് ഇവൻ്റുകൾ, മറ്റ് സാഹചര്യങ്ങൾ എന്നിവ ആവശ്യമായ പ്രവർത്തനങ്ങളുടെ സമാരംഭത്തിലേക്ക് നയിക്കുന്നു.

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

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

ഇത് വികസനത്തിലെ പുതിയ ചിന്തയാണ്: ഒരൊറ്റ ബ്രൗസറിൻ്റെ കുടലിൽ വിതരണം ചെയ്ത വിവര പ്രോസസ്സിംഗ്!

വേരിയബിളുകളുടെയും പ്രവർത്തനങ്ങളുടെയും വാക്യഘടന

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

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

IN ഈ ഉദാഹരണത്തിൽപേജിനും സെർവറിനുമിടയിൽ AJAX എക്സ്ചേഞ്ച് നൽകുന്ന രണ്ട് ഫംഗ്ഷനുകൾ വിവരിച്ചിരിക്കുന്നു. scXHR വേരിയബിൾ മുകളിൽ വിവരിച്ചിരിക്കുന്നു, അതിനാൽ ഇത് InitXML ലും WaitReplySC യിലും ലഭ്യമാണ്.

ഫംഗ്ഷൻ നാമവും "ഫംഗ്ഷൻ" പാരാമീറ്ററും

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

WaitReplySC ഒരു ഫംഗ്‌ഷനാണെന്നതും ഇവിടെ ശ്രദ്ധിക്കേണ്ടതാണ്. എന്നാൽ വരിയിൽ scXHR.onreadystatechange = കാത്തിരിക്കൂ മറുപടി SCഅത് ഒരു പരാമീറ്ററായി കൈമാറുന്നു. ഈ പൊതു നിയമംഫംഗ്‌ഷനുകൾ മറ്റ് ഫംഗ്‌ഷനുകളിലേക്ക് പാരാമീറ്ററുകളായി കൈമാറുന്നു. ബ്രാക്കറ്റുകൾ വ്യക്തമാക്കുകയും അതിൻ്റെ പാരാമീറ്റർ (കൾ) അവയിലേക്ക് കടത്തിവിടുകയും ചെയ്യുക - ഫംഗ്ഷൻ ഉടനടി നടപ്പിലാക്കും. അവൻ എനിക്ക് അവൻ്റെ പേര് മാത്രമാണ് നൽകിയത്, പക്ഷേ എന്ത്. ഫംഗ്‌ഷൻ കോൾ അതിൻ്റെ പേര് ലഭിച്ചയാൾ നടത്തും.

AJAX മുഖേന നടപ്പിലാക്കിയ പ്രവർത്തനം സെർവറിൽ നിന്ന് ലഭിച്ച ഡാറ്റ വഴി ഒരു JavaScript ഫംഗ്ഷനിലേക്ക് ഒരു കോൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. വാസ്തവത്തിൽ, സെർവറിലേക്ക് ഒരു അഭ്യർത്ഥന അയയ്‌ക്കുമ്പോൾ, ഒരു പ്രത്യേക ഫംഗ്‌ഷൻ ഏത് ഫംഗ്‌ഷനാണ് ആക്‌സസ് ചെയ്യുന്നതെന്നും ഏത് വിവരങ്ങളോടെയാണെന്നും “അറിയില്ല”.

ഫംഗ്ഷൻ എക്സിറ്റും അതിൻ്റെ ഫലവും

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

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

സാധാരണഗതിയിൽ, ഡവലപ്പർമാർ ഈ സവിശേഷതയെ വളരെയധികം ബഹുമാനിക്കുകയും സാഹചര്യത്തെ ആശ്രയിച്ച്, കഴിയുന്നത്ര വേഗം ഫീച്ചറിൽ നിന്ന് പുറത്തുകടക്കാൻ തീരുമാനിക്കുകയും ചെയ്യുന്നു.

നിങ്ങൾക്ക് നേരത്തെ പുറത്തുകടക്കാൻ കഴിയുമ്പോൾ മുഴുവൻ ഫംഗ്ഷൻ അൽഗോരിതത്തിലൂടെയും പോകേണ്ട ആവശ്യമില്ല.

ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റുകൾ

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

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

ഫംഗ്‌ഷൻ ആർഗ്യുമെൻ്റ് മാറ്റുന്നത് ഫംഗ്‌ഷനുള്ളിൽ സാധുതയുള്ളതാണ്, പക്ഷേ അതിന് പുറത്തല്ല. പ്രവർത്തനത്തിന് പുറത്ത് എന്തെങ്കിലും മാറ്റുന്നതിന്, നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് ജാവാസ്ക്രിപ്റ്റ് ഓപ്പറേറ്റർറിട്ടേൺ, അതിലൂടെ ആവശ്യമായ മൂല്യം പുറത്തേക്ക് കടത്തുക.

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

ആർഗ്യുമെൻ്റുകൾക്ക് ഒരു കോളീ പ്രോപ്പർട്ടി ഉണ്ട്, അത് ഒരു ഫംഗ്‌ഷനെ വിളിക്കാൻ ഉപയോഗിക്കുന്നു, അത് ചെയ്യുന്നു ഈ നിമിഷംസമയം. നിങ്ങൾ സ്വയം വിളിച്ചാൽ, പിന്നെ JavaScript ഓപ്ഷൻഒരു ഫംഗ്ഷനിലെ ഒരു ഫംഗ്ഷൻ ആവർത്തനം നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കും.

ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു

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

ഒരു ഫംഗ്‌ഷന് ഒന്നിലധികം പേജ് ഘടകങ്ങളും ഒന്നിലധികം ഇവൻ്റുകളും നൽകാനാകും. "ഇത്" പാരാമീറ്റർ ഉപയോഗിച്ച്, അത് വിളിച്ച ഫംഗ്ഷനിലേക്ക് നിങ്ങൾക്ക് വിവരങ്ങൾ കൈമാറാൻ കഴിയും.

ഘടകങ്ങളിലെ ഇവൻ്റ് ഹാൻഡ്‌ലറുകളാണ് JS ഫംഗ്‌ഷനുകളുടെ ഒരു ക്ലാസിക് ഉപയോഗം. ഈ ഉദാഹരണത്തിൽ, scfWecomeGo() അല്ലെങ്കിൽ scfWelcomeCancel() ഫംഗ്‌ഷൻ സന്ദർശക ലോഗിൻ/ലോഗൗട്ട് ഫോമിൽ വിളിക്കും, കൂടാതെ ഓപ്പറേറ്റിംഗ് മോഡ് തിരഞ്ഞെടുക്കുമ്പോൾ scfMenuItemClick(ഇത്).

പിന്നീടുള്ള സന്ദർഭത്തിൽ, "ഈ" പാരാമീറ്റർ കടന്നുപോയി, ഏത് ഡിവിയിൽ നിന്നാണ് കോൾ വന്നതെന്ന് അത്ഭുതകരമായി കണ്ടെത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു. പൊതുവേ, ജാവാസ്ക്രിപ്റ്റ് വളരെ നന്നായി DOM-ൽ ഇംപ്ലാൻ്റ് ചെയ്തിട്ടുണ്ട്, മാത്രമല്ല അതിൻ്റെ ഘടകങ്ങളിലൂടെ നാവിഗേറ്റ് ചെയ്യാനും ശേഖരിക്കാനും ഇത് നിങ്ങളെ സൗകര്യപ്രദമായി അനുവദിക്കുന്നു ആവശ്യമായ വിവരങ്ങൾപേജ് ഡൈനാമിക്സ് പ്രവചനാതീതമായിരിക്കും.

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

പേജിൽ അത്തരമൊരു ഘടകം സ്ഥാപിക്കുന്നതിലൂടെ, ഡവലപ്പർ സൃഷ്ടിക്കുന്നു പുതിയ പ്രവർത്തനം, പ്രശ്നം പരിഹരിക്കുന്നതിനും സന്ദർശകരുടെ താൽപ്പര്യങ്ങൾ തൃപ്തിപ്പെടുത്തുന്നതിനും ഇത് നല്ലതാണ്, എന്നാൽ നടപ്പിലാക്കുന്ന കാര്യത്തിൽ വളരെ ബുദ്ധിമുട്ടാണ്.

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

വിതരണം ചെയ്ത ചിന്തയെക്കുറിച്ച്

ഡെവലപ്പർ എല്ലാ പേജ് ഘടകങ്ങളുടെയും തലത്തിൽ, എല്ലാ ഇവൻ്റുകളുടെയും തലത്തിൽ ചിന്തിക്കണം, എല്ലാം യഥാർത്ഥത്തിൽ എങ്ങനെ സംഭവിക്കുന്നു എന്നതിനെക്കുറിച്ച് വ്യക്തമായ ധാരണ ഉണ്ടായിരിക്കണം. ഇത് ബുദ്ധിമുട്ടാണ്, പക്ഷേ ജോലി വിലമതിക്കുന്നു.

IN ജാവാസ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻചില ഇവൻ്റ് വരെ ഫംഗ്‌ഷനുകൾ മാറ്റിവയ്ക്കാം, കൂടാതെ അത്തരം നിരവധി ഫംഗ്‌ഷനുകൾ ഉണ്ടാകാം, കൂടാതെ ഇവൻ്റുകൾ വ്യാപിക്കുകയും വിവിധ ഹാൻഡ്‌ലർമാരുടെ "ദൃശ്യതയുടെ വ്യാപ്തി"യിലേക്ക് വീഴുകയും ചെയ്യും.

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

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

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

പ്രവർത്തന വാദങ്ങളും ഫലങ്ങളും

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

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

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

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

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

ജനറേറ്റ് ചെയ്ത കോഡിൻ്റെ നിർവ്വഹണം

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

ഈ ഉദാഹരണത്തിൽ, നിലവിലെ ഡിവിയിലേക്ക് ചില വിവരങ്ങൾ ചേർക്കുന്നതിന് ഒരു ലൈൻ ജനറേറ്റ് ചെയ്യുന്നു. ഡിവി നമ്പറും വിവര ഉള്ളടക്കവും വ്യത്യസ്ത സ്ഥാനങ്ങൾക്ക് വ്യത്യസ്തമാണ്, അതിനാൽ ഈ സാഹചര്യത്തിൽ അത്തരമൊരു പരിഹാരം "ജാവാസ്ക്രിപ്റ്റ് പിശക് ഓപ്പറേഷൻ സുരക്ഷിതമല്ല" സാഹചര്യം നൽകുമെന്ന് ഉറപ്പില്ല, പക്ഷേ അത് വിശ്വസനീയമായി ആവശ്യമുള്ള ഫലം നൽകും.

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഒരു സൂക്ഷ്മത "ഒരു ഫംഗ്ഷനുള്ളിലെ പ്രവർത്തനം" മാതൃക

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

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

എന്നിരുന്നാലും, ആവർത്തനവും സാധുവായ കോൾബാക്ക് നടത്താൻ കഴിയുന്ന മറ്റൊരു ഫംഗ്‌ഷനെ വിളിക്കുന്ന ഫംഗ്‌ഷനും മാനദണ്ഡമാണ്.

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

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

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 04/09/2018

ഒരു നിർദ്ദിഷ്‌ട പ്രവർത്തനം നടത്തുന്ന അല്ലെങ്കിൽ ഒരു പ്രത്യേക മൂല്യം കണക്കാക്കുന്ന നിർദ്ദേശങ്ങളുടെ ഒരു കൂട്ടമാണ് ഫംഗ്‌ഷനുകൾ.

പ്രവർത്തന നിർവചന വാക്യഘടന:

ഫംഗ്ഷൻ_നാമം([പാരാമീറ്റർ [, ...]])( // നിർദ്ദേശങ്ങൾ )

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

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

നമുക്ക് ഏറ്റവും ലളിതമായ പ്രവർത്തനം നിർവചിക്കാം:

ഫംഗ്‌ഷൻ ഡിസ്‌പ്ലേ())(document.write("JavaScript-ലെ പ്രവർത്തനം"); )

ഈ പ്രവർത്തനത്തെ ഡിസ്പ്ലേ () എന്ന് വിളിക്കുന്നു. ഇത് പാരാമീറ്ററുകളൊന്നും സ്വീകരിക്കുന്നില്ല, വെബ് പേജിലേക്ക് ഒരു സ്ട്രിംഗ് എഴുതുക മാത്രമാണ് ഇത് ചെയ്യുന്നത്.

എന്നിരുന്നാലും ലളിതമായ നിർവചനംഇത് പ്രവർത്തിക്കാൻ ഫീച്ചർ ഇതുവരെ പര്യാപ്തമല്ല. നിങ്ങൾ ഇപ്പോഴും അവളെ വിളിക്കേണ്ടതുണ്ട്:

ഫംഗ്ഷൻ ഡിസ്പ്ലേ())(document.write("JavaScript ലെ ഫംഗ്ഷൻ"); ) display();

ഫംഗ്‌ഷനുകൾക്ക് ഒരു പ്രത്യേക പേര് നൽകേണ്ടതില്ല. നിങ്ങൾക്ക് അജ്ഞാത പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം:

Var ഡിസ്പ്ലേ = ഫംഗ്ഷൻ())( // ഫംഗ്ഷൻ ഡെഫനിഷൻ ഡോക്യുമെൻ്റ്.write("JavaScript ലെ ഫംഗ്ഷൻ"); ) display();

ഞങ്ങൾ ചെയ്യുന്നത് യഥാർത്ഥത്തിൽ ഒരു ഡിസ്പ്ലേ വേരിയബിൾ നിർവചിക്കുകയും അതിന് ഒരു ഫംഗ്ഷൻ റഫറൻസ് നൽകുകയും ചെയ്യുക എന്നതാണ്. പിന്നെ പേരിൽ വേരിയബിൾ ഫംഗ്ഷൻവിളിച്ചു.

ഒരു വേരിയബിളിന് നമുക്ക് ഡൈനാമിക് ആയി ഫംഗ്ഷനുകൾ നൽകാനും കഴിയും:

ഫംഗ്ഷൻ goodMorning())( document.write("Good Morning"); ) function goodEvening())( document.write("Good Evening"); ) var message = goodMorning; സന്ദേശം(); // സുപ്രഭാതം സന്ദേശം = goodEvening; സന്ദേശം(); // ഗുഡ് ഈവനിംഗ്

ഫംഗ്ഷൻ പരാമീറ്ററുകൾ

പാസിംഗ് പാരാമീറ്ററുകൾ നമുക്ക് പരിഗണിക്കാം:

ഫംഗ്ഷൻ ഡിസ്പ്ലേ(x)( // ഫംഗ്ഷൻ ഡെഫനിഷൻ var z = x * x; document.write(x + "squared equals " + z); ) display(5); // ഫംഗ്ഷൻ കോൾ

ഡിസ്പ്ലേ ഫംഗ്ഷൻ ഒരു പാരാമീറ്റർ എടുക്കുന്നു - x. അതിനാൽ, ഒരു ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, നമുക്ക് അതിനായി ഒരു മൂല്യം കൈമാറാൻ കഴിയും, ഉദാഹരണത്തിന്, നമ്പർ 5, ഈ കേസിലെന്നപോലെ.

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

ഫംഗ്ഷൻ തുക(a, b, c)( d = a + b + c; console.log(d); ) തുക(1, 2, 3); അക്കങ്ങൾ അനുവദിക്കുക = ; തുക(...സംഖ്യകൾ);

രണ്ടാമത്തെ സാഹചര്യത്തിൽ, സംഖ്യകളുടെ അറേയിൽ നിന്നുള്ള സംഖ്യകൾ ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു. എന്നാൽ ഒരു അറേയെ ഒരു മൂല്യമായി മാത്രമല്ല, ഈ അറേയിൽ നിന്നുള്ള അക്കങ്ങളും കൈമാറാൻ, സ്പ്രെഡ് ഓപ്പറേറ്റർ (എലിപ്സിസ്...) ഉപയോഗിക്കുന്നു.

ഓപ്ഷണൽ പാരാമീറ്ററുകൾ

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

ഫംഗ്ഷൻ ഡിസ്പ്ലേ(x, y)( if(y === undefined) y = 5; if(x === undefined) x = 8; z = x * y; console.log(z); ) display() ; // 40 ഡിസ്പ്ലേ(6); // 30 ഡിസ്പ്ലേ(6, 4) // 24

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

പാരാമീറ്ററുകൾക്കായി സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ നിർവചിക്കാൻ മറ്റൊരു മാർഗമുണ്ട്:

ഫംഗ്ഷൻ ഡിസ്പ്ലേ(x = 5, y = 10)( z = x * y; console.log(z); ) display(); // 50 ഡിസ്പ്ലേ(6); // 60 ഡിസ്പ്ലേ(6, 4) // 24

x, y എന്നീ പരാമീറ്ററുകളിലേക്ക് മൂല്യങ്ങളൊന്നും കൈമാറുന്നില്ലെങ്കിൽ, അവ യഥാക്രമം 5, 10 എന്നീ സംഖ്യകളുടെ മൂല്യങ്ങളായി ലഭിക്കും. ഈ രീതി നിർവചിക്കാത്തതുമായി താരതമ്യം ചെയ്യുന്നതിനേക്കാൾ കൂടുതൽ സംക്ഷിപ്തവും അവബോധജന്യവുമാണ്.

ഈ സാഹചര്യത്തിൽ, പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന പരാമീറ്ററിൻ്റെ ഡിഫോൾട്ട് മൂല്യം ലഭിക്കും:

ഫംഗ്ഷൻ ഡിസ്പ്ലേ(x = 5, y = 10 + x)( z = x * y; console.log(z); ) display(); // 75 ഡിസ്പ്ലേ(6); // 96 ഡിസ്പ്ലേ(6, 4) // 24

ഈ സാഹചര്യത്തിൽ, y പാരാമീറ്ററിൻ്റെ മൂല്യം x ൻ്റെ മൂല്യത്തെ ആശ്രയിച്ചിരിക്കുന്നു.

ആവശ്യമെങ്കിൽ, ആഗോളതലത്തിൽ പാസ്സായ എല്ലാ പാരാമീറ്ററുകളും നമുക്ക് സ്വീകരിക്കാം ലഭ്യമായ അറേവാദങ്ങൾ:

ഫംഗ്ഷൻ ഡിസ്പ്ലേ())( var z = 1; for(var i=0; i