Prototype

ஒவ்வொரு பொருளும் ஒரு prototype பொருளுடன் இணைக்கப்பட்டுள்ளது, அதிலிருந்து பண்புகளைப் பெறுகிறது. Object literals ({}) இலிருந்து உருவாக்கப்பட்ட பொருள்கள் தானாகவே Object.prototype உடன் இணைக்கப்படுகின்றன, இது ஜாவாஸ்கிரிப்டுடன் தரநிலையாக வரும் ஒரு பொருளாகும்.

பின்வரும் குறியீட்டில் உள்ளதைப் போல, நீங்கள் மீட்டெடுக்க விரும்பும் ஒரு பண்பைக் கண்டறிய ஜாவாஸ்கிரிப்ட் மொழிபெயர்ப்பாளர் (உங்கள் உலாவியில் உள்ள ஒரு தொகுதி) முயற்சிக்கும்போது:

let adult = { age: 26 },
  retrievedProperty = adult.age;
// மேலே உள்ள வரி

முதலில், மொழிபெயர்ப்பாளர் பொருள் கொண்ட ஒவ்வொரு பண்பையும் பார்க்கிறார். எடுத்துக்காட்டாக, adult க்கு ஒரே ஒரு சொந்த பண்பு மட்டுமே உள்ளது—age. இருப்பினும், இது Object.prototype இலிருந்து பெறப்பட்ட பல பண்புகளையும் கொண்டுள்ளது.

let stringRepresentation = adult.toString();
// மாறியில் '[object Object]' என்ற மதிப்பு உள்ளது

toString என்பது Object.prototype இன் பண்பாகும், இது பெறப்பட்டது. இது ஒரு செயல்பாட்டின் மதிப்பைக் கொண்டுள்ளது, இது பொருளின் சரம் பிரதிநிதித்துவத்தைத் திரும்பப் பெறுகிறது. இது மிகவும் அர்த்தமுள்ள பிரதிநிதித்துவத்தைத் திரும்பப் பெற விரும்பினால், நீங்கள் அதை மேலெழுதலாம் (override). adult பொருளுக்கு ஒரு புதிய பண்பைச் சேர்க்கவும்.

adult.toString = function () {
  return "நான் " + this.age;
};

இப்போது நீங்கள் toString செயல்பாட்டை அழைத்தால், மொழிபெயர்ப்பாளர் பொருளில் புதிய பண்பைக் கண்டுபிடித்து நிறுத்திவிடுவார்.

எனவே மொழிபெயர்ப்பாளர் பொருளிலிருந்து மேலும் அதன் prototype மூலமாகவும் வழியில் கண்டுபிடிக்கும் முதல் பண்பை மீட்டெடுக்கிறார்.

இயல்புநிலை Object.prototype க்குப் பதிலாக உங்கள் சொந்த பொருளை ஒரு prototype ஆக அமைக்க, நீங்கள் பின்வருமாறு Object.create ஐ அழைக்கலாம்:

let child = Object.create(adult);

/* இந்த முறையில் பொருள்களை உருவாக்குவது, நாம் விரும்பும் இயல்புநிலை Object.prototype ஐ எளிதாக மாற்ற அனுமதிக்கிறது. இந்த வழக்கில், child இன் prototype adult பொருளாகும். */

child.age = 8;

/* முன்னதாக, child க்கு அதன் சொந்த age பண்பு இல்லை, மேலும் அதை கண்டுபிடிக்க மொழிபெயர்ப்பாளர் child இன் prototype க்கு மேலும் பார்க்க வேண்டியிருந்தது.
 இப்போது, child இன் சொந்த வயதை அமைக்கும்போது, மொழிபெயர்ப்பாளர் மேலும் செல்ல மாட்டார்.
 குறிப்பு: adult இன் வயது இன்னும் 26 ஆக உள்ளது. */

let stringRepresentation = child.toString();

// மதிப்பு "நான் 8".
/* குறிப்பு: child இன் toString பண்பை நாங்கள் மேலெழுதவில்லை, இதனால் adult இன் முறை அழைக்கப்படும். adult க்கு toString பண்பு இல்லை என்றால், Object.prototype இன் toString முறை அழைக்கப்படும், மேலும் "நான் 8" என்பதற்குப் பதிலாக "[object Object]" கிடைக்கும் */

child இன் prototype adult ஆகும், அதன் prototype Object.prototype ஆகும். prototype களின் இந்த வரிசை prototype chain என்று அழைக்கப்படுகிறது.