$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?>$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?>$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?> ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਲ

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਲ ਅਤੇ ਅਪਲਾਈ ਕਰਨ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਲ ਅਤੇ ਅਪਲਾਈ ਕਰਨ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ
ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਲ ਅਤੇ ਅਪਲਾਈ ਕਰਨ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ
Arthur Petit
ਬੁੱਧਵਾਰ, 26 ਜੂਨ 2024 4:12:59 ਬਾ.ਦੁ.

JavaScript ਵਿੱਚ ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨ ਵਿਧੀਆਂ

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

Node.js ਬੈਕਐਂਡ ਉਦਾਹਰਨ ਵਿੱਚ, call() ਵਿਧੀ ਨਾਲ ਬਣਾਏ ਗਏ HTTP ਸਰਵਰ ਦੇ ਅੰਦਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ http.createServer(). ਇਹ ਉਦਾਹਰਨ ਦੱਸਦੀ ਹੈ ਕਿ ਕਿਵੇਂ this ਸੰਦਰਭ ਨੂੰ HTTP ਬੇਨਤੀਆਂ ਦਾ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਜਵਾਬ ਦੇਣ ਲਈ ਸਰਵਰ-ਸਾਈਡ JavaScript ਵਿੱਚ ਹੇਰਾਫੇਰੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਸਰਵਰ ਇੱਕ ਨਮਸਕਾਰ ਦੇ ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ call() ਵਿਧੀ ਦੇ ਸੰਦਰਭ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ greet ਫੰਕਸ਼ਨ. ਅੰਤ ਵਿੱਚ, ਸੰਯੁਕਤ ਫਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਦੋਵੇਂ ਕਿਵੇਂ ਹਨ call() ਅਤੇ apply() ਇੱਕ ਹੋਰ ਗਤੀਸ਼ੀਲ ਫੰਕਸ਼ਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਵਰਤ ਕੇ call() ਵਿਅਕਤੀਗਤ ਦਲੀਲਾਂ ਦੇ ਨਾਲ ਅਤੇ apply() ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਲੜੀ ਦੇ ਨਾਲ, ਸਕ੍ਰਿਪਟ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਉਪਭੋਗਤਾ ਵੇਰਵੇ ਤਿਆਰ ਕਰਦੀ ਹੈ, ਕਲਾਇੰਟ-ਸਾਈਡ ਅਤੇ ਸਰਵਰ-ਸਾਈਡ JavaScript ਵਿਕਾਸ ਦੋਵਾਂ ਵਿੱਚ ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਦੇ ਵਿਹਾਰਕ ਕਾਰਜਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨ ਲਈ 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 person2
console.log(person.fullName.call(person1)); // Output: John Doe
console.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 person2
console.log(person.fullName.apply(person1, ["New York", "USA"])); // Output: John Doe, New York, USA
console.log(person.fullName.apply(person2, ["London", "UK"])); // Output: Jane Smith, London, UK

Node.js ਬੈਕਐਂਡ ਉਦਾਹਰਨ ਕਾਲ ਕਰੋ ਅਤੇ ਲਾਗੂ ਕਰੋ

Node.js ਨਾਲ JavaScript ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ

// Load the required modules
const http = require('http');
// Create a server object
http.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 Alice
    res.end();
}).listen(3000);
console.log('Server running at http://localhost:3000/');

ਇੱਕ ਡਾਇਨਾਮਿਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕਾਲ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਲਾਗੂ ਕਰਨਾ

JavaScript ਪੂਰੀ ਸਟੈਕ ਸਕ੍ਰਿਪਟ

// Define a function to display user details
function displayDetails(age, profession) {
    return this.name + " is " + age + " years old and works as a " + profession + ".";
}
// User objects
const user1 = { name: 'Bob' };
const user2 = { name: 'Alice' };
// Use call to invoke displayDetails
console.log(displayDetails.call(user1, 30, 'Engineer')); // Output: Bob is 30 years old and works as a Engineer.
// Use apply to invoke displayDetails
console.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 ਵਿੱਚ ਕਾਲ ਕਰਨ ਅਤੇ ਅਪਲਾਈ ਕਰਨ ਬਾਰੇ ਆਮ ਸਵਾਲ

  1. ਵਿਚਕਾਰ ਮੁੱਖ ਅੰਤਰ ਕੀ ਹੈ call() ਅਤੇ apply()?
  2. ਮੁੱਖ ਅੰਤਰ ਇਹ ਹੈ ਕਿ call() ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਜਦਕਿ apply() ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਲੜੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।
  3. ਤੁਹਾਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ apply() ਵੱਧ call()?
  4. ਤੁਹਾਨੂੰ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ apply() ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਲੜੀ ਹੁੰਦੀ ਹੈ ਜਾਂ ਕਿਸੇ ਫੰਕਸ਼ਨ ਲਈ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਸੰਖਿਆ ਨੂੰ ਪਾਸ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
  5. ਵਿਚਕਾਰ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਅੰਤਰ ਹਨ call() ਅਤੇ apply()?
  6. ਆਮ ਤੌਰ 'ਤੇ, ਵਿਚਕਾਰ ਕੋਈ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਦਰਸ਼ਨ ਅੰਤਰ ਨਹੀਂ ਹਨ call() ਅਤੇ apply(). ਕੋਈ ਵੀ ਅੰਤਰ ਆਮ ਤੌਰ 'ਤੇ ਮਾਮੂਲੀ ਹੁੰਦੇ ਹਨ।
  7. ਸਕਦਾ ਹੈ apply() ਗਣਿਤ ਦੇ ਢੰਗ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ?
  8. ਹਾਂ, apply() ਗਣਿਤ ਦੇ ਤਰੀਕਿਆਂ ਜਿਵੇਂ ਕਿ ਨੰਬਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ Math.max() ਜਾਂ Math.min().
  9. ਕੀ ਹੈ Function.prototype.bind()?
  10. bind() ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸਨੂੰ ਜਦੋਂ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਦਾ ਹੁੰਦਾ ਹੈ this ਕੀਵਰਡ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਜਦੋਂ ਨਵਾਂ ਫੰਕਸ਼ਨ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਆਰਗੂਮੈਂਟ ਤੋਂ ਪਹਿਲਾਂ ਦਿੱਤੇ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਦਿੱਤੇ ਕ੍ਰਮ ਦੇ ਨਾਲ।
  11. ਕਿਵੇ ਹੋ ਸਕਦਾ ਹੈ call() ਤਰੀਕਿਆਂ ਨੂੰ ਉਧਾਰ ਲੈਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ?
  12. ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ call() ਇੱਕ ਵਸਤੂ ਤੋਂ ਵਿਧੀਆਂ ਉਧਾਰ ਲੈਣ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਹੋਰ ਵਸਤੂ 'ਤੇ ਵਰਤਣ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਨਕਲ ਕੀਤੇ ਬਿਨਾਂ ਵਿਧੀ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹੋਏ।
  13. ਇਸ ਨੂੰ ਵਰਤਣ ਲਈ ਸੰਭਵ ਹੈ call() ਜਾਂ apply() ਕੰਸਟਰਕਟਰਾਂ ਨਾਲ?
  14. ਨਹੀਂ, ਕੰਸਟਰਕਟਰਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਬੁਲਾਇਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ call() ਜਾਂ apply(). ਇਸ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ Object.create() ਵਿਰਾਸਤੀ ਪੈਟਰਨ ਲਈ.
  15. ਐਰੇ ਵਰਗੀਆਂ ਵਸਤੂਆਂ ਕੀ ਹਨ, ਅਤੇ ਕਿਵੇਂ ਕਰਦੀਆਂ ਹਨ call() ਅਤੇ apply() ਉਹਨਾਂ ਨਾਲ ਕੰਮ ਕਰੋ?
  16. ਐਰੇ ਵਰਗੀਆਂ ਵਸਤੂਆਂ ਉਹ ਵਸਤੂਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀ ਲੰਬਾਈ ਵਿਸ਼ੇਸ਼ਤਾ ਅਤੇ ਸੂਚੀਬੱਧ ਤੱਤ ਹੁੰਦੇ ਹਨ। call() ਅਤੇ apply() ਇਹਨਾਂ ਆਬਜੈਕਟਸ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਉਹ ਐਰੇ ਸਨ।

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਲ ਅਤੇ ਅਪਲਾਈ ਦੀ ਵਰਤੋਂ ਦਾ ਸਾਰ ਦੇਣਾ

JavaScript ਵਿੱਚ, call() ਅਤੇ apply() ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹਨ this ਫੰਕਸ਼ਨਾਂ ਦੇ ਅੰਦਰ ਪ੍ਰਸੰਗ. call() ਵਿਅਕਤੀਗਤ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇਸ ਨੂੰ ਜਾਣੇ-ਪਛਾਣੇ ਅਤੇ ਸਥਿਰ ਆਰਗੂਮੈਂਟਾਂ ਲਈ ਢੁਕਵਾਂ ਬਣਾਉਂਦਾ ਹੈ। ਟਾਕਰੇ ਵਿੱਚ, apply() ਪਰਿਵਰਤਨਸ਼ੀਲ ਆਰਗੂਮੈਂਟ ਸੂਚੀਆਂ ਲਈ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋਏ, ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਲੜੀ ਲੈਂਦਾ ਹੈ। ਦੋਵੇਂ ਵਿਧੀਆਂ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂਯੋਗਤਾ ਅਤੇ ਡਾਇਨਾਮਿਕ ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨ ਨੂੰ ਵਧਾਉਂਦੀਆਂ ਹਨ, ਭਾਵੇਂ ਫਰੰਟਐਂਡ ਵਿਕਾਸ ਜਾਂ Node.js ਵਾਤਾਵਰਣ ਵਿੱਚ। ਸਾਫ਼, ਕੁਸ਼ਲ JavaScript ਕੋਡ ਲਿਖਣ ਲਈ ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਵਰਤਣਾ ਹੈ ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।