à²à²¨à²¦à³ Function.prototype.bind()?

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ

Arthur Petit

ಬುಧವಾರ, ಜೂನ್ 26, 2024 03:40:03 ಅಪರಾಹ್ನ

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಕಾರ್ಯಗಳನ್ನು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಆಹ್ವಾನಿಸಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಎರಡು ವಿಧಾನಗಳು `ಕರೆ` ಮತ್ತು `ಅನ್ವಯಿಸು`. ಈ ವಿಧಾನಗಳು ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂದರ್ಭವನ್ನು (`ಈ` ಮೌಲ್ಯ) ನಿಯಂತ್ರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸಮರ್ಥ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಬರೆಯಲು `ಕರೆ` ಮತ್ತು `ಅನ್ವಯಿಸು` ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.

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

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

ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಬಳಕೆಯ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸುತ್ತದೆ 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() ವಾದಗಳ ಒಂದು ಶ್ರೇಣಿಯೊಂದಿಗೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬಳಕೆದಾರರ ವಿವರಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಕ್ಲೈಂಟ್-ಸೈಡ್ ಮತ್ತು ಸರ್ವರ್-ಸೈಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಈ ವಿಧಾನಗಳ ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ.

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

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

// 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() ಅನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತಿದೆ

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

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

ಕರೆಯನ್ನು ಸಂಯೋಜಿಸುವುದು ಮತ್ತು ಡೈನಾಮಿಕ್ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಅನ್ವಯಿಸುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫುಲ್ ಸ್ಟಾಕ್ ಸ್ಕ್ರಿಪ್ಟ್

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

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

ಮೂಲಭೂತ ಬಳಕೆಯನ್ನು ಮೀರಿ call() ಮತ್ತು apply(), ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಮತ್ತು ಶಕ್ತಿಯುತವಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಈ ವಿಧಾನಗಳನ್ನು ಇತರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಅವುಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಜೊತೆಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ bind(), ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೊಸ ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ this ಮೌಲ್ಯ. ಭಿನ್ನವಾಗಿ call() ಮತ್ತು apply(), ಇದು ತಕ್ಷಣವೇ ಕಾರ್ಯವನ್ನು ಆಹ್ವಾನಿಸುತ್ತದೆ, bind() ಒಂದು ಬೌಂಡ್ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸಲು ಬಳಸಬಹುದು ಅದನ್ನು ನಂತರ ಸ್ಥಿರವಾದ ಸಂದರ್ಭದೊಂದಿಗೆ ಕರೆಯಬಹುದು. ಈವೆಂಟ್ ನಿರ್ವಹಣೆಯಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ನೀವು ಕಾರ್ಯವು ವಿಭಿನ್ನ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗಲೂ ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿನ ಸಂದರ್ಭವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸಬಹುದು.

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

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

ನಡುವಿನ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೇನು 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() ಈ ವಸ್ತುಗಳನ್ನು ಅರೇಗಳಂತೆ ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಬಳಸಬಹುದು.

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

JavaScript ನಲ್ಲಿ, call() ಮತ್ತು apply() ನಿಯಂತ್ರಿಸಲು ಅತ್ಯಗತ್ಯ this ಕಾರ್ಯಗಳ ಒಳಗೆ ಸಂದರ್ಭ. call() ವೈಯಕ್ತಿಕ ವಾದಗಳನ್ನು ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ತಿಳಿದಿರುವ ಮತ್ತು ಸ್ಥಿರವಾದ ವಾದಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, apply() ವಾದಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ವೇರಿಯಬಲ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪಟ್ಟಿಗಳಿಗೆ ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮುಂಭಾಗದ ಅಭಿವೃದ್ಧಿ ಅಥವಾ Node.js ಪರಿಸರದಲ್ಲಿ ಎರಡೂ ವಿಧಾನಗಳು ಕೋಡ್ ಮರುಬಳಕೆ ಮತ್ತು ಡೈನಾಮಿಕ್ ಕಾರ್ಯದ ಆಹ್ವಾನವನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ. ಈ ವಿಧಾನಗಳನ್ನು ಯಾವಾಗ ಮತ್ತು ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಶುದ್ಧ, ಸಮರ್ಥ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಮುಖ್ಯವಾಗಿದೆ.

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