JavaScript ਵਿੱਚ `ਕਾਲ` ਅਤੇ `ਲਾਗੂ` ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ

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 ਵਿੱਚ `ਕਾਲ` ਬਨਾਮ `ਲਾਗੂ` ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਸਮਝਣਾ

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 ਵਿਕਾਸ ਵਿੱਚ `ਕਾਲ` ਅਤੇ `ਲਾਗੂ` ਵਿਚਕਾਰ ਚੋਣ ਕਰਨਾ

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 ਵਿਧੀਆਂ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ ਨਿਸ਼ਚਿਤ ਨਾਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬੁਲਾਉਣ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ ਹਨ this ਮੁੱਲ। ਉਹਨਾਂ ਵਿਚਕਾਰ ਚੋਣ ਬਹੁਤ ਹੱਦ ਤੱਕ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟਸ ਕਿਵੇਂ ਪਾਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਜਦਕਿ call ਦਲੀਲਾਂ ਦੀ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ, apply ਐਰੇ ਜਾਂ ਅਣਜਾਣ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਚਮਕਦਾ ਹੈ। ਇਹਨਾਂ ਸੂਖਮਤਾਵਾਂ ਨੂੰ ਸਮਝਣਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਕੋਡ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਅੰਤ ਵਿੱਚ ਬਿਹਤਰ JavaScript ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਭਿਆਸਾਂ ਵੱਲ ਅਗਵਾਈ ਕਰਦਾ ਹੈ।