à°à°®à°¿à°à°¿ Function.prototype.bind()?

జావాస్క్రిప్ట్‌లో

Arthur Petit

26, జూన్ 2024, బుధవారం 4:36:06 PMకి

జావాస్క్రిప్ట్‌లో ఫంక్షన్ ఆహ్వాన పద్ధతులు

జావాస్క్రిప్ట్‌లో, ఫంక్షన్‌లను వివిధ మార్గాల్లో అమలు చేయవచ్చు మరియు సాధారణంగా ఉపయోగించే రెండు పద్ధతులు `కాల్` మరియు `అప్లై`. ఈ పద్ధతులు ఫంక్షన్‌ని అమలు చేసే సందర్భాన్ని (`ఈ` విలువ) నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తాయి. సమర్థవంతమైన మరియు ప్రభావవంతమైన జావాస్క్రిప్ట్ కోడ్‌ను వ్రాయడానికి `కాల్` మరియు `వర్తించు` మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం.

ఈ కథనం ఒక ఫంక్షన్‌ను ప్రారంభించేటప్పుడు `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() జావాస్క్రిప్ట్‌లో. రెండు పద్ధతులు పేర్కొన్న ఫంక్షన్‌లను అమలు చేయడానికి ఉపయోగించబడతాయి this సందర్భం. మొదటి ఉదాహరణలో, ది call() పిలవడానికి పద్ధతి ఉపయోగించబడుతుంది fullName వివిధ వస్తువులపై పద్ధతి (person1 మరియు person2), ప్రతి వస్తువు యొక్క లక్షణాలను వ్యక్తిగత వాదనలుగా పాస్ చేయడం. ఆర్గ్యుమెంట్‌ల సంఖ్య తెలిసినప్పుడు మరియు స్థిరంగా ఉన్నప్పుడు ఈ పద్ధతి సంక్షిప్త వాక్యనిర్మాణాన్ని అనుమతిస్తుంది. రెండవ ఉదాహరణ యొక్క ఉపయోగాన్ని ప్రదర్శిస్తుంది apply() పద్ధతి, ఇది పోలి ఉంటుంది call() కానీ వ్యక్తిగత వాటికి బదులుగా వాదనల శ్రేణిని తీసుకుంటుంది. ఆర్గ్యుమెంట్‌ల సంఖ్య వేరియబుల్‌గా ఉన్నప్పుడు లేదా శ్రేణి మూలం నుండి వచ్చినప్పుడు ఈ సౌలభ్యం ప్రత్యేకంగా ఉపయోగపడుతుంది.

Node.js బ్యాకెండ్ ఉదాహరణలో, ది call() తో సృష్టించబడిన HTTP సర్వర్‌లో పద్ధతి ఉపయోగించబడుతుంది http.createServer(). ఈ ఉదాహరణ ఎలా హైలైట్ చేస్తుంది this HTTP అభ్యర్థనలకు డైనమిక్‌గా ప్రతిస్పందించడానికి సర్వర్-సైడ్ జావాస్క్రిప్ట్‌లో సందర్భాన్ని మార్చవచ్చు. సర్వర్ గ్రీటింగ్‌తో ప్రతిస్పందిస్తుంది, ఎలా ఉంటుందో ప్రదర్శిస్తుంది call() పద్ధతి యొక్క సందర్భాన్ని మార్చవచ్చు greet ఫంక్షన్. చివరగా, మిళిత ఫ్రంటెండ్ మరియు బ్యాకెండ్ ఉదాహరణ రెండింటినీ ఎలా చూపుతుంది call() మరియు apply() మరింత డైనమిక్ ఫంక్షన్‌లో ఉపయోగించవచ్చు. ఉపయోగించడం ద్వార call() వ్యక్తిగత వాదనలతో మరియు apply() ఆర్గ్యుమెంట్‌ల శ్రేణితో, స్క్రిప్ట్ డైనమిక్‌గా వినియోగదారు వివరాలను ఉత్పత్తి చేస్తుంది, క్లయింట్ వైపు మరియు సర్వర్ వైపు 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()ని వర్తింపజేయడం

జావాస్క్రిప్ట్ ఫ్రంటెండ్ స్క్రిప్ట్

// 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తో జావాస్క్రిప్ట్ బ్యాకెండ్ స్క్రిప్ట్

// 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() ఈ వస్తువులను శ్రేణుల వలె మార్చడానికి ఉపయోగించవచ్చు.

జావాస్క్రిప్ట్‌లో కాల్ మరియు దరఖాస్తు యొక్క వినియోగాన్ని సంగ్రహించడం

జావాస్క్రిప్ట్‌లో, call() మరియు apply() నియంత్రించడానికి అవసరం this ఫంక్షన్లలోని సందర్భం. call() వ్యక్తిగత ఆర్గ్యుమెంట్‌లను ఆమోదించడానికి అనుమతిస్తుంది, ఇది తెలిసిన మరియు స్థిర ఆర్గ్యుమెంట్‌లకు అనుకూలంగా ఉంటుంది. దీనికి విరుద్ధంగా, apply() ఆర్గ్యుమెంట్‌ల శ్రేణిని తీసుకుంటుంది, వేరియబుల్ ఆర్గ్యుమెంట్ జాబితాలకు వశ్యతను అందిస్తుంది. ఫ్రంటెండ్ డెవలప్‌మెంట్ లేదా Node.js ఎన్విరాన్‌మెంట్‌లలో రెండు పద్ధతులు కోడ్ పునర్వినియోగం మరియు డైనమిక్ ఫంక్షన్ ఆహ్వానాన్ని మెరుగుపరుస్తాయి. శుభ్రమైన, సమర్థవంతమైన జావాస్క్రిప్ట్ కోడ్‌ను వ్రాయడానికి ఈ పద్ధతులను ఎప్పుడు మరియు ఎలా సమర్థవంతంగా ఉపయోగించాలో అర్థం చేసుకోవడం చాలా ముఖ్యం.

జావాస్క్రిప్ట్‌లో కాల్ మరియు దరఖాస్తు మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం