$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?> ஜாவாஸ்கிரிப்டில்

ஜாவாஸ்கிரிப்டில் அழைப்பிற்கும் விண்ணப்பத்திற்கும் உள்ள வித்தியாசத்தைப் புரிந்துகொள்வது

ஜாவாஸ்கிரிப்டில் அழைப்பிற்கும் விண்ணப்பத்திற்கும் உள்ள வித்தியாசத்தைப் புரிந்துகொள்வது
ஜாவாஸ்கிரிப்டில் அழைப்பிற்கும் விண்ணப்பத்திற்கும் உள்ள வித்தியாசத்தைப் புரிந்துகொள்வது
Arthur Petit
புதன், 26 ஜூன், 2024 ’அன்று’ பிற்பகல் 4:39:24

ஜாவாஸ்கிரிப்டில் செயல்பாடு அழைப்பு முறைகள்

ஜாவாஸ்கிரிப்டில், செயல்பாடுகளை பல்வேறு வழிகளில் செயல்படுத்தலாம், மேலும் பொதுவாகப் பயன்படுத்தப்படும் இரண்டு முறைகள் `அழைப்பு` மற்றும் `விண்ணப்பிக்கவும்`. இந்த முறைகள் செயல்பாடு செயல்படுத்தப்படும் சூழலை (`இந்த` மதிப்பு) கட்டுப்படுத்த உங்களை அனுமதிக்கிறது. திறமையான மற்றும் பயனுள்ள ஜாவாஸ்கிரிப்ட் குறியீட்டை எழுதுவதற்கு `அழைப்பு` மற்றும் `விண்ணப்பித்தல்` ஆகியவற்றுக்கு இடையேயான வித்தியாசத்தைப் புரிந்துகொள்வது முக்கியம்.

இந்த கட்டுரை ஒரு செயல்பாட்டை செயல்படுத்தும்போது `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() வாதங்களின் வரிசையுடன், ஸ்கிரிப்ட் மாறும் வகையில் பயனர் விவரங்களை உருவாக்குகிறது, கிளையன்ட் பக்க மற்றும் சர்வர் பக்க ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் இந்த முறைகளின் நடைமுறை பயன்பாடுகளை விளக்குகிறது.

செயல்பாட்டு அழைப்பிற்காக ஜாவாஸ்கிரிப்டில் அழைப்பு மற்றும் முறைகளைப் பயன்படுத்துதல்

ஜாவாஸ்கிரிப்ட் ஃப்ரென்ட் ஸ்கிரிப்ட்

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

JavaScript இல் சூழல் கையாளுதலை ஆராய்தல்

அடிப்படை பயன்பாட்டிற்கு அப்பால் call() மற்றும் apply(), இந்த முறைகள் மற்ற ஜாவாஸ்கிரிப்ட் அம்சங்களுடன் இணைந்து மிகவும் சிக்கலான மற்றும் சக்திவாய்ந்த குறியீட்டை உருவாக்கலாம். உதாரணமாக, அவை பெரும்பாலும் இணைந்து பயன்படுத்தப்படுகின்றன bind(), இது குறிப்பிட்ட ஒரு புதிய செயல்பாட்டை வழங்குகிறது this மதிப்பு. போலல்லாமல் call() மற்றும் apply(), இது உடனடியாக செயல்பாட்டைத் தூண்டுகிறது, bind() ஒரு கட்டுப்பட்ட செயல்பாட்டை உருவாக்கப் பயன்படுத்தலாம், அது ஒரு நிலையான சூழலுடன் பின்னர் அழைக்கப்படலாம். நிகழ்வு கையாளுதலில் இது மிகவும் பயனுள்ளதாக இருக்கும், அங்கு ஒரு செயல்பாடு வெவ்வேறு சூழல்களில் செயல்படுத்தப்படும்போதும் ஒரு குறிப்பிட்ட பொருளின் சூழலைத் தக்கவைத்துக்கொள்வதை உறுதிசெய்ய வேண்டும்.

மற்றொரு மேம்பட்ட பயன்பாட்டு வழக்கு ஒரு பொருளில் இருந்து மற்றொன்றுடன் பயன்படுத்துவதற்கான கடன் முறைகளை உள்ளடக்கியது. இதைப் பயன்படுத்துவதன் மூலம் அடையலாம் call() அல்லது apply() ஒரு முறையை வேறு பொருளுடன் தற்காலிகமாக பிணைப்பது. எடுத்துக்காட்டாக, வரிசை முறைகள் போன்றவை slice() அல்லது push() செயல்பாடுகளில் உள்ள வாதங்கள் பொருள் போன்ற வரிசை போன்ற பொருள்களுக்கு கடன் வாங்கி பயன்படுத்தலாம். இந்த நுட்பம் குறியீட்டின் அதிக நெகிழ்வுத்தன்மை மற்றும் மறுபயன்பாடு ஆகியவற்றை அனுமதிக்கிறது, ஏனெனில் இது நகல் இல்லாமல் வெவ்வேறு பொருள்களில் முறைகளைப் பகிர உதவுகிறது.

ஜாவாஸ்கிரிப்டில் அழைப்பு மற்றும் விண்ணப்பம் பற்றிய பொதுவான கேள்விகள்

  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() இந்த பொருட்களை வரிசைகள் போல கையாள பயன்படுத்தப்படலாம்.

ஜாவாஸ்கிரிப்டில் அழைப்பின் பயன்பாட்டைச் சுருக்கவும் மற்றும் விண்ணப்பிக்கவும்

ஜாவாஸ்கிரிப்டில், call() மற்றும் apply() கட்டுப்படுத்துவதற்கு அவசியம் this செயல்பாடுகளுக்குள் சூழல். call() தனிப்பட்ட வாதங்களை அனுப்ப அனுமதிக்கிறது, இது அறியப்பட்ட மற்றும் நிலையான வாதங்களுக்கு ஏற்றதாக அமைகிறது. மாறாக, apply() வாதங்களின் வரிசையை எடுத்து, மாறி வாதப் பட்டியல்களுக்கு நெகிழ்வுத்தன்மையை வழங்குகிறது. முன்னோட்ட மேம்பாடு அல்லது Node.js சூழல்களில் இரண்டு முறைகளும் குறியீடு மறுபயன்பாடு மற்றும் டைனமிக் செயல்பாடு அழைப்பை மேம்படுத்துகின்றன. சுத்தமான, திறமையான ஜாவாஸ்கிரிப்ட் குறியீட்டை எழுதுவதற்கு, இந்த முறைகளை எப்போது, ​​எப்படி திறம்பட பயன்படுத்த வேண்டும் என்பதைப் புரிந்துகொள்வது முக்கியம்.