Object.create எனும் வழிமுறையைப் பயன்படுத்துதல்
Object.create() எனும் வழிமுறையைப் பயன்படுத்தியும் பொருட்களை உருவாக்கலாம். இந்த வழிமுறை மிகவும் பயனுள்ளதாக இருக்கும், ஏனென்றால் இது ஒரு கட்டமைப்பாளர் எனும் செயலியை வரையறுக்காமல் நாம்உருவாக்க விரும்பும் பொருளின் முன்மாதிரி பொருளைத் தேர்வுசெய்ய இது நம்மை அனுமதிக்கிறது, .
// விலங்குகளின் பண்பியல்புகளும் இணைத்தல் வழிமுறையும்
const Animal = {
type: ‘Invertebrates’, // பண்புகளின் இயல்புநிலை மதிப்பு
displayType: function() { // விலங்கின் வகையைக் காண்பிக்கும் வழிமுறை
console.log(this.type);
}
};
// animal1 எனப்படும் புதிய விலங்கின் வகையை உருவாக்கிடுக
const animal1 = Object.create(Animal);
animal1.displayType(); // வெளியீடு: Invertebrates
// மீன் எனப்படும் புதிய விலங்கின் வகையை உருவாக்கிடுக
const fish = Object.create(Animal);
fish.type = ‘Fishes’;
fish.displayType(); // வெளியீடு: Fishes
மரபுரிமை ஜாவாஉரைநிரலில் உள்ள அனைத்து பொருட்களும் குறைந்தது ஒரு பொருளில் இருந்தே பெறுகின்றன. மரபுரிமையாகப் பெறப்படும் பொருளானது முன்மாதிரி என்று அழைக்கப்படுகிறது, மேலும் மரபுவழி பண்பியல்புகளை கட்டமைப்பாளரின் முன்மாதிரி பொருளில் காணலாம்.
பொருளின் பண்பியல்புகளை அட்டவணைப்படுத்துதல், ஒரு பொருளின் பண்பினை அதனுடைய பண்பின் பெயர் அல்லது வரிசைமுறையிலான அட்டவணைப் படுத்துதலின் மூலம் குறிப்பிடலாம். நாம் துவக்கத்தில் ஒரு பண்பினை அதன் பெயரால் வரையறுத்தால், எப்போதும் அதை அதன் பெயரால் குறிப்பிட வேண்டும், மேலும் துவக்கத்தில் ஒரு சுட்டியின் மூலம் ஒரு பண்பினை வரையறுத்தால், எப்போதும் அதை அதன் சுட்டியால் குறிப்பிட வேண்டும். ஒரு பொருளையும் அதன் பண்புகளையும் constructor எனும் செயலியின் மூலம் உருவாக்கும்போது (Carobject எனும் வகையுடன் முன்பு செய்தது போல) , தனிப்பட்ட பண்புகளை வெளிப்படையாக வரைய றுக்கும் போது (எடுத்துக்காட்டாக,myCar.color = ‘red’) இந்தக் கட்டுப்பாடு பொருந்தும். நாம் துவக்கத்தில், myCar[5] = ’25 mpg’ போன்ற சுட்டியுடன் ஒரு பொருளின் பண்பினை வரையறுத்தால், பின்னர் நாம் அந்த பண்பினை myCar[5] என்று மட்டுமே குறிப்பிடவேண்டும். இந்த விதிக்கு விதிவிலக்கு HTML இலிருந்து பிரதிபலிக்கும் வரிசை போன்ற பொருட்கள், அதாவது document.forms array-like object. என்பதாகும்
இந்த அணிவரிசை போன்ற பொருட்களில் உள்ள பொருட்களை அவற்றின் வரிசை முறைப்படியான எண்களின் (ஆவணத்தில் அவை தோன்றும் இடத்தின் அடிப்படையில்) அல்லது அவற்றின் பெயரின் (வரையறுக்கப்பட்டிருந்தால்) மூலம் நாம் எப்போதும் குறிப்பிடலாம். எடுத்துக்காட்டாக, ஒரு ஆவணத்தில் உள்ள இரண்டாவதாக எனும் குறிச்சொல்லில் ஒரு name=”myForm” எனும் பண்பு இருந்தால், படிவத்தை document.forms[1]ordocument.forms[‘myForm’] அல்லது document.forms.myForm எனக் குறிப்பிடலாம்.
ஒரு பொருளின் வகைக்கான பண்புகளை வரையறுத்தல், முன்மாதிரிப் பண்புகளைப் பயன்படுத்தி, முன்னர் வரையறுக்கப்பட்ட பொருள் வகைக்கு ஒரு பண்பினைச் சேர்க்கலாம். இது பொருளின் ஒரு நிகழ்வால் அல்லாமல், குறிப்பிட்ட வகையின் அனைத்து பொருட்களாலும் பகிரப்படும் ஒரு பண்பினை வரையறுக்கிறது. பின்வரும் குறிமுறைவரிகள் காரின் வகையின் அனைத்துப் பொருட்களுக்கும் வண்ணப் பண்புகளைச் சேர்க்கிறது, பின்னர் objectcar1 இன் வண்ணப் பண்பிற்கு மதிப்பை வழங்குகிறது.
.Car.prototype.color = null;
car1.color = ‘black’;
வழிமுறைகளை வரையறுத்தல் ஒரு வழிமுறை என்பது ஒரு பொருளுடன் தொடர்புடைய ஒரு செயலி, அல்லது, வேறுவிதமாகக் கூறவேண்டுமெனில், ஒரு வழிமுறை என்பது ஒரு பொருளின் பண்பு ஆகும். ஒரு பொருளின் பண்பு ஒதுக்கப்பட வேண்டுமே தவிர, இயல்பான செயலிகள் வரையறுக்கப்படும் விதத்தில் வழிமுறைகள் வரையறுக்கப்படுவதில்லை. . ஒரு எடுத்துக்காட்டு:
objectName.methodName = functionName;
const myObj = {
myMethod: function(params) {
// …எதையாவது செய்தல்
},
// இதையும்கூட செய்தல்!
myOtherMethod(params) {
// …வேறு எதையாவது செய்தல்
}
};
objectName என்பது ஏற்கனவே உள்ள பொருளாக இருந்தால், வழிமுறையின் பெயர் வழி முறைக்கு ஒதுக்கும் பெயர்ஆகும், functionName என்பது செயலியின் பெயர்ஆகும். பொருளின் சூழலில் வழிமுறையை பின்வருமாறு அழைக்கலாம்:
object.methodName(params);
object constructor எனும் செயலியில் ஒரு வழிமுறையின் வரையறையைச் சேர்ப்பதன் மூலம் ஒரு பொருளின் வகைக்கான வழிமுறைகளை வரையறுக்கலாம். முன்பு வரையறுக்கப்பட்ட கார் எனும் பொருட்களின் பண்பியல்புகளை வடிவமைத்து காண்பிக்கும் செயலியை வரையறுக்கலாம்; எடுத்துக்காட்டாக,
function displayCar() {
const result = A Beautiful ${this.year} ${this.make} ${this.model};
prettyPrint(result);
}
இதில் prettyPrint என்பது ஒரு கிடைமட்ட விதியையும் ஒரு சரத்தையும் காண்பிக்கின்றம் ஒரு செயலியாகும். இந்த வழிமுறையைப் பயன்படுத்துவதைக் கவனித்திடுக. கூற்றினைச் சேர்ப்பதன் மூலம் இந்தச் செயலியைபொருளின் வரையறைக்குக் காரின் வழிமுறையாக மாற்றலாம் this.displayCar = displayCar; . எனவே, காரின் முழு வரையறை இப்போது பின்வருவதைபோன்று இருக்கும்
function Car(make, model, year, owner) {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
this.displayCar = displayCar;
}
ஒவ்வொரு பொருளுக்கும் displayCar எனும் முறையைப் பின்வருமாறு அழைக்கலாம்:
பொருள் குறிப்புகளுக்கு இதைப் பயன்படுத்துதல் ஜாவாஉரைநிரலில் ஒரு சிறப்புத் திறவுச்சொல்லைக் கொண்டுள்ளது, இது, தற்போதைய பொருளைக் குறிப்பிடுவதற்கு ஒரு வழிமுறைக்குள் பயன்படுத்தலாம். எடுத்துக்காட்டாக, நம்மிடம் 2 பொருட்கள் உள்ளன, மேலாளர் ,பயிற்சியாளர். ஆகிய ஒவ்வொரு பொருளுக்கும் அதன் சொந்த பெயர், வயது, வேலை ஆகியவை உள்ளது. Hi() என்ற செயலியில், this.name எனஇருப்பதைக் கவனித்திடுக. 2 பொருள்களுடன் சேர்க்கப்படும் போது அவை ‘Hello, My name is’ என்று அழைத்து அச்சிடலாம், பின்னர் கீழே காட்டப்பட்டுள்ளது போன்றுஅந்த குறிப்பிட்ட பொருளின் பெயர் மதிப்பைச் சேர்க்கிறது..
const Manager = {
name: “John”,
age: 27,
job: “Software Engineer”
}
const Intern = {
name: “Ben”,
age: 21,
job: “Software Engineer Intern”
}
function sayHi() {
console.log(Hello, my name is ${this.name})
}
// add sayHi function to both objects
Manager.sayHi = sayHi;
Intern.sayHi = sayHi;
Manager.sayHi(); // Hello, my name is John’
Intern.sayHi(); // Hello, my name is Ben’
Thethisrefers to the object that it is in. You can create a new function calledhowOldAmI()which logs a sentence saying how old the person is.
function howOldAmI() {
console.log(I am ${this.age} years old.);
}
Manager.howOldAmI = howOldAmI;
Manager.howOldAmI(); // I am 27 years old.
பெறுபவர்களையும்(getters), அமைப்பாளர்களை(setters) யும்வரையறுத்தல்
ஒரு குறிப்பிட்டபண்பியில்பின் மதிப்பைப் பெறும் ஒரு வழிமுறையாகும். setter என்பது ஒரு குறிப்பிட்ட பண்பின் மதிப்பை அமைக்கும் ஒரு வழிமுறையாகும். புதிய பண்புகளைச் சேர்ப்பதை ஆதரிக்கும் எந்தவொரு முன்கூட்டியே வரையறுக்கப்பட்ட முக்கிய பொருள் அல்லது பயனாளர் வரையறுக்கப்பட்ட பொருளின் பெறுபவர்களையும் அமைப்பாளர்களையும் வரையறுக்கலாம். பெறுபவர்களாக அமைப்பாளர்களாக இருக்கலாம்
• பொருள் துவக்கிகளைப் பயன்படுத்தி வரையறுக்கப்படுகிறது, அல்லது
• பெறுபவர் அல்லது அமைப்பாளர் சேர்க்கும் வழிமுறையைப் பயன்படுத்தி எந்த நேரத்திலும் எந்தவொரு பொருளிலும் பின்னர் சேர்க்கப்படும்.
பொருள் துவக்கிகளைப் பயன்படுத்தி பெறுபவர்கள் அமைப்பாளர்களை வரையறுக்கும் போது, செய்ய வேண்டியது get உடன் கெட்டர் முறையை முன்னொட்டு மற்றும் செட் உடன் செட்டர் முறை. நிச்சயமாக, getter எனும் வழிமுறை ஒரு அளவுருவை எதிர்பார்க்கக்கூடாது, அதே சமயம் setter எனும் வழிமுறை சரியாக ஒரு அளவுருவை (அமைக்க வேண்டிய புதிய மதிப்பு) எதிர்பார்க்கிறது. எடுத்துக்காட்டாக:
const o = {
a: 7,
get b() {
return this.a + 1;
},
set c(x) {
this.a = x / 2;
}
};
console.log(o.a); // 7
console.log(o.b); // 8 <– At this point the get b() method is initiated.
o.c = 50; // <– At this point the set c(x) method is initiated
console.log(o.a); // 25
பொருளின் பண்புகள்:
• o.a- ஒரு எண்
• o.b- திரும்பப் பெறும் ஒரு பெறுநர். Aplus 1
• o.c— மதிப்பை அமைக்கும் மதிப்பை அமைக்கும் ஒரு அமைப்பாளர்.
“[gs]etproperty()” ஐப் பயன்படுத்தி ஒரு பொருளில் வரையறுக்கப்பட்ட பெறுபவர்கள் , அமைப்பாளர்களின் செயலியின் பெயர்கள், [gs]et propertyName(){ } தொடக்கவியல் நம்மை தவறாக வழிநடத்தினாலும், பெறுபவர்களின் பெயர்கள் அன்று என்பதை நினைவில் கொள்க. வேறுவிதமாக கூட கருதலாம்.
Object.define Properties() எனும் வழிமுறையைப் பயன்படுத்தி உருவாக்கிய பிறகு எந்த நேரத்திலும் ஒரு பொருளில் பெறுபவர்கள் அமைப்பாளர்கள் சேர்க்கலாம். இந்த வழிமுறையின் முதல் அளவுரு, பெறுபவர் அல்லது அமைப்பாளரை வரையறுக்க விரும்பும் பொருளாகும். இரண்டாவது அளவுரு என்பது ஒரு பொருளாகும், அதன் பண்பியில்பின் பெயர்கள் பெறுபவர் அல்லதுஅமைப்பாளர் பெயர்கள், அதன் பண்பியல்பின் மதிப்புகள் பெறுபவர் அல்லது அமைப்பாளர் செயலிகளை வரையறுக்கும் பொருள்கள். முந்தைய எடுத்துக்காட்டில் பயன்படுத்தப்பட்ட அதே gette ,setterஐவரையறுக்கின்ற ஒரு எடுத்துக்காட்டு:
const o = { a: 0 };
Object.defineProperties(o, {
‘b’: { get: function() { return this.a + 1; } },
‘c’: { set: function(x) { this.a = x / 2; } }
});
o.c = 10; // Runs the setter, which assigns 10 / 2 (5) to the ‘a’ property
console.log(o.b); // Runs the getter, which yields a + 1 or 6
இரண்டு படிவங்களில் எதை தேர்வு செய்வது என்பது நம்முடைய நிரலாக்க பாணி யையும் கையில் இருக்கும் பணியையும் பொறுத்ததாகும். ஒரு முன்மாதிரியை வரையறுக்கும் போது ஏற்கனவே பொருளின் துவக்கிக்கு சென்றால், பெரும்பாலும் முதல் படிவத்தை தேர்வு செய்யலாம். இந்த வடிவம் மிகவும் கச்சிதமானது இயற்கையானது. இருப்பினும், பின்னர் பெறுபவர்களையும் அமைப்பாளர்களையும் சேர்க்க வேண்டும் எனில் -முன்மாதிரி அல்லது குறிப்பிட்ட பொருளை எழுதாததால் – இரண்டாவது படிவம் மட்டுமே சாத்தியமான படிவமாகும். இரண்டாவது வடிவம் ஜாவாஉரைநிரலின் மாறும் தன்மையை சிறப்பாக பிரதிபலிக்கிறது – ஆனால் இது குறிமுறைவரிகளைப் படிக்கவும் புரிந்துகொள்ளவும் கடினமாக்கும். பண்புகளை நீக்குதல் delete எனும் இயக்குபவரைப் பயன்படுத்தி மரபுரிமை அல்லாத பண்பினை அகற்றலாம். பண்பினை எவ்வாறு அகற்றுவது என்பதை பின்வரும் குறிமுறைவரிகள் காண்பிக்கின்றன.
//myobjஆனது a,bஆகிய இருபண்புகளுடன் ஒருபுதிய பொருளைஉருவாக்குகிறது,
const myobj = new Object();
myobj.a = 5;
myobj.b = 12;
// ஒரு பண்பினை அகற்றி, myobj ஐ மட்டும் b எனும் பண்புடன் விட்டுவிடும் .
delete myobj.a;
console.log (‘a’ in myobj); // output: “false”
ஜாவாஉரைநிரலில் பொருட்களை ஒப்பிடுதல், பொருட்கள் ஒரு குறிப்பு வகை. இரண்டு வேறுபட்ட பொருள்கள் ஒரே பண்புகளைக் கொண்டிருந்தாலும் அவை சமமாக இருக்காது. ஒரே பொருள் குறிப்பை அதனுடன் ஒப்பிட்டுப் பார்த்தால் மட்டுமே உண்மை கிடைக்கும்
. // இரண்டு மாறிகள்,ஒரே பண்புகளைக் கொண்ட இருவேறுபட்ட பொருட்கள்
const fruit = {name: ‘apple’};
const fruitbear = {name: ‘apple’};
fruit == fruitbear; // false என திரும்பும்
fruit === fruitbear; // false என திரும்பும்
// ஒரேபொருளிற்கு இருமாறிகள்variables,
const fruit = {name: ‘apple’};
const fruitbear = fruit; //fruitbearஎன்பதற்குfruit object எனும் மேற்கோளை ஒதுக்குக
//இங்கு fruitஎன்பதும், fruitbearஎன்பதும் ஒரே பொருளைச் சுட்டிக்காட்டுகின்றன
fruit == fruitbear; // trueஎனதிரும்பும்
fruit === fruitbear; // trueஎனதிரும்பும்
fruit.name = ‘grape’;
console.log(fruitbear); // வெளியீடு: { name: “grape” }, instead of { name: “apple” }
தொடரும்
இனிய, எளிய தமிழில் கணினி தகவல் 