ജാവാസ്ക്രിപ്റ്റിലെ ഫംഗ്ഷൻ ഇൻവോക്കേഷൻ രീതികൾ
JavaScript-ൽ, ഫംഗ്‌ഷനുകൾ വിവിധ രീതികളിൽ അഭ്യർത്ഥിക്കാം, കൂടാതെ സാധാരണയായി ഉപയോഗിക്കുന്ന രണ്ട് രീതികൾ `കോൾ`, `അപ്ലൈ` എന്നിവയാണ്. ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുന്ന സന്ദർഭം (`ഇത്` മൂല്യം) നിയന്ത്രിക്കാൻ ഈ രീതികൾ നിങ്ങളെ അനുവദിക്കുന്നു. കാര്യക്ഷമവും ഫലപ്രദവുമായ JavaScript കോഡ് എഴുതുന്നതിന് `കോൾ`, `പ്രയോഗിക്കുക` എന്നിവ തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്.
ഒരു ഫംഗ്ഷൻ അഭ്യർത്ഥിക്കുമ്പോൾ `Function.prototype.call()`, `Function.prototype.apply()` എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ ഈ ലേഖനം പര്യവേക്ഷണം ചെയ്യുന്നു. അവരുടെ വാക്യഘടന, ഉപയോഗ കേസുകൾ, സാധ്യമായ പ്രകടന വ്യത്യാസങ്ങൾ എന്നിവ ഞങ്ങൾ പരിശോധിക്കും. ഈ ലേഖനത്തിൻ്റെ അവസാനത്തോടെ, `അപേക്ഷിക്കുക` എന്നതിനുമുപരിയായി `കോൾ` എപ്പോൾ ഉപയോഗിക്കണമെന്ന് നിങ്ങൾക്ക് വ്യക്തമായ ധാരണ ലഭിക്കും.
| കമാൻഡ് | വിവരണം |
|---|---|
| Function.prototype.call() | ഈ മൂല്യവും വ്യക്തിഗതമായി നൽകിയിരിക്കുന്ന ആർഗ്യുമെൻ്റുകളും ഉള്ള ഒരു ഫംഗ്‌ഷനെ വിളിക്കുന്നു. |
| Function.prototype.apply() | നൽകിയിരിക്കുന്ന ഈ മൂല്യമുള്ള ഒരു ഫംഗ്‌ഷനെ വിളിക്കുന്നു, കൂടാതെ ഒരു അറേയായി നൽകിയിരിക്കുന്ന ആർഗ്യുമെൻ്റുകളും. |
| this | ഡൈനാമിക് സന്ദർഭ അസൈൻമെൻ്റ് അനുവദിച്ചുകൊണ്ട് ഫംഗ്ഷൻ വിളിച്ച ഒബ്ജക്റ്റിനെ സൂചിപ്പിക്കുന്നു. |
| console.log() | ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്കായി കൺസോളിലേക്ക് സന്ദേശങ്ങളോ വേരിയബിളുകളോ പ്രിൻ്റ് ചെയ്യുന്നു. |
| res.writeHead() | ഒരു Node.js സെർവറിൽ HTTP സ്റ്റാറ്റസ് കോഡും പ്രതികരണ തലക്കെട്ടുകളും സജ്ജമാക്കുന്നു. |
| res.end() | ഒരു Node.js സെർവറിൽ പ്രതികരണ പ്രക്രിയ അവസാനിപ്പിക്കുന്നു, എല്ലാ ഡാറ്റയും അയച്ചു എന്നതിൻ്റെ സൂചന നൽകുന്നു. |
| http.createServer() | Node.js-ൽ ഒരു HTTP സെർവർ ഉദാഹരണം സൃഷ്ടിക്കുന്നു, ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ കേൾക്കുന്നു. |
| listen() | HTTP സെർവർ ആരംഭിക്കുന്നു, ഇത് ഒരു നിർദ്ദിഷ്ട പോർട്ടിൽ കേൾക്കാൻ അനുവദിക്കുന്നു. |
കോളിൻ്റെ ഉപയോഗം മനസ്സിലാക്കി JavaScript-ൽ പ്രയോഗിക്കുക
നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കുന്നത് തമ്മിലുള്ള വ്യത്യാസങ്ങൾ വ്യക്തമാക്കുന്നു Function.prototype.call() ഒപ്പം Function.prototype.apply() ജാവാസ്ക്രിപ്റ്റിൽ. രണ്ട് രീതികളും നിർദ്ദിഷ്‌ടമായ ഫംഗ്‌ഷനുകൾ അഭ്യർത്ഥിക്കാൻ ഉപയോഗിക്കുന്നു this സന്ദർഭം. ആദ്യ ഉദാഹരണത്തിൽ, ദി call() അഭ്യർത്ഥിക്കാൻ രീതി ഉപയോഗിക്കുന്നു fullName വ്യത്യസ്ത വസ്തുക്കളുടെ രീതി (person1 ഒപ്പം person2), ഓരോ വസ്തുവിൻ്റെയും സവിശേഷതകൾ വ്യക്തിഗത ആർഗ്യുമെൻ്റുകളായി കൈമാറുന്നു. ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം അറിയുകയും സ്ഥിരപ്പെടുകയും ചെയ്യുമ്പോൾ ഈ രീതി ഒരു സംക്ഷിപ്ത വാക്യഘടനയെ അനുവദിക്കുന്നു. രണ്ടാമത്തെ ഉദാഹരണം ഇതിൻ്റെ ഉപയോഗം കാണിക്കുന്നു apply() രീതി, ഇത് സമാനമാണ് call() എന്നാൽ വ്യക്തിഗതമായവയ്ക്ക് പകരം വാദങ്ങളുടെ ഒരു നിര എടുക്കുന്നു. ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം വേരിയബിൾ ആണെങ്കിൽ അല്ലെങ്കിൽ ഒരു അറേ ഉറവിടത്തിൽ നിന്ന് വരുമ്പോൾ ഈ വഴക്കം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.
Node.js ബാക്കെൻഡ് ഉദാഹരണത്തിൽ, the call() ഉപയോഗിച്ച് സൃഷ്ടിച്ച ഒരു HTTP സെർവറിലാണ് രീതി ഉപയോഗിക്കുന്നത് http.createServer(). എങ്ങനെയെന്ന് ഈ ഉദാഹരണം എടുത്തുകാണിക്കുന്നു this HTTP അഭ്യർത്ഥനകളോട് ചലനാത്മകമായി പ്രതികരിക്കുന്നതിന് സെർവർ സൈഡ് JavaScript-ൽ സന്ദർഭം കൈകാര്യം ചെയ്യാൻ കഴിയും. സെർവർ ഒരു ആശംസയോടെ പ്രതികരിക്കുന്നു, അത് എങ്ങനെയെന്ന് കാണിക്കുന്നു call() രീതിയുടെ സന്ദർഭം മാറ്റാൻ കഴിയും greet പ്രവർത്തനം. അവസാനമായി, സംയോജിത മുൻഭാഗവും ബാക്കെൻഡ് ഉദാഹരണവും എങ്ങനെ രണ്ടും കാണിക്കുന്നു call() ഒപ്പം apply() കൂടുതൽ ചലനാത്മകമായ പ്രവർത്തനത്തിൽ ഉപയോഗിക്കാം. ഉപയോഗിച്ച് call() വ്യക്തിഗത വാദങ്ങൾക്കൊപ്പം apply() ഒരു കൂട്ടം ആർഗ്യുമെൻ്റുകൾക്കൊപ്പം, സ്ക്രിപ്റ്റ് ചലനാത്മകമായി ഉപയോക്തൃ വിശദാംശങ്ങൾ സൃഷ്ടിക്കുന്നു, ക്ലയൻ്റ് സൈഡിലും സെർവർ സൈഡിലും ജാവാസ്ക്രിപ്റ്റ് വികസനത്തിൽ ഈ രീതികളുടെ പ്രായോഗിക പ്രയോഗങ്ങൾ ചിത്രീകരിക്കുന്നു.
ഫംഗ്ഷൻ ഇൻവോക്കേഷനായി JavaScript-ൽ കോൾ ഉപയോഗിക്കുകയും രീതികൾ പ്രയോഗിക്കുകയും ചെയ്യുന്നു
JavaScript ഫ്രണ്ടെൻഡ് സ്ക്രിപ്റ്റ്
// Example 1: Using Function.prototype.call()const person = {fullName: function() {return this.firstName + " " + this.lastName;}};const person1 = {firstName: "John",lastName: "Doe"};const person2 = {firstName: "Jane",lastName: "Smith"};// Call the fullName method on person1 and person2console.log(person.fullName.call(person1)); // Output: John Doeconsole.log(person.fullName.call(person2)); // Output: Jane Smith
ഫ്ലെക്സിബിൾ ആർഗ്യുമെൻ്റ് പാസിംഗിനായി Function.prototype.apply() പ്രയോഗിക്കുന്നു
JavaScript ഫ്രണ്ടെൻഡ് സ്ക്രിപ്റ്റ്
// Example 2: Using Function.prototype.apply()const person = {fullName: function(city, country) {return this.firstName + " " + this.lastName + ", " + city + ", " + country;}};const person1 = {firstName: "John",lastName: "Doe"};const person2 = {firstName: "Jane",lastName: "Smith"};// Apply the fullName method with arguments on person1 and person2console.log(person.fullName.apply(person1, ["New York", "USA"])); // Output: John Doe, New York, USAconsole.log(person.fullName.apply(person2, ["London", "UK"])); // Output: Jane Smith, London, UK
Node.js ബാക്ക്എൻഡ് ഉദാഹരണം കോൾ ചെയ്ത് പ്രയോഗിക്കുക
Node.js ഉള്ള JavaScript ബാക്കെൻഡ് സ്ക്രിപ്റ്റ്
// Load the required modulesconst http = require('http');// Create a server objecthttp.createServer((req, res) => {res.writeHead(200, {'Content-Type': 'text/plain'});// Example using call()function greet() {return 'Hello ' + this.name;}const user = { name: 'Alice' };res.write(greet.call(user)); // Output: Hello Aliceres.end();}).listen(3000);console.log('Server running at http://localhost:3000/');
ഒരു ഡൈനാമിക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് കോൾ സംയോജിപ്പിച്ച് പ്രയോഗിക്കുക
JavaScript ഫുൾ സ്റ്റാക്ക് സ്ക്രിപ്റ്റ്
// Define a function to display user detailsfunction displayDetails(age, profession) {return this.name + " is " + age + " years old and works as a " + profession + ".";}// User objectsconst user1 = { name: 'Bob' };const user2 = { name: 'Alice' };// Use call to invoke displayDetailsconsole.log(displayDetails.call(user1, 30, 'Engineer')); // Output: Bob is 30 years old and works as a Engineer.// Use apply to invoke displayDetailsconsole.log(displayDetails.apply(user2, [28, 'Doctor'])); // Output: Alice is 28 years old and works as a Doctor.
JavaScript-ൽ സന്ദർഭ കൃത്രിമത്വം പര്യവേക്ഷണം ചെയ്യുന്നു
അടിസ്ഥാന ഉപയോഗത്തിനപ്പുറം call() ഒപ്പം apply(), കൂടുതൽ സങ്കീർണ്ണവും ശക്തവുമായ കോഡ് സൃഷ്ടിക്കുന്നതിന് ഈ രീതികൾ മറ്റ് JavaScript സവിശേഷതകളുമായി സംയോജിപ്പിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, അവ പലപ്പോഴും സംയോജിച്ച് ഉപയോഗിക്കുന്നു bind(), ഇത് ഒരു നിർദ്ദിഷ്‌ടമായ ഒരു ഫംഗ്ഷൻ നൽകുന്നു this മൂല്യം. വ്യത്യസ്തമായി call() ഒപ്പം apply(), അത് ഉടൻ തന്നെ ഫംഗ്‌ഷനെ ക്ഷണിക്കുന്നു, bind() ഒരു ബൗണ്ട് ഫംഗ്ഷൻ സൃഷ്‌ടിക്കാൻ ഉപയോഗിക്കാവുന്നതാണ്, അത് പിന്നീട് സ്ഥിരമായ ഒരു സന്ദർഭത്തിൽ വിളിക്കാവുന്നതാണ്. ഇവൻ്റ് കൈകാര്യം ചെയ്യുന്നതിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, അവിടെ ഒരു ഫംഗ്ഷൻ വ്യത്യസ്ത പരിതസ്ഥിതികളിൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുമ്പോഴും ഒരു പ്രത്യേക ഒബ്‌ജക്റ്റിൻ്റെ സന്ദർഭം നിലനിർത്തുന്നുവെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം.
മറ്റൊരു വിപുലമായ ഉപയോഗ കേസിൽ ഒരു ഒബ്ജക്റ്റിൽ നിന്ന് മറ്റൊന്നുമായി ഉപയോഗിക്കുന്നതിന് കടമെടുക്കുന്ന രീതികൾ ഉൾപ്പെടുന്നു. ഉപയോഗിച്ചുകൊണ്ട് ഇത് നേടാനാകും call() അഥവാ apply() മറ്റൊരു വസ്തുവുമായി ഒരു രീതിയെ താൽക്കാലികമായി ബന്ധിപ്പിക്കാൻ. ഉദാഹരണത്തിന്, പോലുള്ള അറേ രീതികൾ slice() അഥവാ push() ഫംഗ്‌ഷനുകളിലെ ആർഗ്യുമെൻ്റ് ഒബ്‌ജക്‌റ്റ് പോലുള്ള അറേ പോലുള്ള ഒബ്‌ജക്‌റ്റുകളിൽ കടമെടുത്ത് പ്രയോഗിക്കാൻ കഴിയും. ഈ സാങ്കേതികത കോഡിൻ്റെ കൂടുതൽ വഴക്കവും പുനരുപയോഗവും അനുവദിക്കുന്നു, കാരണം ഇത് ഡ്യൂപ്ലിക്കേഷൻ കൂടാതെ വ്യത്യസ്ത ഒബ്‌ജക്‌റ്റുകളിലുടനീളം രീതികൾ പങ്കിടാൻ പ്രാപ്‌തമാക്കുന്നു.
കോളിനെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ JavaScript-ൽ പ്രയോഗിക്കുക
- തമ്മിലുള്ള പ്രധാന വ്യത്യാസം എന്താണ് call() ഒപ്പം apply()?
- പ്രധാന വ്യത്യാസം അതാണ് call() ആർഗ്യുമെൻ്റുകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിക്കുന്നു, അതേസമയം apply() വാദങ്ങളുടെ ഒരു നിര സ്വീകരിക്കുന്നു.
- എപ്പോഴാണ് ഉപയോഗിക്കേണ്ടത് apply() കഴിഞ്ഞു call()?
- നിങ്ങൾ ഉപയോഗിക്കണം apply() നിങ്ങൾക്ക് ആർഗ്യുമെൻ്റുകളുടെ ഒരു നിര ഉള്ളപ്പോൾ അല്ലെങ്കിൽ ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു വേരിയബിൾ ആർഗ്യുമെൻ്റുകൾ കൈമാറേണ്ടിവരുമ്പോൾ.
- തമ്മിൽ പ്രകടന വ്യത്യാസങ്ങൾ ഉണ്ടോ call() ഒപ്പം apply()?
- സാധാരണയായി, തമ്മിൽ കാര്യമായ പ്രകടന വ്യത്യാസങ്ങളൊന്നുമില്ല call() ഒപ്പം apply(). ഏതെങ്കിലും വ്യത്യാസങ്ങൾ സാധാരണയായി നിസ്സാരമാണ്.
- കഴിയും apply() ഗണിത രീതികൾ ഉപയോഗിക്കണോ?
- അതെ, apply() പോലുള്ള ഗണിത രീതികളിലേക്ക് സംഖ്യകളുടെ ഒരു നിര കൈമാറാൻ ഉപയോഗിക്കാം Math.max() അഥവാ Math.min().
- എന്താണ് Function.prototype.bind()?
- bind() ഒരു പുതിയ ഫംഗ്ഷൻ സൃഷ്ടിക്കുന്നു, അത് വിളിക്കുമ്പോൾ, അതിൻ്റേതാണ് this നൽകിയിരിക്കുന്ന മൂല്യത്തിലേക്ക് കീവേഡ് സജ്ജീകരിച്ചിരിക്കുന്നു, പുതിയ ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ നൽകിയിട്ടുള്ള ആർഗ്യുമെൻ്റുകളുടെ ഒരു നിശ്ചിത ശ്രേണി.
- എങ്ങനെ കഴിയും call() കടം വാങ്ങുന്ന രീതികൾ ഉപയോഗിക്കണോ?
- നിങ്ങൾക്ക് ഉപയോഗിക്കാം call() ഒരു ഒബ്ജക്റ്റിൽ നിന്ന് രീതികൾ കടമെടുത്ത് മറ്റൊരു ഒബ്ജക്റ്റിൽ അവ ഉപയോഗിക്കുന്നതിന്, ഫംഗ്ഷൻ പകർത്താതെ തന്നെ രീതി പുനരുപയോഗം അനുവദിക്കുന്നു.
- ഉപയോഗിക്കാൻ പറ്റുമോ call() അഥവാ apply() കൺസ്ട്രക്‌ടർമാർക്കൊപ്പം?
- ഇല്ല, കൺസ്ട്രക്റ്റർമാരെ നേരിട്ട് വിളിക്കാൻ കഴിയില്ല call() അഥവാ apply(). പകരം, നിങ്ങൾക്ക് ഉപയോഗിക്കാം Object.create() അനന്തരാവകാശ പാറ്റേണുകൾക്കായി.
- അറേ പോലുള്ള ഒബ്ജക്റ്റുകൾ എന്തൊക്കെയാണ്, എങ്ങനെ ചെയ്യണം call() ഒപ്പം apply() അവരോടൊപ്പം പ്രവർത്തിക്കണോ?
- അറേ പോലെയുള്ള ഒബ്ജക്റ്റുകൾ ദൈർഘ്യമുള്ള ഗുണങ്ങളും സൂചികയിലുള്ള ഘടകങ്ങളും ഉള്ള വസ്തുക്കളാണ്. call() ഒപ്പം apply() ഈ ഒബ്ജക്റ്റുകൾ അറേകൾ പോലെ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കാം.
ജാവാസ്ക്രിപ്റ്റിൽ കോളിൻ്റെയും പ്രയോഗിക്കുന്നതിൻ്റെയും ഉപയോഗം സംഗ്രഹിക്കുന്നു
ജാവാസ്ക്രിപ്റ്റിൽ, call() ഒപ്പം apply() നിയന്ത്രിക്കുന്നതിന് അത്യാവശ്യമാണ് this ഫംഗ്ഷനുകൾക്കുള്ളിലെ സന്ദർഭം. call() വ്യക്തിഗത ആർഗ്യുമെൻ്റുകൾ കൈമാറാൻ അനുവദിക്കുന്നു, ഇത് അറിയപ്പെടുന്നതും സ്ഥിരവുമായ ആർഗ്യുമെൻ്റുകൾക്ക് അനുയോജ്യമാക്കുന്നു. വിപരീതമായി, apply() വേരിയബിൾ ആർഗ്യുമെൻ്റ് ലിസ്റ്റുകൾക്ക് വഴക്കം നൽകിക്കൊണ്ട് ആർഗ്യുമെൻ്റുകളുടെ ഒരു നിര എടുക്കുന്നു. രണ്ട് രീതികളും കോഡ് പുനരുപയോഗക്ഷമതയും ഡൈനാമിക് ഫംഗ്ഷൻ ഇൻവോക്കേഷനും മെച്ചപ്പെടുത്തുന്നു, ഫ്രണ്ട്എൻഡ് വികസനത്തിലായാലും Node.js പരിതസ്ഥിതികളിലായാലും. ശുദ്ധവും കാര്യക്ഷമവുമായ ജാവാസ്ക്രിപ്റ്റ് കോഡ് എഴുതുന്നതിന് ഈ രീതികൾ എപ്പോൾ, എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കണമെന്ന് മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്.