JavaScript-ൽ `കോൾ`, `അപ്ലൈ` എന്നിവ തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നു

ജാവാസ്ക്രിപ്റ്റിലെ ഫംഗ്ഷൻ ഇൻവോക്കേഷൻ രീതികൾ

ഫംഗ്‌ഷനുകൾ അഭ്യർത്ഥിക്കുന്നതിന് JavaScript നിരവധി മാർഗങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, അവയിൽ രണ്ടെണ്ണം `Function.prototype.call()`, `Function.prototype.apply()` എന്നിവയാണ്. രണ്ട് രീതികളും ഒരു നിർദ്ദിഷ്‌ട `ഇത്' മൂല്യവും ആർഗ്യുമെൻ്റുകളും ഉള്ള ഫംഗ്‌ഷനുകളെ വിളിക്കാൻ സഹായിക്കുന്നു, എന്നാൽ ഈ ആർഗ്യുമെൻ്റുകൾ എങ്ങനെ കൈമാറുന്നു എന്നതിൽ അവ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു.

ഈ ലേഖനം `കോൾ`, `അപ്ലൈ` എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ, അവയുടെ പ്രകടന പ്രത്യാഘാതങ്ങൾ, മറ്റൊന്നിനേക്കാൾ മുൻഗണന നൽകിയേക്കാവുന്ന സാഹചര്യങ്ങൾ എന്നിവ പര്യവേക്ഷണം ചെയ്യാൻ ലക്ഷ്യമിടുന്നു. അവസാനത്തോടെ, നിങ്ങളുടെ JavaScript കോഡിൽ എപ്പോൾ `കോൾ` അല്ലെങ്കിൽ `പ്രയോഗിക്കുക` എന്നതിനെ കുറിച്ച് നിങ്ങൾക്ക് വ്യക്തമായ ധാരണ ലഭിക്കും.

JavaScript-ൽ `കോൾ`, `അപ്ലൈ` എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു

JavaScript ഫ്രണ്ടെൻഡ് ഉദാഹരണം

// Example of Function.prototype.call()
const person = {
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

const person1 = {
  firstName: "John",
  lastName: "Doe"
};

console.log(person.fullName.call(person1)); // John Doe

JavaScript-ൽ `കോൾ` vs `apply` എന്നതിൻ്റെ പ്രകടനം മനസ്സിലാക്കുന്നു

JavaScript ഫ്രണ്ടെൻഡ് ഉദാഹരണം

// Example of Function.prototype.apply()
const person = {
  fullName: function(city, country) {
    return this.firstName + " " + this.lastName + ", " + city + ", " + country;
  }
};

const person2 = {
  firstName: "Jane",
  lastName: "Doe"
};

console.log(person.fullName.apply(person2, ["Oslo", "Norway"])); // Jane Doe, Oslo, Norway

JavaScript-ലെ ഫംഗ്‌ഷൻ ഇൻവോക്കേഷനായി `കോൾ`, `അപേക്ഷിക്കുക` എന്നിവ താരതമ്യം ചെയ്യുന്നു

Node.js ബാക്കെൻഡ് ഉദാഹരണം

const person = {
  fullName: function(city, country) {
    return this.firstName + " " + this.lastName + ", " + city + ", " + country;
  }
};

const person3 = {
  firstName: "Alice",
  lastName: "Smith"
};

function printName(method) {
  if (method === 'call') {
    console.log(person.fullName.call(person3, 'Paris', 'France'));
  } else if (method === 'apply') {
    console.log(person.fullName.apply(person3, ['Paris', 'France']));
  }
}

printName('call');  // Alice Smith, Paris, France
printName('apply'); // Alice Smith, Paris, France

JavaScript ഡവലപ്‌മെൻ്റിൽ `കോൾ`, `അപ്ലൈ` എന്നിവയ്ക്കിടയിൽ തിരഞ്ഞെടുക്കുന്നു

ജാവാസ്ക്രിപ്റ്റ് പ്രകടന വിശകലനം

const iterations = 1000000;
const person = {
  fullName: function(city, country) {
    return this.firstName + " " + this.lastName + ", " + city + ", " + country;
  }
};
const person4 = {
  firstName: "Bob",
  lastName: "Brown"
};

console.time('call');
for (let i = 0; i < iterations; i++) {
  person.fullName.call(person4, 'Berlin', 'Germany');
}
console.timeEnd('call');

console.time('apply');
for (let i = 0; i < iterations; i++) {
  person.fullName.apply(person4, ['Berlin', 'Germany']);
}
console.timeEnd('apply');

കോളിൻ്റെ ആഴത്തിലുള്ള ഉൾക്കാഴ്ചയും JavaScript-ൽ രീതികളും പ്രയോഗിക്കുക

അവയുടെ അടിസ്ഥാന ഉപയോഗത്തിന് പുറമേ, Function.prototype.call() ഒപ്പം Function.prototype.apply() നിങ്ങളുടെ JavaScript പ്രോഗ്രാമിംഗ് മെച്ചപ്പെടുത്താൻ കഴിയുന്ന നിരവധി വിപുലമായ ഉപയോഗ കേസുകൾ ഉണ്ട്. ഒരു വസ്തുവിൽ നിന്നുള്ള രീതികൾ മറ്റൊന്ന് കടമെടുക്കുന്ന രീതിയിലുള്ള കടം വാങ്ങലാണ് അത്തരത്തിലുള്ള ഒരു ഉപയോഗ കേസ്. അനന്തരാവകാശമില്ലാതെ മറ്റൊരു വസ്തുവിൽ നിന്ന് ഒരു രീതി ഉപയോഗിക്കേണ്ട ഒരു ഒബ്ജക്റ്റ് നിങ്ങളുടെ പക്കലുണ്ടെങ്കിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഉപയോഗിക്കുന്നത് call() ഒപ്പം apply(), നിങ്ങൾക്ക് താത്കാലികമായി രീതികൾ കടമെടുക്കാനും വ്യത്യസ്ത വസ്തുക്കളുടെ പശ്ചാത്തലത്തിൽ അവ നടപ്പിലാക്കാനും കഴിയും, അതുവഴി കോഡ് പുനരുപയോഗം വർദ്ധിപ്പിക്കുകയും ആവർത്തനം കുറയ്ക്കുകയും ചെയ്യും.

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

JavaScript-ൽ കോളിനെ കുറിച്ചും അപേക്ഷിക്കുന്നതിനെ കുറിച്ചും പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

1. തമ്മിലുള്ള പ്രാഥമിക വ്യത്യാസം എന്താണ് call() ഒപ്പം apply()?
2. call() വാദങ്ങൾ വ്യക്തിഗതമായി അംഗീകരിക്കുന്നു, അതേസമയം apply() ആർഗ്യുമെൻ്റുകൾ ഒരു അറേ ആയി സ്വീകരിക്കുന്നു.
3. കഴിയും call() ഒപ്പം apply() പരസ്പരം മാറ്റി ഉപയോഗിക്കണോ?
4. അതെ, അവർക്ക് ഒരേ ഫലം നേടാൻ കഴിയും, എന്നാൽ തിരഞ്ഞെടുപ്പ് വാദങ്ങൾ എങ്ങനെ രൂപപ്പെടുത്തിയിരിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.
5. എപ്പോഴാണ് ഞാൻ മുൻഗണന നൽകേണ്ടത് apply() കഴിഞ്ഞു call()?
6. ഉപയോഗിക്കുക apply() നിങ്ങൾക്ക് ആർഗ്യുമെൻ്റുകളുടെ ഒരു നിരയോ അല്ലെങ്കിൽ ഒരു വേരിയബിൾ ആർഗ്യുമെൻ്റുകളോ ഉള്ളപ്പോൾ.
7. തമ്മിൽ പ്രകടന വ്യത്യാസമുണ്ടോ call() ഒപ്പം apply()?
8. പ്രകടന വ്യത്യാസങ്ങൾ മിക്ക കേസുകളിലും നിസ്സാരമാണ്, പക്ഷേ call() ഒരു നിശ്ചിത എണ്ണം ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് അൽപ്പം വേഗതയുള്ളതാകാം.
9. എങ്ങനെ ചെയ്യും call() ഒപ്പം apply() കൈകാര്യം ചെയ്യുക this സന്ദർഭം?
10. രണ്ട് രീതികളും വ്യക്തമായി സജ്ജീകരിച്ചിരിക്കുന്നു this ഫംഗ്ഷൻ അഭ്യർത്ഥനയ്ക്കുള്ള സന്ദർഭം.
11. എനിക്ക് ഉപയോഗിക്കാമോ call() ഒപ്പം apply() കൺസ്ട്രക്റ്റർ ഫംഗ്ഷനുകൾക്കൊപ്പം?
12. ഇല്ല, പുതിയ സംഭവങ്ങൾ സൃഷ്ടിക്കാത്തതിനാൽ അവ കൺസ്ട്രക്റ്റർ ഫംഗ്‌ഷനുകൾക്ക് അനുയോജ്യമല്ല.
13. എന്തിനുവേണ്ടിയുള്ള ചില വിപുലമായ ഉപയോഗ കേസുകൾ call() ഒപ്പം apply()?
14. രീതി കടമെടുക്കുന്നതിനും വൈവിധ്യമാർന്ന പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനും അവ ഉപയോഗപ്രദമാണ്.
15. എങ്ങിനെയാണ് call() കോഡ് റീഡബിലിറ്റി മെച്ചപ്പെടുത്തണോ?
16. call() ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം അറിയുകയും സ്ഥിരപ്പെടുകയും ചെയ്യുമ്പോൾ ഫംഗ്‌ഷൻ ഇൻവോക്കേഷൻ വ്യക്തമാക്കുന്നു.
17. കഴിയും apply() ഒരു അജ്ഞാതമായ ആർഗ്യുമെൻ്റുകൾ കൈകാര്യം ചെയ്യണോ?
18. അതെ, apply() ഒരു വേരിയബിൾ എണ്ണം ആർഗ്യുമെൻ്റുകൾ കൈകാര്യം ചെയ്യേണ്ട ഫംഗ്ഷനുകൾക്ക് അനുയോജ്യമാണ്.

ഫംഗ്ഷൻ ഇൻവോക്കേഷൻ രീതികളെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ

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