JavaScript ನಲ್ಲಿ `ಕರೆ` ಮತ್ತು `ಅನ್ವಯಿಸು` ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕಾರ್ಯ ಆಹ್ವಾನ ವಿಧಾನಗಳು

JavaScript ಕಾರ್ಯಗಳನ್ನು ಆಹ್ವಾನಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅವುಗಳಲ್ಲಿ ಎರಡು `Function.prototype.call()` ಮತ್ತು `Function.prototype.apply()`. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ `ಈ` ಮೌಲ್ಯ ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಕಾರ್ಯಗಳನ್ನು ಕರೆಯಲು ಎರಡೂ ವಿಧಾನಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಆದರೆ ಈ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಹೇಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಅವು ಭಿನ್ನವಾಗಿರುತ್ತವೆ.

ಈ ಲೇಖನವು `ಕರೆ` ಮತ್ತು `ಅನ್ವಯಿಸು` ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು, ಅವುಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳು ಮತ್ತು ಒಂದು ಇನ್ನೊಂದಕ್ಕಿಂತ ಆದ್ಯತೆ ನೀಡಬಹುದಾದ ಸನ್ನಿವೇಶಗಳನ್ನು ಅನ್ವೇಷಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ. ಅಂತ್ಯದ ವೇಳೆಗೆ, ನಿಮ್ಮ 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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ `ಕರೆ` ವಿರುದ್ಧ `ಅನ್ವಯಿಸು` ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮುಂಭಾಗದ ಉದಾಹರಣೆ

// 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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಫಂಕ್ಷನ್ ಆಹ್ವಾನಕ್ಕಾಗಿ `ಕರೆ` ಮತ್ತು `ಅನ್ವಯಿಸು` ಹೋಲಿಸಲಾಗುತ್ತಿದೆ

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');

ಕರೆಗೆ ಆಳವಾದ ಒಳನೋಟ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವಿಧಾನಗಳನ್ನು ಅನ್ವಯಿಸಿ

ಅವುಗಳ ಮೂಲ ಬಳಕೆಯ ಜೊತೆಗೆ, Function.prototype.call() ಮತ್ತು Function.prototype.apply() ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ವರ್ಧಿಸುವ ಹಲವಾರು ಸುಧಾರಿತ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಹೊಂದಿರಿ. ಅಂತಹ ಒಂದು ಬಳಕೆಯ ಸಂದರ್ಭವೆಂದರೆ ವಿಧಾನ ಎರವಲು, ಅಲ್ಲಿ ಒಂದು ವಸ್ತುವಿನಿಂದ ವಿಧಾನಗಳನ್ನು ಇನ್ನೊಂದರಿಂದ ಎರವಲು ಪಡೆಯಲಾಗುತ್ತದೆ. ನೀವು ಆನುವಂಶಿಕತೆ ಇಲ್ಲದೆ ಮತ್ತೊಂದು ವಸ್ತುವಿನಿಂದ ವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾದ ವಸ್ತುವನ್ನು ಹೊಂದಿರುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಬಳಸಿ call() ಮತ್ತು apply(), ನೀವು ತಾತ್ಕಾಲಿಕವಾಗಿ ವಿಧಾನಗಳನ್ನು ಎರವಲು ಪಡೆಯಬಹುದು ಮತ್ತು ವಿವಿಧ ವಸ್ತುಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಇದರಿಂದಾಗಿ ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು ಮತ್ತು ಪುನರುಜ್ಜೀವನವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು.

ಪರಿಗಣಿಸಬೇಕಾದ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಬಳಕೆ apply() ವಿವಿಧ ಕಾರ್ಯಗಳಿಗಾಗಿ - ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಕಾರ್ಯಗಳು. ನೀವು ವಾದಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವಾಗ ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ರಚನೆಯನ್ನು ಸ್ವೀಕರಿಸದ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಬೇಕಾದಾಗ, apply() ಅತ್ಯಂತ ಸೂಕ್ತವಾಗುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, call() ಕಾರ್ಯಕ್ಷಮತೆ ನಿರ್ಣಾಯಕವಾಗಿರುವ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಬಹುದು, ಮತ್ತು ವಾದಗಳ ಸಂಖ್ಯೆ ತಿಳಿದಿರುತ್ತದೆ ಮತ್ತು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಈ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಯಾವಾಗ ಬಳಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚು ತಿಳುವಳಿಕೆಯುಳ್ಳ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು call() ವಿರುದ್ಧ apply(), ಓದುವಿಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಎರಡಕ್ಕೂ ಅವರ ಕೋಡ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕರೆ ಮತ್ತು ಅನ್ವಯಿಸುವ ಕುರಿತು ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

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 ವಿಧಾನಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾರ್ಯಗಳನ್ನು ಆಹ್ವಾನಿಸಲು ಪ್ರಬಲ ಸಾಧನಗಳಾಗಿವೆ this ಮೌಲ್ಯ. ಅವುಗಳ ನಡುವಿನ ಆಯ್ಕೆಯು ನೀವು ಕಾರ್ಯಕ್ಕೆ ವಾದಗಳನ್ನು ಹೇಗೆ ರವಾನಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂಬುದರ ಮೇಲೆ ಹೆಚ್ಚಾಗಿ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಹಾಗೆಯೇ call ಸ್ಥಿರ ಸಂಖ್ಯೆಯ ವಾದಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಉತ್ತಮವಾಗಿದೆ, apply ಅರೇಗಳು ಅಥವಾ ಅಜ್ಞಾತ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಹೊಳೆಯುತ್ತದೆ. ಈ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಓದಬಲ್ಲ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಅಂತಿಮವಾಗಿ ಉತ್ತಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅಭ್ಯಾಸಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.