මම එය ගතික ක්‍රමලේඛන භාෂාවලට නොව ජාවාස්ක්‍රිප්ට් කේතයේ මගේ සාධාරණ කොටස ලියා ඇත. මෙම මූලාකෘති පාදක කරගත් ක්‍රමලේඛනය වටා මා කිසි විටෙකත් හිස ඔසවා නැත, මෙය ක්‍රියාත්මක වන්නේ කෙසේදැයි කිසිවෙකු දන්නවාද?

var obj = new Object();
obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();

ටික කලකට පෙර මම මිනිසුන් සමඟ කළ බොහෝ සාකච්ඡාවන් මට මතකයි (මා කරන්නේ කුමක්දැයි මට හරියටම විශ්වාස නැත) නමුත් මම එය තේරුම් ගත් පරිදි පන්තියක් පිළිබඳ සංකල්පයක් නොමැත. එය හුදෙක් වස්තුවක් පමණක් වන අතර, එම වස්තූන්ගේ අවස්ථා මුල් පිටපතෙහි ක්ලෝන වේ, නේද?

නමුත් ජාවාස්ක්‍රිප්ට් හි මෙම “.ප්‍රොටොටයිප්” දේපලෙහි නියම අරමුණ කුමක්ද? වස්තූන් ක්ෂණිකව සම්බන්ධ කිරීමට එය සම්බන්ධ වන්නේ කෙසේද?

යාවත්කාලීන කිරීම: නිවැරදි මාර්ගය

var obj = new Object(); // not a functional object
obj.prototype.test = function() { alert('Hello?'); }; // this is wrong!

function MyObject() {} // a first class functional object
MyObject.prototype.test = function() { alert('OK'); } // OK

එසේම මෙම විනිවිදක බොහෝ සෙයින් උපකාරී විය.

සෑම JavaScript වස්තුව අභ්යන්තර "තව්" ඇත කැඳවා [[Prototype]]අගය වේ එක්කෝ nullහෝ object. ජාවාස්ක්‍රිප්ට් එන්ජිමට අභ්‍යන්තරව, ඔබ ලියන කේතයෙන් සැඟවී ඇති වස්තුවක් මත ඇති දේපලක් ලෙස ඔබට සිතිය හැකිය. අවට [[Prototype]]ඇති වර්ග වරහන් හිතාමතාම වන අතර අභ්‍යන්තර තව් දැක්වීමට ECMAScript පිරිවිතර සම්මුතියකි.

[[Prototype]]වස්තුවක පෙන්වා ඇති අගය , “එම වස්තුවේ මූලාකෘතිය” ලෙස හැඳින්වේ.

ඔබ තිතක් ( obj.propName) හෝ වරහන ( obj['propName']) අංකනය හරහා දේපලකට ප්‍රවේශ වන්නේ නම් සහ වස්තුවට සෘජුවම එවැනි දේපලක් නොමැති නම් (එනම්, තමන්ගේම දේපලක් , පරීක්ෂා කළ හැකි obj.hasOwnProperty('propName')), ධාවන කාලය සඳහන් කර ඇති වස්තුව මත එම නම සහිත දේපලක් සොයයි ඒ [[Prototype]]වෙනුවට. නම් [[Prototype]] ද එවැනි දේපල නැත, එහි [[Prototype]]කියන්නේ අනෙක් අතට පරීක්ෂා, සහ යනාදි. මේ ආකාරයට, මුල් වස්තුවේ මූලාකෘති දාමය ගැලපීමක් සොයා ගන්නා තෙක් හෝ එහි අවසානය කරා ළඟා වන තෙක් ගමන් කරයි. මූලාකෘති දාමයේ ඉහළින්ම nullඅගය ඇත.

නවීන ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම මඟින් [[Prototype]]පහත දැක්වෙන ආකාරවලින් කියවීමට සහ / හෝ ලිවීමට ප්‍රවේශය ලබා දේ :

1. මෙම newක්රියාකරු (මානකරනු වූ ඉදිකිරීමටත් කාර්යය සිට ආපසු පෙරනිමි වස්තුවක් මත පතිරූපක දාම),
2. මෙම extendsමූල පදය (පන්ති කාරක රීති භාවිතා කරන විට පතිරූපක දාම මාන),
3. Object.createසපයන ලද තර්කය එහි ප්‍රති ing ලයක් ලෙස [[Prototype]]ඇති වස්තුව ලෙස සැකසෙනු ඇත.
4. Object.getPrototypeOfසහ Object.setPrototypeOf( [[Prototype]] පසු වස්තු නිර්මාණය කිරීමෙන් / ලබා ගන්න ), සහ
5. නම් කරන ලද ප්‍රමිතිගත ප්‍රවේශක (එනම්, ලබා ගන්නා / සකසන) දේපල __proto__(4 ට සමාන)

Object.getPrototypeOfහා Object.setPrototypeOfදක්වනු ඇත __proto__කොටසක්, හැසිරීම නිසා o.__proto__ අසාමාන්ය වස්තුවක මූලාකෘතිය ඇති විට null.

වස්තුවක් [[Prototype]]මුලින් සකසා ඇත්තේ වස්තු නිර්මාණය අතරතුර ය.

ඔබ හරහා නව වස්තුවක් නිර්මාණය කරන්නේ නම් , පෙරනිමියෙන්, new Func()වස්තුවෙහි [[Prototype]]අභිමතය පරිදි යොමු කරන ලද වස්තුවට සැකසෙනු ඇත Func.prototype.

එබැවින්, සියලු පංති සහ newක්‍රියාකරු සමඟ භාවිතා කළ හැකි සියළුම කාර්යයන් .prototypeසඳහා ඔවුන්ගේම [[Prototype]]අභ්‍යන්තර තව් වලට අමතරව නම් කරන ලද දේපලක් ඇති බව සලකන්න . "මූලාකෘති" යන වචනය මෙම ද්විත්ව භාවිතය භාෂාවට නවකයන් අතර නිමක් නැති ව්‍යාකූලත්වයේ මූලාශ්‍රය වේ.

newඉදිකිරීම්කරුවන්ගේ කාර්යයන් සමඟ භාවිතා කිරීම අපට ජාවාස්ක්‍රිප්ට් හි සම්භාව්‍ය උරුමය අනුකරණය කිරීමට ඉඩ දෙයි; ජාවාස්ක්‍රිප්ට් හි උරුම පද්ධතිය වුවද - අප දැක ඇති පරිදි - මූලාකෘති මිස පන්ති පදනම් නොවේ.

ජාවාස්ක්‍රිප්ට් වෙත පන්ති සින්ටැක්ස් හඳුන්වාදීමට පෙර, පන්ති අනුකරණය කිරීමට ඇති එකම ක්‍රමය ඉදිකිරීම්කරුවන්ගේ කාර්යයන්ය. ඉදිකිරීම්කරු ශ්‍රිතයේ .prototypeදේපල හවුල් සාමාජිකයන් ලෙස සඳහන් කර ඇති වස්තුවේ ගුණාංග ගැන අපට සිතිය හැකිය ; එනම්. එක් එක් අවස්ථාව සඳහා සමාන වන සාමාජිකයන්. පංති පාදක පද්ධති වලදී, එක් එක් අවස්ථාව සඳහා ක්‍රම එකම ආකාරයකින් ක්‍රියාත්මක වේ, එබැවින් ක්‍රමෝපායන් .prototypeදේපල සඳහා සංකල්පමය වශයෙන් එකතු කරනු ලැබේ ; කෙසේ වෙතත්, වස්තුවක ක්ෂේත්‍ර නිදර්ශන-විශේෂිත වන අතර එම නිසා ඉදිකිරීම් අතරතුරදී එම වස්තුවටම එකතු වේ.

පංති සින්ටැක්ස් නොමැතිව, සංවර්ධකයින්ට සම්භාව්‍ය උරුමයට සමාන ක්‍රියාකාරීත්වයක් ලබා ගැනීම සඳහා මූලාකෘති දාමය අතින් වින්‍යාස කිරීමට සිදු විය. මෙය සාක්ෂාත් කර ගැනීම සඳහා විවිධ ක්‍රම පිළිබඳ පූර්ව නිගමනයකට එළඹුණි.

මෙන්න එක් ක්‍රමයක්:

function Child() {}
function Parent() {}
Parent.prototype.inheritedMethod = function () { return 'this is inherited' }

function inherit(child, parent) {
  child.prototype = Object.create(parent.prototype)
  child.prototype.constructor = child
  return child;
}

Child = inherit(Child, Parent)
const o = new Child
console.log(o.inheritedMethod()) // 'this is inherited'

... මෙන්න තවත් ක්‍රමයක්:

function Child() {}
function Parent() {}
Parent.prototype.inheritedMethod = function () { return 'this is inherited' }

function inherit(child, parent) {
    function tmp() {}
    tmp.prototype = parent.prototype
    const proto = new tmp()
    proto.constructor = child
    child.prototype = proto
    return child
}

Child = inherit(Child, Parent)
const o = new Child
console.log(o.inheritedMethod()) // 'this is inherited'

ES2015 හි හඳුන්වා දුන් පන්ති වාක්‍ය ඛණ්ඩය extendsජාවාස්ක්‍රිප්ට් හි සම්භාව්‍ය උරුමය අනුකරණය කිරීම සඳහා මූලාකෘති දාමය වින්‍යාස කිරීමට “එක් සත්‍ය ක්‍රමයක්” ලෙස සැපයීමෙන් දේවල් සරල කරයි.

එබැවින්, ඉහත කේතයට සමානව, ඔබ නව වස්තුවක් නිර්මාණය කිරීම සඳහා පන්ති සින්ටැක්ස් භාවිතා කරන්නේ නම්:

class Parent { inheritedMethod() { return 'this is inherited' } }
class Child extends Parent {}

const o = new Child
console.log(o.inheritedMethod()) // 'this is inherited'

... එහි [[Prototype]]ප්‍රති ing ලයක් ලෙස ඇති වස්තුව නිදසුනකට Parentසැකසෙනු [[Prototype]]ඇත Parent.prototype.

අවසාන වශයෙන්, ඔබ නව වස්තුවක් හරහා නිර්මාණය කරන්නේ නම් Object.create(foo), එහි ප්‍රති ing ලයක් ලෙස ඇති වස්තුව සැකසෙනු [[Prototype]]ඇත foo.

ජාවා, සී # හෝ සී ++ වැනි සම්භාව්‍ය උරුමය ක්‍රියාත්මක කරන භාෂාවකින් ඔබ පන්තියක් නිර්මාණය කිරීමෙන් ආරම්භ කරයි - ඔබේ වස්තූන් සඳහා සැලැස්මක් - ඉන්පසු ඔබට එම පන්තියෙන් නව වස්තු නිර්මාණය කළ හැකිය, නැතහොත් ඔබට පන්තිය දීර් extend කළ හැකිය, නව පන්තියක් නිර්වචනය කරයි මුල් පන්තිය.

ජාවාස්ක්‍රිප්ට් හි ඔබ මුලින්ම වස්තුවක් නිර්මාණය කරයි (පංතිය පිළිබඳ සංකල්පයක් නොමැත), එවිට ඔබට ඔබේම වස්තුව වැඩි කිරීමට හෝ එයින් නව වස්තු නිර්මාණය කළ හැකිය. එය අපහසු නැත, නමුත් සම්භාව්‍ය ක්‍රමයට පුරුදු වී සිටින කෙනෙකුට පරිවෘත්තීය කිරීමට ටිකක් විදේශීය හා දුෂ්කර ය.

උදාහරණයක්:

//Define a functional object to hold persons in JavaScript
var Person = function(name) {
  this.name = name;
};

//Add dynamically to the already defined object a new getter
Person.prototype.getName = function() {
  return this.name;
};

//Create a new object of type Person
var john = new Person("John");

//Try the getter
alert(john.getName());

//If now I modify person, also John gets the updates
Person.prototype.sayMyName = function() {
  alert('Hello, my name is ' + this.getName());
};

//Call the new method on john
john.sayMyName();

මේ වන තෙක් මම මූලික වස්තුව දීර් ing කරමින් සිටිමි, දැන් මම වෙනත් වස්තුවක් නිර්මාණය කර පසුව පුද්ගලයාගෙන් උරුම වෙමි.

//Create a new object of type Customer by defining its constructor. It's not 
//related to Person for now.
var Customer = function(name) {
    this.name = name;
};

//Now I link the objects and to do so, we link the prototype of Customer to 
//a new instance of Person. The prototype is the base that will be used to 
//construct all new instances and also, will modify dynamically all already 
//constructed objects because in JavaScript objects retain a pointer to the 
//prototype
Customer.prototype = new Person();     

//Now I can call the methods of Person on the Customer, let's try, first 
//I need to create a Customer.
var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();

//If I add new methods to Person, they will be added to Customer, but if I
//add new methods to Customer they won't be added to Person. Example:
Customer.prototype.setAmountDue = function(amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function() {
    return this.amountDue;
};

//Let's try:       
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

var Person = function (name) {
    this.name = name;
};
Person.prototype.getName = function () {
    return this.name;
};
var john = new Person("John");
alert(john.getName());
Person.prototype.sayMyName = function () {
    alert('Hello, my name is ' + this.getName());
};
john.sayMyName();
var Customer = function (name) {
    this.name = name;
};
Customer.prototype = new Person();

var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();
Customer.prototype.setAmountDue = function (amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function () {
    return this.amountDue;
};
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

මට setAmountDue () අමතන්න බැහැ, පුද්ගලයෙකුට getAmountDue () අමතන්න.

//The following statement generates an error.
john.setAmountDue(1000);

මෙය ඉතා සරල මූලාකෘති පදනම් කරගත් වස්තු ආකෘතියක් වන අතර එය පැහැදිලි කිරීමක් අතරතුර නියැදියක් ලෙස සලකනු ඇත.

function Person(name){
    this.name = name;
}
Person.prototype.getName = function(){
    console.log(this.name);
}
var person = new Person("George");

මූලාකෘති සංකල්පය හරහා යාමට පෙර අප විසින් සලකා බැලිය යුතු තීරණාත්මක කරුණු කිහිපයක් තිබේ.

1- ජාවාස්ක්‍රිප්ට් ක්‍රියාකාරිත්වය සැබවින්ම ක්‍රියාත්මක වන ආකාරය:

පළමු පියවර ගැනීම සඳහා, ජාවාස්ක්‍රිප්ට් ක්‍රියාකාරීත්වය සැබවින්ම ක්‍රියාත්මක වන්නේ කෙසේද, එහි thisයතුරුපදය භාවිතා කරන ශ්‍රිතය වැනි පන්තියක් ලෙස හෝ එහි තර්ක සමඟ නිත්‍ය ශ්‍රිතයක් ලෙස, එය කරන්නේ කුමක්ද සහ එය නැවත ලබා දෙන්නේ කුමක් ද යන්න.

Personවස්තු ආකෘතියක් නිර්මාණය කිරීමට අපට අවශ්‍ය යැයි කියමු . නමුත් මෙම පියවර, මම උත්සාහ කළ හදන්නේ භාවිතා නොකර එම නිශ්චිත දෙයක් කරන්න prototypeසහ newමූල පදය .

ඉතින් මේ පියවරේදී functions, objectsසහ thisයතුරු පදයෙන් අපට ඇත්තේ සියල්ලම පමණි.

පළමු ප්‍රශ්නය වනුයේ යතුරු පද භාවිතා නොකර යතුරුපදය ප්‍රයෝජනවත් වන්නේ කෙසේද යන්නයිthisnew .

එබැවින් එයට පිළිතුරු දීමට අපට හිස් වස්තුවක් ඇති බව කියමු.

var person = {};
function Person(name){  this.name = name;  }

function getName(){
    console.log(this.name);
}

දැන් යතුරු පද භාවිතා නොකරnew අපට මෙම කාර්යයන් භාවිතා කරන්නේ කෙසේද. එබැවින් ජාවාස්ක්‍රිප්ට් ඒ සඳහා විවිධ ක්‍රම 3 ක් ඇත:

ඒ. පළමු ක්‍රමය නම් ශ්‍රිතය සාමාන්‍ය ශ්‍රිතයක් ලෙස හැඳින්වීම පමණි:

Person("George");
getName();//would print the "George" in the console

මෙම අවස්ථාවේදී, මෙය වර්තමාන සන්දර්භය වස්තුව වනු ඇත, එය සාමාන්‍යයෙන් windowබ්‍රව්සරයේ හෝ GLOBALතුළ ඇති ගෝලීය වස්තුව වේ Node.js. එහි අර්ථය වන්නේ බ්‍රව්සරයේ window.name හෝ Node.js හි GLOBAL.name, එහි වටිනාකම ලෙස "ජෝර්ජ්" යන්නයි.

බී. වස්තුවකට එහි ගුණාංග ලෙස අපට ඒවා ඇමිණිය හැකිය

- මෙය කිරීමට ඇති පහසුම ක්‍රමය වන්නේ හිස් personවස්තුව වෙනස් කිරීමයි , වැනි:

person.Person = Person;
person.getName = getName;

මේ ආකාරයෙන් අපට ඔවුන්ව මෙසේ හැඳින්විය හැකිය:

person.Person("George");
person.getName();// -->"George"

දැන් personවස්තුව සමාන ය:

Object {Person: function, getName: function, name: "George"}

- කිසියම් වස්තුවකට දේපලක් ඇමිණිය හැකි අනෙක් ක්‍රමයprototype නම් ඕනෑම ජාවාස්ක්‍රිප්ට් වස්තුවක නම සහිත සොයාගත හැකි එම වස්තුව භාවිතා කිරීමයි __proto__, සාරාංශ කොටසේ එය ටිකක් පැහැදිලි කිරීමට මම උත්සාහ කර ඇත්තෙමි. එබැවින් අපට සමාන ප්‍රති result ල ලබා ගත හැකිය:

person.__proto__.Person = Person;
person.__proto__.getName = getName;

නමුත් මේ ආකාරයෙන් අප කරන්නේ ඇත්ත වශයෙන්ම වෙනස් කිරීමයි Object.prototype, මන්ද අපි ජාවාස්ක්‍රිප්ට් වස්තුවක් සාහිත්‍යය ( { ... }) භාවිතා කරමින් නිර්මාණය කරන සෑම විටම එය පදනම් කරගෙන නිර්මාණය වන Object.prototypeඅතර එයින් අදහස් කරන්නේ එය අලුතින් සාදන ලද වස්තුවට නම් කරන ලද ලක්ෂණයක් ලෙස සම්බන්ධ වන බවයි __proto__, එබැවින් අපි එය වෙනස් කළහොත් , අපගේ පෙර කේත ස්නිපටයේ සිදු කර ඇති පරිදි, සියලු ජාවාස්ක්‍රිප්ට් වස්තු වෙනස් වනු ඇත, හොඳ පුහුණුවක් නොවේ. ඉතින් දැන් වඩා හොඳ පුරුද්ද කුමක් විය හැකිද:

person.__proto__ = {
    Person: Person,
    getName: getName
};

දැන් වෙනත් වස්තූන් සාමයෙන් සිටින නමුත් එය තවමත් හොඳ පුරුද්දක් ලෙස නොපෙනේ. එබැවින් අපට තවත් එක් විසඳුම් ඇත, නමුත් මෙම විසඳුම භාවිතා කිරීම සඳහා අපි personවස්තුව නිර්මාණය කළ කේත රේඛාවට ආපසු යා යුතුය ( var person = {};) ඉන්පසු එය වෙනස් කරන්න:

var propertiesObject = {
    Person: Person,
    getName: getName
};
var person = Object.create(propertiesObject);

දේ එය වන නව JavaScript නිර්මාණය කරමින් Objectසහ අනුයුක්ත propertiesObjectකිරීමට __proto__විශේෂණය. එබැවින් ඔබට කළ හැකි බවට වග බලා ගැනීම සඳහා:

console.log(person.__proto__===propertiesObject); //true

නමුත් මෙහි ඇති උපායශීලී කරුණ නම් __proto__, personවස්තුවේ පළමු මට්ටමේ අර්ථ දක්වා ඇති සියලුම ගුණාංග වෙත ඔබට ප්‍රවේශය තිබීමයි (වැඩි විස්තර සඳහා සාරාංශ කොටස කියවන්න).

ඔබ දකින පරිදි මෙම ක්‍රම දෙකෙන් thisඑකක් භාවිතා කිරීම හරියටම personවස්තුවට යොමු වේ.

ඇ. ජාවාස්ක්රිප්ට් සමග මෙම උත්සවයට ලබා තවත් ක්රමයක් thisභාවිතා කරන, ඇමතුම් හෝ අදාළ උත්සවයට පතා.

Apply () ක්‍රමය මඟින් ලබා දී ඇති මෙම අගය සහිත ශ්‍රිතයක් සහ අරාව (හෝ අරාව වැනි වස්තුවක්) ලෙස දක්වා ඇති තර්ක කැඳවයි.

සහ

ඇමතුම් () ක්‍රමය මඟින් මෙම අගය ලබා දී ඇති ශ්‍රිතයක් සහ තර්ක තනි තනිව සපයයි.

මගේ ප්‍රියතම ක්‍රමය වන අපට පහසුවෙන් අපගේ කාර්යයන් අමතන්න:

Person.call(person, "George");

හෝ

//apply is more useful when params count is not fixed
Person.apply(person, ["George"]);

getName.call(person);   
getName.apply(person);

.ප්‍රොටොටයිප් ක්‍රියාකාරිත්වය හඳුනා ගැනීම සඳහා වැදගත් ආරම්භක පියවර මෙම ක්‍රම 3 වේ.

2- newමූල පදය ක්‍රියා කරන්නේ කෙසේද?

.prototypeක්‍රියාකාරීත්වය අවබෝධ කර ගැනීමේ දෙවන පියවර මෙයයි . ක්‍රියාවලිය අනුකරණය කිරීමට මා භාවිතා කරන්නේ මෙයයි:

function Person(name){  this.name = name;  }
my_person_prototype = { getName: function(){ console.log(this.name); } };

මෙම කොටසේදී මම උත්සාහ කරන්නේ ජාවාස්ක්‍රිප්ට් විසින් ගනු ලබන සියලුම පියවරයන්, newමූලික පදය භාවිතා නොකර, සහ prototypeඔබ newයතුරු පද භාවිතා කරන විට . එබැවින් අප එසේ කරන විට new Person("George"), Personශ්‍රිතය ඉදිකිරීම්කරුවෙකු ලෙස සේවය කරයි, මේවා ජාවාස්ක්‍රිප්ට් එකින් එක කරයි:

ඒ. පළමුවෙන්ම එය හිස් වස්තුවක් සාදයි, මූලික වශයෙන් හිස් හැෂ් වැනි:

var newObject = {};

බී. ජාවාස්ක්‍රිප්ට් විසින් ගනු ලබන ඊළඟ පියවර වන්නේ සියලු මූලාකෘති වස්තු අලුතින් සාදන ලද වස්තුවට අනුයුක්ත කිරීමයි

අපට my_person_prototypeමෙහි මූලාකෘති වස්තුවට සමාන ය.

for(var key in my_person_prototype){
    newObject[key] = my_person_prototype[key];
}

ජාවාස්ක්‍රිප්ට් ඇත්ත වශයෙන්ම මූලාකෘතියේ අර්ථ දක්වා ඇති ගුණාංග සම්බන්ධ කරන ආකාරය නොවේ. සත්‍ය ක්‍රමය මූලාකෘති දාම සංකල්පයට සම්බන්ධයි.

ඒ. & බී. මෙම පියවර දෙක වෙනුවට ඔබට කිරීමෙන් එකම ප්‍රති result ලය ලබා ගත හැකිය:

var newObject = Object.create(my_person_prototype);
//here you can check out the __proto__ attribute
console.log(newObject.__proto__ === my_person_prototype); //true
//and also check if you have access to your desired properties
console.log(typeof newObject.getName);//"function"

දැන් අපට getNameඅපගේ ශ්‍රිතය ඇමතිය හැකිය my_person_prototype:

newObject.getName();

ඇ. එවිට එය එම වස්තුව ඉදිකිරීම්කරුට ලබා දෙයි,

අපගේ නියැදිය සමඟ අපට මෙය කළ හැකිය:

Person.call(newObject, "George");

හෝ

Person.apply(newObject, ["George"]);

එවිට ඉදිකිරීම්කරුට අවශ්‍ය ඕනෑම දෙයක් කළ හැකිය මෙම ඉදිකිරීම්කරුගේ ඇතුළත මෙම නිර්මාණය කරන ලද වස්තුවයි.

අනෙක් පියවර අනුකරණය කිරීමට පෙර දැන් අවසාන ප්‍රති result ලය: වස්තුව {නම: "ජෝර්ජ්"}

සාරාංශය:

මූලික වශයෙන්, ඔබ ශ්‍රිතයක් සඳහා නව මූල පදය භාවිතා කරන විට , ඔබ එය ඉල්ලා සිටින අතර එම ශ්‍රිතය ඉදිකිරීම්කරුවෙකු ලෙස සේවය කරයි, එබැවින් ඔබ කියන විට:

new FunctionName()

ජාවාස්ක්‍රිප්ට් අභ්‍යන්තරව වස්තුවක්, හිස් හැෂ් එකක් සාදා එය එම වස්තුව ඉදිකිරීම්කරුට ලබා දෙයි, එවිට ඉදිකිරීම්කරුට අවශ්‍ය ඕනෑම දෙයක් කළ හැකිය, මන්ද මෙම ඉදිකිරීම්කරුගේ ඇතුළත මේ වන විට නිර්මාණය කරන ලද වස්තුව වන අතර එමඟින් එය ඔබට එම වස්තුව ලබා දෙයි. ඔබ ඔබේ ශ්‍රිතයේ ප්‍රතිලාභ ප්‍රකාශය භාවිතා කර නොමැති නම් හෝ return undefined;ඔබේ ක්‍රියාකාරී ශරීරයේ අවසානයේ ඔබ තබා තිබේ නම් .

එබැවින් ජාවාස්ක්‍රිප්ට් වස්තුවක් මත දේපලක් බැලීමට ගිය විට, එය කරන පළමු දෙය නම්, එය එම වස්තුව දෙස බැලීමයි. රහසිගත දේපලක් [[prototype]]අප සතුව ඇති අතර එය සාමාන්‍යයෙන් __proto__ජාවාස්ක්‍රිප්ට් දෙස බලයි. එය නැවත බැලූ විට __proto__, එය නැවතත් තවත් ජාවාස්ක්‍රිප්ට් වස්තුවක් වන තාක්, එයට එයටම ආවේණික වූ __proto__ගුණාංගයක් ඇත, එය ඊළඟට __proto__ශුන්‍ය වන ස්ථානයට ළඟා වන තෙක් එය ඉහළට හා ඉහළට යයි . ජාවාස්ක්‍රිප්ට් හි ඇති එකම වස්තුව ලක්ෂ්‍යය වන අතර එහි __proto__ගුණාංගය ශුන්‍ය වේ Object.prototype:

console.log(Object.prototype.__proto__===null);//true

ජාවාස්ක්‍රිප්ට් හි උරුමය ක්‍රියාත්මක වන්නේ එලෙසයි.

වෙනත් වචන වලින් කිවහොත්, ඔබ ශ්‍රිතයක් සඳහා මූලාකෘති දේපලක් ඇති විට සහ ඔබ ඒ පිළිබඳව නව දෙයක් කැඳවූ විට, ජාවාස්ක්‍රිප්ට් විසින් දේපල සඳහා අලුතින් නිර්මාණය කරන ලද වස්තුව දෙස බැලීමෙන් පසුව, එය ශ්‍රිතය දෙස බලා .prototypeමෙම වස්තුවට එහි ඇති බව පෙනේ. අභ්‍යන්තර මූලාකෘතියක්. සහ යනාදි.

මූලාකෘති කෝන්ස් හත

ගැඹුරු භාවනාවෙන් පසු සයිරෝ සැන් ෆයර් ෆොක්ස් කන්දෙන් බැස යද්දී ඔහුගේ මනස පැහැදිලි සහ සාමකාමී විය.

කෙසේවෙතත්, ඔහුගේ අත නොසන්සුන් වූ අතර, ඔහු විසින්ම බුරුසුවක් අල්ලා පහත සටහන් සටහන් කළේය.

0) වෙනස් කරුණු දෙකක් "මූලාකෘති" ලෙස හැඳින්විය හැකිය:

• මූලාකෘති දේපල, මෙන් obj.prototype

• [[Prototype]] ES5 හි දැක්වෙන පරිදි මූලාකෘති අභ්‍යන්තර දේපල .

  එය ES5 හරහා ලබා ගත හැකිය Object.getPrototypeOf().

  ෆයර්ෆොක්ස් එය __proto__දේපල හරහා දිගුවක් ලෙස ප්‍රවේශ කළ හැකිය . ES6 දැන් විකල්ප විකල්ප කිහිපයක් සඳහන් කරයි__proto__ .

1) එම සංකල්ප පවතින්නේ ප්‍රශ්නයට පිළිතුරු දීමට ය:

මා එසේ කරන විට obj.property, JS සොයන්නේ .propertyකොහෙන්ද?

බුද්ධිමය වශයෙන්, සම්භාව්‍ය උරුමය දේපල සෙවීමට බලපායි.

2)

• __proto__තිත් .දේපල සෙවීම සඳහා භාවිතා වේ obj.property.
• .prototypeඇත නැත වක්රව එය තීරණය ලෙස පමණක්, කෙලින්ම බැලීම සඳහා භාවිතා __proto__සහිත වස්තුවක්, අනගි නිර්මාණය new.

බැලීමේ අනුපිළිවෙල:

• objසමග එකතු ගුණ obj.p = ...හෝObject.defineProperty(obj, ...)
• හි ගුණාංග obj.__proto__
• ගුණාංග obj.__proto__.__proto__සහ යනාදිය
• සමහරක් __proto__නම් null, ආපසු යන්න undefined.

මෙය ඊනියා මූලාකෘති දාමයයි .

සහ .සමඟ බැලීම වළක්වා ගත හැකියobj.hasOwnProperty('key')Object.getOwnPropertyNames(f)

3) සැකසීමට ප්‍රධාන ක්‍රම දෙකක් තිබේ obj.__proto__:

• new:

  var F = function() {}
  var f = new F()

  පසුව newසකසා ඇත:

  f.__proto__ === F.prototype

  මෙම කොහේ .prototypeඋපයෝගී.

• Object.create:

   f = Object.create(proto)

  කට්ටල:

  f.__proto__ === proto

4) කේතය:

var F = function(i) { this.i = i }
var f = new F(1)

පහත රූපසටහනට අනුරූප වේ (සමහර Numberදේවල් මඟ හැරී ඇත):

(Function)       (  F  )                                      (f)----->(1)
 |  ^             | | ^                                        |   i    |
 |  |             | | |                                        |        |
 |  |             | | +-------------------------+              |        |
 |  |constructor  | |                           |              |        |
 |  |             | +--------------+            |              |        |
 |  |             |                |            |              |        |
 |  |             |                |            |              |        |
 |[[Prototype]]   |[[Prototype]]   |prototype   |constructor   |[[Prototype]]
 |  |             |                |            |              |        |
 |  |             |                |            |              |        |
 |  |             |                | +----------+              |        |
 |  |             |                | |                         |        |
 |  |             |                | | +-----------------------+        |
 |  |             |                | | |                                |
 v  |             v                v | v                                |
(Function.prototype)              (F.prototype)                         |
 |                                 |                                    |
 |                                 |                                    |
 |[[Prototype]]                    |[[Prototype]]          [[Prototype]]|
 |                                 |                                    |
 |                                 |                                    |
 | +-------------------------------+                                    |
 | |                                                                    |
 v v                                                                    v
(Object.prototype)                                       (Number.prototype)
 | | ^
 | | |
 | | +---------------------------+
 | |                             |
 | +--------------+              |
 |                |              |
 |                |              |
 |[[Prototype]]   |constructor   |prototype
 |                |              |
 |                |              |
 |                | -------------+
 |                | |
 v                v |
(null)           (Object)

මෙම රූප සටහන බොහෝ භාෂා පූර්ව නිශ්චිත වස්තු නෝඩ් පෙන්වයි:

• null
• Object
• Object.prototype
• Function
• Function.prototype
• 1
• Number.prototype( (1).__proto__සින්ටැක්ස් තෘප්තිමත් කිරීම සඳහා වරහන් අනිවාර්යය සමඟ සොයාගත හැකිය )

අපගේ කේත පේළි 2 නිර්මාණය කළේ පහත සඳහන් නව වස්තු පමණි:

• f
• F
• F.prototype

iදැන් දේපලක් fවන්නේ ඔබ එසේ කරන විට:

var f = new F(1)

එය ඇගයීමට ලක් Fසමග thisබව අගය කරමින් newපසුව පවරා ලක්වෙයි වන, ආපසුf .

5) .constructor සාමාන්යයෙන් පැමිණෙන්නේ F.prototypeහරහා .බැලීම:

f.constructor === F
!f.hasOwnProperty('constructor')
Object.getPrototypeOf(f) === F.prototype
F.prototype.hasOwnProperty('constructor')
F.prototype.constructor === f.constructor

අප ලියන විට f.constructor, ජාවාස්ක්‍රිප්ට් විසින් .සෙවීම සිදු කරන්නේ:

• f නැත .constructor
• f.__proto__ === F.prototype ඇත .constructor === F , එබැවින් එය ගන්න

සම්භාව්‍ය OOP භාෂාවලට සමානව, ක්ෂේත්‍ර සැකසීම සඳහා භාවිතා කරන f.constructor == Fබැවින්, ප්‍රති result ලය බුද්ධිමත්ව නිවැරදි ය .Ff

6) මූලාකෘති දාම හැසිරවීමෙන් සම්භාව්‍ය උරුම සින්ටැක්ස් ලබා ගත හැකිය.

ඊඑස් 6 classසහ extendsමූල පද එකතු කරයි , ඒවා බොහෝ විට කලින් කළ හැකි මූලාකෘති හැසිරවීමේ පිස්සුව සඳහා සින්ටැක්ස් සීනි වේ.

class C {
    constructor(i) {
        this.i = i
    }
    inc() {
        return this.i + 1
    }
}

class D extends C {
    constructor(i) {
        super(i)
    }
    inc2() {
        return this.i + 2
    }
}

// Inheritance syntax works as expected.
c = new C(1)
c.inc() === 2
(new D(1)).inc() === 2
(new D(1)).inc2() === 3

// "Classes" are just function objects.
C.constructor === Function
C.__proto__ === Function.prototype
D.constructor === Function
// D is a function "indirectly" through the chain.
D.__proto__ === C
D.__proto__.__proto__ === Function.prototype

// "extends" sets up the prototype chain so that base class
// lookups will work as expected
var d = new D(1)
d.__proto__ === D.prototype
D.prototype.__proto__ === C.prototype
// This is what `d.inc` actually does.
d.__proto__.__proto__.inc === C.prototype.inc

// Class variables
// No ES6 syntax sugar apparently:
// http://stackoverflow.com/questions/22528967/es6-class-variable-alternatives
C.c = 1
C.c === 1
// Because `D.__proto__ === C`.
D.c === 1
// Nothing makes this work.
d.c === undefined

සියලු පූර්ව නිශ්චිත වස්තු නොමැතිව සරල කළ රූප සටහන:

(c)----->(1)
 |   i
 |
 |
 |[[Prototype]]
 |
 |
 v    __proto__
(C)<--------------(D)         (d)
| |                |           |
| |                |           |
| |prototype       |prototype  |[[Prototype]] 
| |                |           |
| |                |           |
| |                | +---------+
| |                | |
| |                | |
| |                v v
|[[Prototype]]    (D.prototype)--------> (inc2 function object)
| |                |             inc2
| |                |
| |                |[[Prototype]]
| |                |
| |                |
| | +--------------+
| | |
| | |
| v v
| (C.prototype)------->(inc function object)
|                inc
v
Function.prototype

පහත සඳහන් දෑ ක්‍රියාත්මක වන ආකාරය අධ්‍යයනය කිරීමට අපි මොහොතක් ගත කරමු:

c = new C(1)
c.inc() === 2

පළමු පේළිය සකසයි c.i1 "4)" හි විස්තර කර ඇති ආකාරයට ඇත .

දෙවන පේළියේ, අප කරන විට:

c.inc()

• .inc[[Prototype]]දාමය හරහා හමු වේ : c-> C->C.prototype ->inc
• අපි ජාවාස්ක්‍රිප්ට් හි ශ්‍රිතයක් ලෙස හැඳින්වූ විට X.Y(), ජාවාස්ක්‍රිප්ට් ස්වයංක්‍රීයව ඇතුළත thisසමාන XවේY() ශ්‍රිත ඇමතුම වේ.

හරියටම එකම තර්කනය ද පැහැදිලි කරයි d.inc සහ d.inc2.

මෙම ලිපිය https://javascript.info/class#not-just-a-syntax-sugar තවදුරටත් බලපෑම් සඳහන් classදැන වටිනවා. ඒවායින් සමහරක් classමූල පදය නොමැතිව සාක්ෂාත් කරගත නොහැකි විය හැකිය (TODO check which):

• [[FunctionKind]]:"classConstructor", එය නවක සමඟ ඉදිකිරීම්කරු කැඳවීමට බල කරයි: ES6 පන්තියේ ඉදිකිරීම්කරුවන් සාමාන්‍ය කාර්යයන් ලෙස හැඳින්වීමට හේතුව කුමක්ද?
• පන්ති ක්‍රම ගණන් කළ නොහැකි ය. සමඟ කළ හැකියObject.defineProperty .
• පන්ති සෑම විටම use strict. use strictසෑම කාර්යයක් සඳහාම පැහැදිලිව කළ හැකි අතර එය පිළිගත හැකි ය.

prototypeපන්ති කිරීමට ඔබට ඉඩ සලසයි. ඔබ භාවිතා නොකරන්නේ නම්prototype නම් එය ස්ථිතික බවට පත්වේ.

මෙන්න කෙටි උදාහරණයක්.

var obj = new Object();
obj.test = function() { alert('Hello?'); };

ඉහත අවස්ථාවෙහිදී, ඔබට ස්ථිතික විනෝද ඇමතුම් පරීක්ෂණයක් ඇත. මෙම ශ්‍රිතයට ප්‍රවේශ විය හැක්කේ obj.test මඟින් පමණි.

පහත කේතයේ මෙන්

function obj()
{
}

obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();

වස්තුව දැන් ක්ෂණිකව කළ හැකි පන්තියක් බවට පත්ව ඇත. Obj හි බහුවිධ අවස්ථා පැවතිය හැකි අතර ඒවා සියල්ලටම ඇතtest ක්‍රියාකාරීත්වයක් ඇත.

ඉහත දැක්වෙන්නේ මගේ අවබෝධයයි. මම එය ප්‍රජා විකියක් බවට පත් කරමි, එබැවින් මා වැරදියි නම් මිනිසුන්ට මාව නිවැරදි කළ හැකිය.

මෙම ත්‍රෙඩ් එක කියවීමෙන් පසු මට ජාවාස්ක්‍රිප්ට් මූලාකෘති දාමය සමඟ ව්‍යාකූල බවක් දැනේ, එවිට මට මෙම ප්‍රස්ථාර හමු විය

http://iwiki.readthedocs.org/en/latest/javascript/js_core.html#inheritance

මූලාකෘති දාමය මගින් ජාවාස්ක්‍රිප්ට් උරුමය පෙන්වීමට එය පැහැදිලි සටහනකි

සහ

http://www.javascriptbank.com/javascript/article/JavaScript_Classical_Inheritance/

මෙහි කේත සහ හොඳ රූප සටහන් කිහිපයක් සහිත උදාහරණයක් අඩංගු වේ.

මූලාකෘති දාමය අවසානයේ Object.prototype වෙත වැටේ.

මූලාකෘති දාමය ඔබට අවශ්‍ය තාක් දුරට තාක්ෂණික වශයෙන් දීර් can කළ හැකිය, සෑම අවස්ථාවකදීම උප පංතියේ මූලාකෘතිය මව් පන්තියේ වස්තුවකට සමාන ලෙස සැකසීම.

ජාවාස්ක්‍රිප්ට් මූලාකෘති දාමය අවබෝධ කර ගැනීමටද එය ප්‍රයෝජනවත් වේ යැයි සිතමු.

සෑම වස්තුවකටම අභ්‍යන්තර දේපලක් ඇත, [[මූලාකෘති]] , එය වෙනත් වස්තුවකට සම්බන්ධ කරයි:

object [[Prototype]] → anotherObject

සාම්ප්‍රදායික ජාවාස්ක්‍රිප්ට් වලදී, සම්බන්ධිත වස්තුව prototypeශ්‍රිතයක දේපල වේ:

object [[Prototype]] → aFunction.prototype

සමහර පරිසරයන් [[මූලාකෘති]] පහත පරිදි නිරාවරණය කරයි __proto__:

anObject.__proto__ === anotherObject

වස්තුවක් නිර්මාණය කිරීමේදී ඔබ [[මූලාකෘති]] සබැඳිය සාදයි.

// (1) Object.create:
var object = Object.create(anotherObject)
// object.__proto__ = anotherObject

// (2) ES6 object initializer:
var object = { __proto__: anotherObject };
// object.__proto__ = anotherObject

// (3) Traditional JavaScript:
var object = new aFunction;
// object.__proto__ = aFunction.prototype

එබැවින් මෙම ප්‍රකාශ සමාන වේ:

var object = Object.create(Object.prototype);
var object = { __proto__: Object.prototype }; // ES6 only
var object = new Object;

නව ප්‍රකාශයකින් ඔබට සබැඳි ඉලක්කය ( Object.prototype) සැබවින්ම දැකිය නොහැක ; ඒ වෙනුවට ඉලක්කය ඉදිකිරීම්කරු විසින් ගම්‍ය වේ (Object ) විසිනි.

මතක තබා ගන්න:

• සෑම වස්තුවකටම සබැඳියක් ඇත, [[මූලාකෘති]] , සමහර විට __proto__ ලෙස නිරාවරණය වේ .
• සෑම ශ්‍රිතයක්ම a prototype දේපලක් ඇත, මුලින් හිස් වස්තුවක් දරයි.
• අළුත් දේ සමඟ නිර්මාණය කරන ලද වස්තු සම්බන්ධ වේprototype ඒවායේ ඉදිකිරීම්කරුගේ දේපල හා .
• ශ්‍රිතයක් කිසි විටෙක ඉදිකිරීම්කරුවෙකු ලෙස භාවිතා නොකරන්නේ නම්, එය prototype දේපල භාවිතයට නොගනී.
• ඔබට ඉදිකිරීම්කරුවෙකු අවශ්‍ය නොවේ නම්, ඒ වෙනුවට Object.create භාවිතා කරන්න new.

සාමාන්‍ය අර්ථයෙන් ජාවාස්ක්‍රිප්ට උරුමයක් නැත, නමුත් එයට මූලාකෘති දාමය ඇත.

මූලාකෘති දාමය

වස්තුවක සාමාජිකයෙකු වස්තුව තුළ සොයාගත නොහැකි නම් එය මූලාකෘති දාමයේ සොයයි. දාමය වෙනත් වස්තූන්ගෙන් සමන්විත වේ. දී ඇති අවස්ථාවක මූලාකෘතිය __proto__විචල්‍යය සමඟ ප්‍රවේශ විය හැකිය . ජාවාස්ක්‍රිප්ට් හි පන්ති සහ සිද්ධීන් අතර වෙනසක් නොමැති බැවින් සෑම වස්තුවකටම එකක් තිබේ.

මූලාකෘතියට ශ්‍රිතයක් / විචල්‍යයක් එක් කිරීමේ වාසිය නම්, එය මතකයේ තිබිය යුත්තේ එක් වරක් පමණි, සෑම අවස්ථාවකටම නොවේ.

එය උරුමය සඳහා ද ප්‍රයෝජනවත් වේ, මන්ද මූලාකෘති දාමයට වෙනත් බොහෝ වස්තු වලින් සමන්විත විය හැකි බැවිනි.

මෙම ලිපිය දිගු ය. නමුත් ජාවාස්ක්‍රිප්ට් උරුමයේ “මූලාකෘති” ස්වභාවය පිළිබඳ ඔබගේ බොහෝ විමසීම් එයින් ඉවත් වනු ඇතැයි මට විශ්වාසයි. ඊටත් වඩා. කරුණාකර සම්පූර්ණ ලිපිය කියවන්න.

ජාවාස්ක්‍රිප්ට් මූලික වශයෙන් දත්ත වර්ග දෙකක් ඇත

• වස්තු නොවන
• වස්තු

වස්තු නොවන

වස්තු නොවන දත්ත වර්ග පහත දැක්වේ

• නූල්
• අංකය (NaN සහ Infinity ඇතුළුව)
• බූලියන් අගයන් (සත්‍ය, අසත්‍ය)
• නිර්වචනය නොකළ

ඔබ යතුරු ලියන ක්‍රියාකරු භාවිතා කරන විට මෙම දත්ත වර්ග පහත දැක්වේ

typeof "string literal" (හෝ වචනාර්ථයෙන් වචන අඩංගු විචල්‍යයක්) === 'string'

typeof 5 (හෝ ඕනෑම සංඛ්‍යාත්මක වචනාර්ථයක් හෝ සංඛ්‍යාත්මක වචනාර්ථයක් හෝ NaN හෝ Infynity අඩංගු විචල්‍යයක් ) === 'අංකය'

typeof true (හෝ අසත්‍ය හෝ සත්‍ය හෝ අසත්‍ය අඩංගු විචල්‍යයක් ) === 'බූලියන්'

typeof නිර්වචනය නොකළ (හෝ නිර්වචනය නොකළ විචල්ය හෝ අඩංගු විචල්ය නිර්වචනය නොකළ ) === 'නිර්වචනය නොකළ'

මෙම සංගීත , අංකය සහ වීජ දත්ත වර්ග ලෙස දෙකම නියෝජනය කළ හැකි වස්තූන් හා විරුද්ධ නොවන ඔවුන්ගේ typeof සෑම විටම === 'වස්තුව' වන විරුද්ධ ලෙස ඔවුන් නියෝජනය කරනු .ඒ. වස්තු දත්ත වර්ග තේරුම් ගත් පසු අපි නැවත මේ වෙත පැමිණෙමු.

වස්තු

වස්තු දත්ත සමුදායන් තවදුරටත් වර්ග දෙකකට බෙදිය හැකිය

1. ක්‍රියාකාරී වර්ගයේ වස්තු
2. ක්‍රියාකාරී නොවන වර්ගයේ වස්තු

ටයිප් ඔෆ් ඔපරේටර් සමඟ 'ශ්‍රිතය' නූල නැවත ලබා දෙන්නේ ශ්‍රිත වර්ග වස්තු ය . සියලුම පරිශීලකයින් විසින් අර්ථ දක්වා ඇති කාර්යයන් සහ නව ක්‍රියාකරු භාවිතා කිරීමෙන් නව වස්තු නිර්මාණය කළ හැකි වස්තූන් තුළ ගොඩනගා ඇති සියලුම ජාවාස්ක්‍රිප්ට් මෙම ගණයට වැටේ. උදා.

• වස්තුව
• නූල්
• අංකය
• බූලියන්
• අරාව
• ටයිප් කළ අරා
• RegExp
• ක්රියාකාරිත්වය
• නව ක්‍රියාකරු භාවිතා කිරීමෙන් නව වස්තූන් නිර්මාණය කළ හැකි අනෙක් සියලුම වස්තු වලින් සාදා ඇත
• UserDefinedFunction () function / * පරිශීලක අර්ථ දක්වා ඇති කේතය * /}

ඉතින්, typeof (Object) === typeof (String) === typeof (Number) === typeof (Boolean) === typeof (Array) === typeof (RegExp) === typeof (Function) == = typeof (UserDefinedFunction) === 'ශ්‍රිතය'

සියලුම ක්‍රියාකාරී වර්ගයේ වස්තූන් සැබවින්ම ජාවාස්ක්‍රිප්ට් වස්තු ශ්‍රිතය තුළ සාදන ලද අවස්ථා වේ ( ක්‍රියාකාරී වස්තුව ද ඇතුළුව එය පුනරාවර්තන ලෙස අර්ථ දක්වා ඇත). මෙම වස්තූන් පහත දැක්වෙන ආකාරයට අර්ථ දක්වා ඇත

var Object= new Function ([native code for object Object])
var String= new Function ([native code for object String])
var Number= new Function ([native code for object Number])
var Boolean= new Function ([native code for object Boolean])
var Array= new Function ([native code for object Array])
var RegExp= new Function ([native code for object RegExp])
var Function= new Function ([native code  for object Function])
var UserDefinedFunction= new Function ("user defined code")

සඳහන් කළ පරිදි, ක්‍රියාකාරී වර්ගයේ වස්තූන් හට නව ක්‍රියාකරු භාවිතා කර නව වස්තු නිර්මාණය කළ හැකිය . වර්ගය උදා වස්තුවක් සඳහා වස්තූන් , සංගීත , අංකය , බූලියන් , Array , RegExp නැත්නම් UserDefinedFunction භාවිතා විසින් නිර්මාණය කළ හැකි

var a=new Object() or var a=Object() or var a={} //Create object of type Object
var a=new String() //Create object of type String
var a=new Number() //Create object of type Number
var a=new Boolean() //Create object of type Boolean
var a=new Array() or var a=Array() or var a=[]  //Create object of type Array
var a=new RegExp() or var a=RegExp() //Create object of type RegExp
var a=new UserDefinedFunction() 

මෙලෙස නිර්මාණය කරන ලද වස්තූන් සියල්ලම ක්‍රියාකාරී නොවන වර්ගයේ වස්තූන් වන අතර ඒවායේ typeof === 'object' ආපසු ලබා දේ . මෙම සියලු අවස්ථාවන්හිදී "a" වස්තුවට නව ක්‍රියාකරු භාවිතා කරමින් වස්තු තවදුරටත් නිර්මාණය කළ නොහැක. එබැවින් පහත දැක්වෙන්නේ වැරදිය

var b=new a() //error. a is not typeof==='function'

ගණිතය තුළ ගොඩනගා ඇත්තේ typeof === 'object' වේ. එබැවින් ගණිතයේ නව වස්තුවක් නව ක්‍රියාකරුට නිර්මාණය කළ නොහැක.

var b=new Math() //error. Math is not typeof==='function'

ද සිටින බව දැනුම් වස්තූන් , Array හා RegExp කාර්යයන් භාවිතා පවා තොරව නව වස්තුව නිර්මාණය කළ හැකි නව ක්රියාකරු . කෙසේවෙතත්, මෝඩයන් එසේ නොකරයි.

var a=String() // Create a new Non Object string. returns a typeof==='string' 
var a=Number() // Create a new Non Object Number. returns a typeof==='number'
var a=Boolean() //Create a new Non Object Boolean. returns a typeof==='boolean'

පරිශීලක අර්ථ දක්වන ලද කාර්යයන් විශේෂ අවස්ථාවකි.

var a=UserDefinedFunction() //may or may not create an object of type UserDefinedFunction() based on how it is defined.

සිට කාර්යභාරය වර්ගය වස්තු නව වස්තූන් නිර්මාණය කළ හැකි අය ද කැඳවා ඇත ඉදිකරන්නන් .

ස්වයංක්‍රීයව නිර්වචනය කරන විට සෑම ඉදිකිරීම්කරුවෙකු / කාර්යයක්ම (ගොඩනගා ඇති හෝ පරිශීලකයා අර්ථ දක්වා තිබේද) ස්වයංක්‍රීයව “මූලාකෘති” නමින් දේපලක් ඇති අතර එහි අගය පෙරනිමියෙන් වස්තුවක් ලෙස සකසා ඇත. මෙම වස්තුවට “ඉදිකිරීම්කරු” නමින් දේපලක් ඇති අතර එය පෙරනිමියෙන් ඉදිකිරීම්කරු / ශ්‍රිතය සඳහන් කරයි.

උදාහරණයක් ලෙස අපි ශ්‍රිතයක් අර්ථ දක්වන විට

function UserDefinedFunction()
{
}

පහත දැක්වෙන දේ ස්වයංක්‍රීයව සිදු වේ

UserDefinedFunction.prototype={constructor:UserDefinedFunction}

මෙම "මූලාකෘති" ගුණාංගය පවතින්නේ ශ්‍රිත වර්ගයේ වස්තූන් තුළ පමණි (සහ කිසි විටෙකත් ක්‍රියාකාරී නොවන ආකාරයේ වස්තු වල ).

මෙයට හේතුව නව වස්තුවක් නිර්මාණය වූ විට (නව ක්‍රියාකරු භාවිතා කරමින්) එය ඉදිකිරීම්කරුගේ වර්තමාන මූලාකෘති වස්තුවෙන් සියලු ගුණාංග සහ ක්‍රමවේදයන් උරුම කර ගැනීමයි. එනම් , අලුතින් සාදන ලද වස්තුව තුළ අභ්‍යන්තර යොමු කිරීමක් සාදනු ලැබේ.

උරුම වූ දේපල යොමු කිරීම සඳහා වස්තුව තුළ නිර්මාණය කර ඇති මෙම "අභ්‍යන්තර යොමු කිරීම" වස්තුවේ මූලාකෘතිය ලෙස හැඳින්වේ (එය ඉදිකිරීම්කරුගේ "මූලාකෘති" දේපල මගින් යොමු කරන ලද වස්තුව යොමු කරන නමුත් ඊට වඩා වෙනස් වේ). ඕනෑම වස්තුවක් සඳහා (ශ්‍රිතය හෝ ක්‍රියාකාරී නොවන) Object.getPrototypeOf () ක්‍රමය භාවිතයෙන් මෙය ලබා ගත හැකිය . මෙම ක්‍රමය භාවිතා කිරීමෙන් කෙනෙකුට වස්තුවක මූලාකෘති දාමය සොයාගත හැකිය.

එසේම, නිර්මාණය කරන ලද සෑම වස්තුවකටම ( ක්‍රියාකාරී වර්ගය හෝ ක්‍රියාකාරී නොවන වර්ගය ) “ඉදිකිරීම්කරු” දේපලක් ඇති අතර එය ඉදිකිරීම්කරු ශ්‍රිතයේ මූලාකෘති දේපල මගින් යොමු කරන ලද වස්තුවෙන් උරුම වේ. සාමාන්යයෙන් මෙම "ඉදිකිරීමටත්" දේපළ නිර්දේශන ඉදිකිරීම් කාර්යය එය නිර්මාණය කළ බව (මෙම නම් ඉදිකිරීම් කාර්යයන් ගේ පෙරනිමි "මූලාකෘතියක්" වෙනස් නැත).

සියළුම ශ්‍රිත වර්ග වස්තු සඳහා, ඉදිකිරීම්කරුගේ ශ්‍රිතය සැමවිටම ශ්‍රිතය වේ.

සඳහා ශ්රිතය නොවන වර්ගය වස්තු (උදා: කරුණාකර Javascript ගණිත වස්තුව දී ඉදි කළ) එම ඉදිකිරීමටත් කාර්යය එය නිර්මාණය කළ බව සඳහන් කාර්යයකි. සඳහා ගණිත වස්තුව එය කාර්යය වස්තූන් () {} .

ඉහත විස්තර කර ඇති සියලුම සංකල්ප කිසිදු උපකාරක කේතයකින් තොරව තේරුම් ගැනීමට ටිකක් බිය විය හැකිය. සංකල්පය අවබෝධ කර ගැනීමට කරුණාකර පහත කේත රේඛාව රේඛාව ඔස්සේ යන්න. වඩා හොඳ අවබෝධයක් ලබා ගැනීම සඳහා එය ක්‍රියාත්මක කිරීමට උත්සාහ කරන්න.

function UserDefinedFunction()
{ 

} 

/* creating the above function automatically does the following as mentioned earlier

UserDefinedFunction.prototype={constructor:UserDefinedFunction}

*/


var newObj_1=new UserDefinedFunction()

alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays true

alert(newObj_1.constructor) //Displays function UserDefinedFunction

//Create a new property in UserDefinedFunction.prototype object

UserDefinedFunction.prototype.TestProperty="test"

alert(newObj_1.TestProperty) //Displays "test"

alert(Object.getPrototypeOf(newObj_1).TestProperty)// Displays "test"

//Create a new Object

var objA = {
        property1 : "Property1",
        constructor:Array

}


//assign a new object to UserDefinedFunction.prototype
UserDefinedFunction.prototype=objA

alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays false. The object referenced by UserDefinedFunction.prototype has changed

//The internal reference does not change
alert(newObj_1.constructor) // This shall still Display function UserDefinedFunction

alert(newObj_1.TestProperty) //This shall still Display "test" 

alert(Object.getPrototypeOf(newObj_1).TestProperty) //This shall still Display "test"


//Create another object of type UserDefinedFunction
var newObj_2= new UserDefinedFunction();

alert(Object.getPrototypeOf(newObj_2)===objA) //Displays true.

alert(newObj_2.constructor) //Displays function Array()

alert(newObj_2.property1) //Displays "Property1"

alert(Object.getPrototypeOf(newObj_2).property1) //Displays "Property1"

//Create a new property in objA
objA.property2="property2"

alert(objA.property2) //Displays "Property2"

alert(UserDefinedFunction.prototype.property2) //Displays "Property2"

alert(newObj_2.property2) // Displays Property2

alert(Object.getPrototypeOf(newObj_2).property2) //Displays  "Property2"

සෑම වස්තුවකම මූලාකෘති දාමය අවසානයේ Object.prototype වෙත යොමු වේ (එයට කිසිදු මූලාකෘති වස්තුවක් නොමැත). වස්තුවක මූලාකෘති දාමය සොයා ගැනීම සඳහා පහත කේතය භාවිතා කළ හැකිය

var o=Starting object;

do {
    alert(o + "\n" + Object.getOwnPropertyNames(o))

}while(o=Object.getPrototypeOf(o))

විවිධ වස්තූන් සඳහා වන මූලාකෘති දාමය පහත පරිදි ක්‍රියාත්මක වේ.

• සෑම ක්‍රියාකාරී වස්තුවක්ම (ක්‍රියාකාරී වස්තුව තුළ ගොඩනගා තිබීම ඇතුළුව) -> Function.prototype -> Object.prototype -> null
• සරල වස්තූන් (නව වස්තුවක් () හෝ ගණිත වස්තුව තුළ සාදන ලද ඇතුළුව}}) -> Object.prototype -> null
• නව හෝ Object.create -> මූලාකෘති දාම එකක් හෝ වැඩි ගණනක් සමඟ නිර්මාණය කරන ලද වස්තුව -> Object.prototype -> null

කිසිදු මූලාකෘතියකින් තොරව වස්තුවක් නිර්මාණය කිරීම සඳහා පහත සඳහන් දෑ භාවිතා කරන්න:

var o=Object.create(null)
alert(Object.getPrototypeOf(o)) //Displays null

ඉදිකිරීම්කරුගේ මූලාකෘති දේපල ශුන්‍යයට සැකසීම ශුන්‍ය මූලාකෘතියක් සහිත වස්තුවක් නිර්මාණය කරනු ඇතැයි කෙනෙකුට සිතිය හැකිය. කෙසේ වෙතත් එවැනි අවස්ථාවන්හිදී අලුතින් සාදන ලද වස්තුවේ මූලාකෘතිය Object.prototype ලෙස සකසා ඇති අතර එහි ඉදිකිරීම්කරු වස්තුව ක්‍රියාත්මක කිරීමට සකසා ඇත. මෙය පහත කේතය මගින් පෙන්නුම් කෙරේ

function UserDefinedFunction(){}
UserDefinedFunction.prototype=null// Can be set to any non object value (number,string,undefined etc.)

var o=new UserDefinedFunction()
alert(Object.getPrototypeOf(o)==Object.prototype)   //Displays true
alert(o.constructor)    //Displays Function Object

මෙම ලිපියේ සාරාංශය පහත දැක්වේ

• වස්තු වර්ග දෙකක් ඇත ක්‍රියාකාරී වර්ග සහ ක්‍රියාකාරී නොවන වර්ග

• ක්‍රියාකරු නව භාවිතා කරමින් නව වස්තුවක් නිර්මාණය කළ හැක්කේ ශ්‍රිත වර්ගයේ වස්තු වලට පමණි . මෙසේ නිර්මාණය කරන ලද වස්තූන් ක්‍රියාකාරී නොවන වර්ගයේ වස්තු වේ. ක්‍රියා විරහිත ආකාරයේ වස්තු වලට ක්‍රියාකරු නව භාවිතා කරමින් වස්තුවක් තවදුරටත් නිර්මාණය කළ නොහැක .

• පෙරනිමියෙන් සියලුම ක්‍රියාකාරී වර්ගවල වස්තු වලට "මූලාකෘති" ගුණාංගයක් ඇත. මෙම "මූලාකෘති" ගුණාංගය මඟින් "ඉදිකිරීම්කරු" දේපලක් ඇති වස්තුවක් පෙරනිමියෙන් ශ්‍රිත වර්ගයේ වස්තුවම සඳහන් කරයි.

• සියළුම වස්තූන් ( ක්‍රියාකාරී වර්ගය සහ ක්‍රියාකාරී නොවන වර්ගය ) සතුව “ඉදිකිරීම්කරු” දේපලක් ඇති අතර එය පෙරනිමියෙන් එය නිර්මාණය කළ ශ්‍රිත වර්ග වස්තුව / ඉදිකිරීම්කරු සඳහන් කරයි.

• අභ්‍යන්තරව නිර්මාණය වන සෑම වස්තුවක්ම එය නිර්මාණය කළ ඉදිකිරීම්කරුගේ “මූලාකෘති” දේපල මගින් යොමු කරන ලද වස්තුව ගැන සඳහන් කරයි. මෙම වස්තුව හැඳින්වෙන්නේ නිර්මාණය කරන ලද වස්තුවේ මූලාකෘතිය ලෙසය (එය ක්‍රියාකාරී වර්ගයේ වස්තූන් "මූලාකෘති" දේපල වලට වඩා වෙනස් වේ). මේ ආකාරයෙන් නිර්මාණය කරන ලද වස්තුවට ඉදිකිරීම්කරුගේ “මූලාකෘති” දේපල (වස්තු නිර්මාණය කරන අවස්ථාවේ) විසින් යොමු කරන ලද වස්තුවෙහි අර්ථ දක්වා ඇති ක්‍රම සහ ගුණාංග වෙත කෙලින්ම පිවිසිය හැකිය.

• ක වස්තුව ගේ මූලාකෘතියක් (සහ ඒ නිසා එහි උරුම දේපල නම්) භාවිතා ලබා ගත හැක Object.getPrototypeOf () ක්රමය. ඇත්ත වශයෙන්ම මෙම ක්‍රමය වස්තුවේ සමස්ත මූලාකෘති දාමය සැරිසැරීම සඳහා භාවිතා කළ හැකිය.

• සෑම වස්තුවකම මූලාකෘති දාමය අවසානයේ Object.prototype වෙතට දිව යයි (වස්තුව නිර්මාණය කර නොමැති නම් Object.create (null) භාවිතා කර වස්තුවට මූලාකෘතියක් නොමැති අවස්ථාවක).

• typeof (new Array ()) === 'වස්තුව' යනු භාෂාවේ සැලසුම අනුව මිස ඩග්ලස් ක්‍රොක්ෆර්ඩ් පෙන්වා දුන් වැරැද්දක් නොවේ

• ඉදිකිරීම්කරුගේ මූලාකෘති දේපල ශුන්‍ය (හෝ නිර්වචනය නොකළ, අංක, සත්‍ය, අසත්‍ය, නූල්) ලෙස සැකසීම ශුන්‍ය මූලාකෘතියක් සහිත වස්තුවක් නිර්මාණය නොකරයි. එවැනි අවස්ථාවන්හිදී අලුතින් සාදන ලද වස්තුවේ මූලාකෘතිය Object.prototype ලෙස සකසා ඇති අතර එහි ඉදිකිරීම්කරු වස්තුව ක්‍රියාත්මක කිරීමට සකසා ඇත.

මෙය උපකාරී වේ යැයි සිතමි.

prototypalඋරුමය පිළිබඳ සංකල්පය බොහෝ සංවර්ධකයින් සඳහා වඩාත් සංකීර්ණ එකකි. prototypal inheritanceවඩා හොඳින් තේරුම් ගැනීම සඳහා ගැටලුවේ මුල තේරුම් ගැනීමට උත්සාහ කරමු . plainශ්‍රිතයකින් ආරම්භ කරමු .

අපි newක්‍රියාකරු භාවිතා කරන්නේ නම් Tree function, අපි එය constructorශ්‍රිතයක් ලෙස හඳුන්වමු .

සෑම JavaScriptශ්‍රිතයක්ම a prototype. ඔබ ලොග් වූ විට Tree.prototype, ඔබට ලැබෙනු ඇත ...

ඔබ ඉහත console.log()ප්‍රතිදානය දෙස බැලුවහොත් , ඔබට ඉදිකිරීම්කරුගේ දේපලක් Tree.prototypeසහ දේපලක් දැක ගත හැකිය __proto__. මෙම __proto__නියෝජනයprototype බව , මෙය තවම සකසා නැති functionතැනිතලාවක් බැවින්, එය යොමු දක්වන්නේ ජාවාස්ක්‍රිප්ට් වෙත ගොඩනගා ඇති දෙයක් ...JavaScript functioninheritanceObject prototype

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype

මේ වගේ දේවල් තියෙනවා .toString, .toValue, .hasOwnProperty...

__proto__ගෙන ආ මගේ මොසිල්ලා අතහැර දමා ඇති අතර එය Object.getPrototypeOfලබා ගැනීමේ ක්‍රමවේදය මගින් ප්‍රතිස්ථාපනය object's prototypeවේ.

Object.getPrototypeOf(Tree.prototype); // Object {} 

අපිට ක්‍රමයක් එකතු කරමු Tree prototype .

අපි වෙනස් කර Rootafunction ශාඛාවක් .

ඒ කියන්නේ ඔබ නිර්මාණය කරන instanceවිට Tree, ඔබට එය branchක්‍රමය ලෙස හැඳින්විය හැකිය .

අපට අපගේ primitivesහෝ එකතු කළ හැකිය .objectsPrototype

ගේ එකතු කරමු child-treeඅපගේ Tree.

මෙන්න Childඑය prototypeගසෙන් උරුම වේ, අප මෙහි කරන්නේ Object.create()ඔබ සමත් වූ දේ පදනම් කරගෙන නව වස්තුවක් නිර්මාණය කිරීමේ ක්‍රමයයි, මෙන්න එයයි Tree.prototype. මේ අවස්ථාවේ දී අප කරන්නේ ළමා මූලාකෘතිය මූලාකෘතියට සමාන නව වස්තුවකට සැකසීමයි Tree. ඊළඟට අපි එය සකසමු Child's constructor to Child, අප එසේ නොකළහොත් එය යොමු වනු ඇත Tree().

Childදැන් එයටම ආවේණික වූ අතර prototype, එහි __proto__ලකුණු Treeහා Tree's prototypeපාදම දක්වා ඇත Object.

Child  
|
 \
  \
   Tree.prototype
   - branch
   |
   |
    \
     \
      Object.prototype
      -toString
      -valueOf
      -etc., etc.

දැන් ඔබ නිර්මාණය instanceකිරීම Childහා ඇමතුමක් branchදී මුලින් ලබා ගත හැකි වන Tree. අපි ඇත්ත වශයෙන්ම අපේ branchමත අර්ථ දක්වා නැත Child prototype. එහෙත්, Root prototypeදරුවාට උරුම වූ.

JS හි සෑම දෙයක්ම වස්තුවක් නොවේ, සෑම දෙයක්ම වස්තුවක් ලෙස ක්‍රියා කළ හැකිය.

Javascriptstrings, number, booleans, undefined, null.ඒවා නැති තරම් ප්‍රාථමිකයන් ඇත object(i.e reference types), නමුත් නිසැකවම එය මෙන් ක්‍රියා කළ හැකිය object. මෙහි උදාහරණයක් බලමු.

මෙම ලැයිස්තුගත කිරීමේ පළමු පේළියේ දී, primitiveනමක් සඳහා නමක් ලබා දී ඇත. දෙවන පේළියේ නම a ලෙස සලකන අතර තිත් අංකනය භාවිතා කර objectඇමතුම් ලබා charAt(0)ගනී.

තිරය ​​පිටුපස සිදුවන්නේ මෙයයි: // JavaScriptඑන්ජිම කරන දේ

මෙම String objectඑය විනාශ වීමට පෙර එක් ප්රකාශයක් පමණක් පවතී (නම් ක්රියාවලිය autoboxing). අපි නැවතත් අපේ දෙසට යමු prototypal inheritance.

• Javascriptdelegationමත පදනම්ව උරුමය සඳහා සහය දක්වයි prototypes.
• එක් එක් Functionසතුව prototypeතවත් වස්තුවකට සඳහන් කරන දේපල,.
• properties/functionsඑය නොපවතී නම් එය objectතමා විසින්ම හෝ prototypeදාමය හරහා බලනු ලැබේ

prototypeJS හි A යනු yieldsඔබ වෙනත් කෙනෙකුගේ මවුපියන්ට ලබා දෙන වස්තුවකි object. [එනම් .. නියෝජිත කණ්ඩායම] Delegation යනු ඔබට යමක් කිරීමට නොහැකි නම්, ඔබ වෙනුවෙන් එය කිරීමට වෙනත් කෙනෙකුට පවසනු ඇත.

https://jsfiddle.net/say0tzpL/1/

ඔබ ඉහත සඳහන් කළ ප්‍රහේලිකාව දෙස බැලුවහොත්, බල්ලාට toStringක්‍රමයට ප්‍රවේශය ඇත , නමුත් එය එහි නොමැත, නමුත් එය පැවරෙන මූලාකෘති දාමය හරහා ලබා ගත හැකියObject.prototype

ඔබ පහත දැක්වෙන callක්‍රමය දෙස බැලුවහොත්, අපි උත්සාහ කරන්නේ සෑම දෙයකින්ම ලබා ගත හැකි ක්‍රමයට ප්‍රවේශ වීමටයි function.

https://jsfiddle.net/rknffckc/

ඔබ ඉහත ප්‍රහේලිකාව දෙස බැලුවහොත්, ශ්‍රිතයට ක්‍රමයට Profileප්‍රවේශය ඇත call, නමුත් එය එහි නොමැත, නමුත් එය පැවරෙන මූලාකෘති දාමය හරහා ලබා ගත හැකියFunction.prototype

සටහන: prototype ශ්‍රිත ඉදිකිරීම්කරුගේ දේපලක් වන අතර ශ්‍රිත __proto__ඉදිකිරීම්කරු වෙතින් සාදන ලද වස්තූන්ගේ දේපලකි. සෑම කාර්යයක් සඳහාම prototypeවටිනාකමක් ඇති දේපලක් ඇත object. අපි ශ්‍රිතයේ නිදසුනක් නිර්මාණය කරන විට, අපට අභ්‍යන්තර දේපලක් ලැබෙනු ඇත, [[Prototype]]නැතහොත් ශ්‍රිතයේ __proto__මූලාකෘතිය වන්නේ කාගේද යන්නයි constructor.

ඉහත රූප සටහන තරමක් සංකීර්ණ බව පෙනේ, නමුත් කෙසේද යන්න පිළිබඳ සම්පූර්ණ පින්තූරයම ගෙන එයි prototype chaining ක්‍රියා . අපි මෙය සෙමින් ගමන් කරමු:

උදාහරණයක් දෙකක් ඇත b1හා b2සිය ඉදිකිරීමටත් වේ Barහා මව් ෆූ හා මූලාකෘති දම්වැලේ ක්රම දෙකක් ඇත identifyහා speakහරහා BarහාFoo

https://jsfiddle.net/kbp7jr7n/

ඔබ ඉහත කේතය දෙස බැලුවහොත්, අපට Fooක්‍රමවේදය ඇති ඉදිකිරීම්කරු identify()සහ ක්‍රමවේදයක් ඇති Barඉදිකිරීම්කරු සිටී speak. අපි දෙදෙනා නිර්මාණය Barඋදාහරණයක් b1හා b2සිය මව් වර්ගය වේ Foo. දැන් ඇමතීමේ speakක්‍රමවේදය අතරතුර, කථාව අමතන්නේ Barකවුරුන්ද යන්න prototypeදාමය හරහා හඳුනා ගැනීමට අපට හැකි වේ .

Barදැන් එහි සියලු ක්‍රම Fooනිර්වචනය කර ඇත prototype. එහෙනම් අපි තේරුම් ගැනීම තවදුරටත් කැණීම් Object.prototypeහා Function.prototypeඔවුන් සම්බන්ධ වී ඇති ආකාරය. ඔබ යන ඉදිකිරීමටත් සොයා නම් Foo, Barසහ Objectය Function constructor.

මෙම prototypeක Barය Foo, prototypeක Fooය Objectසහ ඔබ සමීපව බැලීමට නම් prototypeකිරීම Fooහා සම්බන්ධ වේ Object.prototype.

අපි මෙය වසා දැමීමට පෙර, ඉහත සියල්ල සාරාංශ කිරීමට මෙහි කුඩා කේත කැබැල්ලකින් ඔතා බලමු . අප කරනුයේ instanceofඉතා දැයි පරීක්ෂා කිරීමට මෙතන ක්රියාකරු objectඑහි ඇති prototypeදාම මේ prototypeවන දේපල constructorපහත සමස්ත මහා සටහන සාරාංශ කරන ලද.

මෙම එකතු කිරීම යම් තොරතුරක් ඇතැයි මම විශ්වාස කරමි, මෙය තරමක් ග්‍රහණය කර ගැනීමට විශාල විය හැකි බව මම දනිමි ... සරල වචන වලින් කිවහොත් එය හුදෙක් වස්තූන් හා සම්බන්ධ වූ වස්තූන් !!!!

මෙම ".ප්‍රොටෝටයිප්" දේපලෙහි නියම අරමුණ කුමක්ද?

සම්මත පංති සඳහා අතුරුමුහුණත විස්තීරණ වේ. උදාහරණයක් ලෙස, ඔබ භාවිතා කරන්නේArray පන්තිය ඔබේ සියලු අරාව වස්තු සඳහා අභිරුචි අනුක්‍රමිකකාරකයක් එක් කිරීමටද අවශ්‍ය වේ. ඔබ උප පංතියක් කේතනය කිරීමට කාලය ගත කරනවාද, නැතහොත් සංයුතිය භාවිතා කරන්නේද ... ... මූලාකෘති දේපල මඟින් මෙය විසඳන්නේ පන්තියකට ලබා ගත හැකි නිශ්චිත සාමාජිකයන් / ක්‍රම පාලනය කිරීමට පරිශීලකයින්ට ඉඩ දීමෙනි.

මූලාකෘති අතිරේක vtable-pointer ලෙස සිතන්න. සමහර සාමාජිකයින් මුල් පන්තියෙන් අතුරුදහන් වූ විට, මූලාකෘතිය ධාවන වේලාව දෙස බලයි.

මූලාකෘති දාම කොටස් දෙකකට වර්ග කිරීමට එය උපකාරී වේ.

ඉදිකිරීම්කරු සලකා බලන්න:

 function Person() {}

අගය Object.getPrototypeOf(Person)යනු ශ්‍රිතයකි. ඇත්ත වශයෙන්ම, එය එසේ ය Function.prototype. Personශ්‍රිතයක් ලෙස නිර්මාණය කර ඇති බැවින් , එය සියලු ශ්‍රිතයන්ට ඇති එකම මූලාකෘති ශ්‍රිත වස්තුව බෙදා ගනී. එය සමාන ය Person.__proto__, නමුත් එම දේපල භාවිතා නොකළ යුතුය. කෙසේ වෙතත්, Object.getPrototypeOf(Person)ඔබ සමඟ effectively ලදායි ලෙස මූලාකෘති දාමය ලෙස හැඳින්වෙන ඉණිමඟ ඉහළට යන්න.

ඉහළ දිශාවට ඇති දාමය මේ වගේ ය:

    Personඇතුළුවන්න → Function.prototypeඇතුළුවන්න → Object.prototype(අවසන් වන ස්ථානය)

ඉතා වැදගත් මේ මූලාකෘති දාම බව වස්තූන් අල්ප ඇති බව ය Personහැකි ඉදි . ඉදිකරන ලද එම වස්තූන්ට තමන්ගේම මූලාකෘති දාමයක් ඇති අතර, මෙම දාමයට ඉහත සඳහන් කළ දෙයට සමාන සමීප මුතුන් මිත්තෙකු සිටිය නොහැක.

උදාහරණයක් ලෙස මෙම වස්තුව ගන්න:

var p = new Person();

p සමඟ පුද්ගලයා සමඟ සෘජු මූලාකෘති-දාම සම්බන්ධතාවයක් නොමැත . ඔවුන්ගේ සම්බන්ධතාවය වෙනස් ය. P වස්තුවට තමන්ගේම මූලාකෘති දාමයක් ඇත. භාවිතා කිරීමෙන් Object.getPrototypeOf, දාමය පහත පරිදි වේ:

    pඇතුළුවන්න → Person.prototypeඇතුළුවන්න →Object.prototype(අවසන් වන ස්ථානය)

මෙම දාමයේ ක්‍රියාකාරී වස්තුවක් නොමැත (එය එසේ විය හැකි වුවද).

ඒ නිසා Personතමන්ගේ ජීවිත ජීවත් වන දම්වැල් වර්ග දෙකක් සම්බන්ධ බව පෙනේ. එක් දාමයක සිට අනෙක් දාමයට "පනින්න", ඔබ භාවිතා කරන්නේ:

1. .prototype: ඉදිකිරීම්කරුගේ දාමයේ සිට සාදන ලද-වස්තුවේ දාමයට පනින්න. මෙම ගුණාංගය අර්ථ දැක්වෙන්නේ ශ්‍රිත වස්තු සඳහා පමණි (භාවිතා newකළ හැක්කේ ශ්‍රිත මත පමණි).

2. .constructor: සාදන ලද-වස්තුවේ දාමයේ සිට ඉදිකිරීම්කරුගේ දාමයට පනින්න.

තීරු ලෙස නිරූපණය කර ඇති මූලාකෘති දාම දෙකෙහි දෘශ්‍ය ඉදිරිපත් කිරීමක් මෙන්න:

සාරාංශගත කිරීම සඳහා:

මෙම prototypeදේපල පිළිබඳ කිසිදු තොරතුරක් ලබා දෙන විෂය ගේ මූලාකෘති දාම, නමුත් වස්තූන් විසින් නිර්මාණය කරන විෂය.

දේපලවල නම prototypeව්‍යාකූලත්වයට හේතු වීම පුදුමයක් නොවේ . මෙම දේපල නම් කර තිබුනේ නම් එය වඩාත් පැහැදිලි වනු ඇතprototypeOfConstructedInstances හෝ එම රේඛාව ඔස්සේ යමක් .

මූලාකෘති දාම දෙක අතර ඔබට ඉදිරියට සහ පසුපසට පනින්න පුළුවන්:

Person.prototype.constructor === Person

වෙත වෙනත් වස්තුවක් පැහැදිලිවම පැවරීමෙන් මෙම සමමිතිය බිඳ දැමිය හැකිය prototypeදේපල (පසුව ඒ ගැන වැඩි විස්තර).

එක් ශ්‍රිතයක් සාදන්න, වස්තු දෙකක් ලබා ගන්න

Person.prototypeශ්‍රිතය Personනිර්මාණය කරන අවස්ථාවේදීම නිර්මාණය කරන ලද වස්තුවකි . Personඑම ඉදිකිරීම්කරු තවමත් ක්‍රියාත්මක කර නොතිබුණද, එය ඉදිකිරීම්කරු ලෙස ඇත . එබැවින් එකවර වස්තු දෙකක් නිර්මාණය වේ:

1. ශ්‍රිතය Personම ය
2. ශ්‍රිතය ඉදිකිරීම්කරුවෙකු ලෙස හැඳින්වූ විට මූලාකෘතියක් ලෙස ක්‍රියා කරන වස්තුව

දෙකම වස්තූන් වේ, නමුත් ඒවාට වෙනස් භූමිකාවන් ඇත: ශ්‍රිත වස්තුව සාදයි , අනෙක් වස්තුව නිරූපණය කරන්නේ ඕනෑම වස්තුවක මූලාකෘතියයි. මූලාකෘති වස්තුව එහි මූලාකෘති දාමයේ ඉදිකරන ලද වස්තුවේ මව් බවට පත්වේ.

ශ්‍රිතයක් ද වස්තුවක් බැවින් එයට මවුපියන්ගේම මූලාකෘති දාමයක් ඇත, නමුත් මෙම දම්වැල් දෙක විවිධ දේ ගැන බව මතක තබා ගන්න.

ගැටලුව ග්‍රහණය කර ගැනීමට උපකාරී වන සමානතා කිහිපයක් මෙන්න - මේ සියල්ලම මුද්‍රණය කරන්න true:

function Person() {};

// This is prototype chain info for the constructor (the function object):
console.log(Object.getPrototypeOf(Person) === Function.prototype);
// Step further up in the same hierarchy:
console.log(Object.getPrototypeOf(Function.prototype) === Object.prototype);
console.log(Object.getPrototypeOf(Object.prototype) === null);
console.log(Person.__proto__ === Function.prototype);
// Here we swap lanes, and look at the constructor of the constructor
console.log(Person.constructor === Function);
console.log(Person instanceof Function);

// Person.prototype was created by Person (at the time of its creation)
// Here we swap lanes back and forth:
console.log(Person.prototype.constructor === Person);
// Although it is not an instance of it:
console.log(!(Person.prototype instanceof Person));
// Instances are objects created by the constructor:
var p = new Person();
// Similarly to what was shown for the constructor, here we have
// the same for the object created by the constructor:
console.log(Object.getPrototypeOf(p) === Person.prototype);
console.log(p.__proto__ === Person.prototype);
// Here we swap lanes, and look at the constructor
console.log(p.constructor === Person);
console.log(p instanceof Person);

මූලාකෘති දාමයට මට්ටම් එකතු කිරීම

ඔබ ඉදිකිරීම් ශ්‍රිතයක් නිර්මාණය කරන විට මූලාකෘති වස්තුවක් නිර්මාණය වුවද, ඔබට එම වස්තුව නොසලකා හැරිය හැකි අතර, එම ඉදිකිරීම්කරු විසින් නිර්මාණය කරන ලද පසුකාලීන අවස්ථා සඳහා මූලාකෘතියක් ලෙස භාවිතා කළ යුතු වෙනත් වස්තුවක් පැවරිය හැකිය.

උදාහරණයක් වශයෙන්:

function Thief() { }
var p = new Person();
Thief.prototype = p; // this determines the prototype for any new Thief objects:
var t = new Thief();

දැන් t හි මූලාකෘති දාමය p ට වඩා එක් පියවරක් දිගු වේ :

    tඇතුළුවන්න → pඇතුළුවන්න → Person.prototypeඇතුළුවන්න → Object.prototype(අවසන් වන ස්ථානය)

අනෙක් මූලාකෘති දාම තවදුරටත් නොවේ: Thiefහා Personඔවුන්ගේ මූලාකෘති දාම එකම මව් බෙදා සහෝදර සහෝදරියන් ය:

    Person}
    Thief  } ඇතුළුවන්න → Function.prototypeඇතුළුවන්න → Object.prototype(අවසන් වන ස්ථානය)

කලින් ඉදිරිපත් කරන ලද ග්‍රැෆික් එක මේ දක්වා දීර් extend කළ හැකිය (මුල් පිටපත Thief.prototypeඅතහැර දමා ඇත):

නිල් රේඛා මූලාකෘති දාම නියෝජනය කරයි, අනෙක් වර්ණ රේඛා වෙනත් සම්බන්ධතා නියෝජනය කරයි:

• වස්තුවක් සහ එහි ඉදිකිරීම්කරු අතර
• ඉදිකිරීම්කරුවෙකු සහ වස්තු තැනීම සඳහා භාවිතා කරන මූලාකෘති වස්තුව අතර

වස්තු-නැඹුරුවන ජාවාස්ක්‍රිප්ට් සඳහා නියත මාර්ගෝපදේශය - අසන ලද ප්‍රශ්නය පිළිබඳ ඉතා සංක්ෂිප්ත හා පැහැදිලි min 30 විනාඩි වීඩියෝ පැහැදිලි කිරීමක් (මූලාකෘති උරුමය මාතෘකාව 5:45 සිට ආරම්භ වේ , නමුත් මම සම්පූර්ණ වීඩියෝවට සවන් දීමට කැමැත්තෙමි). මෙම වීඩියෝ පටයේ කතුවරයා ජාවාස්ක්‍රිප්ට් වස්තු දෘශ්‍යකරණ වෙබ් අඩවිය http://www.objectplayground.com/ ද නිර්මාණය කළේය .

යොමු කරන විට “මූලාකෘති දාමය” පුනරාවර්තන සම්මුතියක් ලෙස පැහැදිලි කිරීම මට ප්‍රයෝජනවත් විය obj_n.prop_X:

නම් obj_n.prop_Xනොපවතියි, පරීක්ෂා obj_n+1.prop_Xඑහිදීobj_n+1 = obj_n.[[prototype]]

නම් prop_Xඅවසානයේ පසුව k-වන පරමාදර්ශයක් වස්තුව හමු වී ඇත

obj_1.prop_X = obj_1.[[prototype]].[[prototype]]..(k-times)..[[prototype]].prop_X

ජාවාස්ක්‍රිප්ට් වස්තූන්ගේ ගුණාංග අනුව ඔබට ඒවායේ ප්‍රස්ථාරය සොයාගත හැකිය:

http://jsobjects.org

ඉදිකිරීම්කරුවෙකු වස්තුවක් නිර්මාණය කරන විට, එම වස්තුව දේපල යොමු කිරීම් විසඳීම සඳහා ඉදිකිරීම්කරුගේ “මූලාකෘති” දේපල ව්‍යංගයෙන් සඳහන් කරයි. ඉදිකිරීම්කරුගේ “මූලාකෘති” දේපල වැඩසටහන් ප්‍රකාශන කන්ස්ට්‍රක්ටර් ප්‍රොටොටයිප් මගින් යොමු කළ හැකි අතර, වස්තුවක මූලාකෘතියට එකතු කරන ලද ගුණාංග උරුමය හරහා, සියලු වස්තු මූලාකෘතිය බෙදා ගනී.

පැහැදිලි කළ යුතු නමුත් ඊට සම්බන්ධ ආයතන දෙකක් මෙහි ඇත:

• මෙම .prototypeකාර්යයන් දේපල.
• මෙම [[Prototype]]^[1] සියලු වස්තු දේපළ ^[2] .

මේවා වෙනස් කරුණු දෙකකි.

මෙම [[Prototype]]දේපල:

මෙය සියලු ^[2] වස්තු වල පවතින දේපලකි .

මෙහි ගබඩා කර ඇත්තේ තවත් වස්තුවකි, එය වස්තුවක් ලෙස වෙනත් වස්තුවකට යොමු වන [[Prototype]]තමන්ගේම දෑ ඇත. අනෙක් වස්තුවට [[Prototype]]එයටම ආවේණික වේ. සියලු වස්තූන් සඳහා (වැනි .toString) ප්‍රවේශ විය හැකි ක්‍රම සපයන මූලාකෘති වස්තුව වෙත ඔබ ළඟා වන තෙක් මෙම කතාව දිගටම පවතී .

මෙම [[Prototype]]දේපල සාදයි දේ කොටසක් [[Prototype]]දාම. මෙම [[Prototype]]වස්තු දාමය යනු වස්තුවක් මත නිදසුනක් ලෙස [[Get]]හෝ [[Set]]මෙහෙයුම් සිදු කරන විට පරීක්ෂා කරනු ලබන්නේ:

var obj = {}
obj.a         // [[Get]] consults prototype chain
obj.b = 20    // [[Set]] consults prototype chain

මෙම .prototypeදේපල:

මෙය කාර්යයන් මත පමණක් දක්නට ලැබෙන දේපලකි. ඉතා සරල ශ්‍රිතයක් භාවිතා කිරීම:

function Bar(){};

මෙම .prototypeදේපල වස්තුවක් පවත්වයි පැවරී ඇති b.[[Prototype]]ඔබ එසේ කරන විට var b = new Bar. ඔබට මෙය පහසුවෙන් පරීක්ෂා කළ හැකිය:

// Both assign Bar.prototype to b1/b2[[Prototype]]
var b = new Bar;
// Object.getPrototypeOf grabs the objects [[Prototype]]
console.log(Object.getPrototypeOf(b) === Bar.prototype) // true

වඩාත්ම වැදගත් එක් .prototypeනොවන බව පිළිබඳ Objectකාර්යය . මෙම මූලාකෘතිය සියළුම [[Prototype]]දාමයන්හි අඩංගු මූලාකෘති වස්තුව රඳවා තබා ගනී . එය මත, නව වස්තු සඳහා ඇති සියලුම ක්‍රම අර්ථ දක්වා ඇත:

// Get properties that are defined on this object
console.log(Object.getOwnPropertyDescriptors(Object.prototype))

දැන්, .prototypeවස්තුවක් බැවින් එයට [[Prototype]]දේපලක් ඇත. ඔබට ඕනෑම පැවරුම් කරන්න එපා විට Function.prototypeඑම, .prototypeගේ [[Prototype]]මූලාකෘතික වස්තුවකට ලකුණු ( Object.prototype). ඔබ නව ශ්‍රිතයක් නිර්මාණය කරන ඕනෑම වේලාවක මෙය ස්වයංක්‍රීයව සිදු වේ.

මේ ආකාරයෙන්, ඔබ කරන ඕනෑම වේලාවක new Bar;මූලාකෘති දාමය ඔබ වෙනුවෙන් සකසා ඇති විට, ඔබට සියල්ල අර්ථ දක්වා ඇති Bar.prototypeඅතර සියල්ල අර්ථ දක්වා ඇත Object.prototype:

var b = new Bar;
// Get all Bar.prototype properties
console.log(b.__proto__ === Bar.prototype)
// Get all Object.prototype properties
console.log(b.__proto__.__proto__ === Object.prototype)

ඔබ විට කරන්න කිරීමට පසුබිම පැවරුම් Function.prototypeඔබ කරන සියලු තවත් වස්තුවක් ඇතුළත් කිරීමට පතිරූපක දාම දීර්ඝ වේ. එය තනි සම්බන්ධිත ලැයිස්තුවකට ඇතුළත් කිරීමක් වැනිය.

මෙය මූලික වශයෙන් [[Prototype]]දාමය වෙනස් Function.prototypeකරන්නේ ශ්‍රිතය මගින් නිර්මාණය කරන ලද ඕනෑම වස්තුවකට දැකීමට පවරා ඇති වස්තුව මත අර්ථ දක්වා ඇති ගුණාංගවලට ය .

^{[1: එය කිසිවෙකු ව්‍යාකූල නොකරනු ඇත; හරහා ලබා ඇති __proto__දේපල බොහෝ නිර්මාණයන් ය.
[2]: හැර අන් සියල්ලම null.}

මූලාකෘති පිළිබඳ මගේ අවබෝධය මම ඔබට කියන්නම්. මම මෙහි උරුමය වෙනත් භාෂා සමඟ සංසන්දනය නොකරමි. මිනිසුන් භාෂාවන් සංසන්දනය කිරීම නවත්වනු ඇතැයි මම සිතමි. මූලාකෘති සහ මූලාකෘති උරුමය අවබෝධ කර ගැනීම ඉතා සරල ය, මම ඔබට පහත පෙන්වන්නම්.

මූලාකෘතිය යනු ඔබ නිෂ්පාදනයක් නිර්මාණය කරන ආකෘතියක් වැනි ය. වටහා ගත යුතු වැදගත්ම කරුණ නම්, ඔබ වෙනත් වස්තුවක් මූලාකෘතියක් ලෙස භාවිතා කරමින් එය නිර්මාණය කරන විට, මූලාකෘතිය සහ නිෂ්පාදනය අතර සම්බන්ධය සදාකාලික වන බවයි. උදාහරණයක් වශයෙන්:

var model = {x:2};
var product = Object.create(model);
model.y = 5;
product.y
=>5

සෑම වස්තුවකම [[මූලාකෘති]] නමින් අභ්‍යන්තර දේපලක් අඩංගු වන අතර එමඟින් Object.getPrototypeOf()ශ්‍රිතයට ප්‍රවේශ විය හැකිය . Object.create(model)නව වස්තුවක් නිර්මාණය කර එය [[මූලාකෘති]] දේපල වස්තු ආකෘතියට සකසයි . එබැවින් ඔබ එසේ කරන විට Object.getPrototypeOf(product), ඔබට වස්තු ආකෘතිය ලැබෙනු ඇත .

නිෂ්පාදනයේ ගුණාංග පහත පරිදි හසුරුවනු ලැබේ:

• දේපලකට එහි වටිනාකම කියවීමට ප්‍රවේශ වූ විට, එය විෂය පථයේ දාමය දෙස බලයි. විචල්‍යය සෙවීම නිෂ්පාදනයේ සිට එහි මූලාකෘතිය දක්වා ආරම්භ වේ . සෙවීමේදී එවැනි විචල්‍යයක් සොයාගත හොත්, සෙවීම එතැනම නතර කර වටිනාකම නැවත ලබා දෙනු ලැබේ. එවැනි විචල්‍යයක් විෂය පථයේ සොයාගත නොහැකි නම්, නිර්වචනය නොකළ ආපසු ලබා දෙනු ලැබේ.
• දේපලක් ලියන විට (වෙනස් කරන ලද), එවිට දේපල සෑම විටම නිෂ්පාදන වස්තුව මත ලියා ඇත . නිෂ්පාදනයට දැනටමත් එවැනි දේපලක් නොමැති නම් , එය ව්‍යංගයෙන් නිර්මාණය කර ලියා ඇත.

මූලාකෘති දේපල භාවිතා කරමින් එවැනි වස්තු සම්බන්ධ කිරීම මූලාකෘති උරුමය ලෙස හැඳින්වේ. එහිදී, එය එතරම් සරලයි, එකඟද?

වඩා හොඳ පින්තූර සහිත ජාවාස්ක්‍රිප්ට් මූලාකෘති පදනම් කරගත් උරුමය පැහැදිලි කිරීමට තවත් උත්සාහයක්

පහත දැක්වෙන keyValueStoreවස්තුව සලකා බලන්න :

var keyValueStore = (function() {
    var count = 0;
    var kvs = function() {
        count++;
        this.data = {};
        this.get = function(key) { return this.data[key]; };
        this.set = function(key, value) { this.data[key] = value; };
        this.delete = function(key) { delete this.data[key]; };
        this.getLength = function() {
            var l = 0;
            for (p in this.data) l++;
            return l;
        }
    };

    return  { // Singleton public properties
        'create' : function() { return new kvs(); },
        'count' : function() { return count; }
    };
})();

මෙය කිරීමෙන් මට මෙම වස්තුවේ නව අවස්ථාවක් නිර්මාණය කළ හැකිය:

kvs = keyValueStore.create();

මෙම වස්තුවේ සෑම අවස්ථාවකම පහත සඳහන් පොදු ගුණාංග ඇත:

• data
• get
• set
• delete
• getLength

දැන්, අපි මෙම keyValueStoreවස්තුවේ අවස්ථා 100 ක් නිර්මාණය කරමු යැයි සිතමු . වුවත් get, set, delete, getLengthමෙම අවස්ථා 100 ක් එක් එක් සඳහා මේ දේම කරන්නේ, සෑම අවස්ථාවක මේ කර්තව්යය එහි ම පිටපතක් ඇත.

ඔබ තනි හැකි නම් දැන්, හිතාගන්න get, set, deleteහා getLengthපිටපත් කිරීම, සහ එක් එක් උදාහරණයක් බව එම උත්සවය අදාල වනු ඇත. මෙය කාර්ය සාධනය සඳහා වඩා හොඳ වන අතර අඩු මතකයක් අවශ්‍ය වේ.

මූලාකෘති එන්නේ එතැනිනි. මූලාකෘතියක් යනු උරුම වී ඇති නමුත් අවස්ථා වලින් පිටපත් නොකරන ලද ගුණාංගවල “සැලැස්මක්” වේ. එබැවින් මෙයින් අදහස් වන්නේ එය වස්තුවක සියලු අවස්ථාවන් සඳහා මතකයේ එක් වරක් පමණක් පවතින බවත් එම සියලු අවස්ථාවන් විසින් බෙදා ගන්නා බවත්ය.

දැන්, keyValueStoreවස්තුව නැවත සලකා බලන්න . මට එය නැවත ලිවිය හැකිය:

var keyValueStore = (function() {
    var count = 0;
    var kvs = function() {
        count++;
        this.data = {};
    };

    kvs.prototype = {
        'get' : function(key) { return this.data[key]; },
        'set' : function(key, value) { this.data[key] = value; },
        'delete' : function(key) { delete this.data[key]; },
        'getLength' : function() {
            var l = 0;
            for (p in this.data) l++;
            return l;
        }
    };

    return  {
        'create' : function() { return new kvs(); },
        'count' : function() { return count; }
    };
})();

මෙය හරියටම keyValueStoreවස්තුවේ පෙර අනුවාදයට සමාන වේ, එහි සියලු ක්‍රම දැන් මූලාකෘතියක දමා ඇත. මෙයින් අදහස් කරන්නේ, මේ අවස්ථා 100 ම සෑම එකක්ම තමන්ගේම පිටපතක් වෙනුවට මෙම ක්‍රම හතර බෙදා ගැනීමයි.

සාරාංශය:

• කාර්යයන් යනු ජාවාස්ක්‍රිප්ට් හි ඇති වස්තූන් වන අතර එමඟින් ගුණාංග තිබිය හැකිය
• (ඉදිකිරීම්කරු) කාර්යයන් සෑම විටම මූලාකෘති ගුණාංගයක් ඇත
• newයතුරු පදයක් සහිත ඉදිකිරීම්කරුවෙකු ලෙස ශ්‍රිතයක් භාවිතා කරන විට වස්තුවට මූලාකෘතියක් ලැබේ. මෙම මූලාකෘතිය පිළිබඳ සඳහනක් __proto__අලුතින් නිර්මාණය කරන ලද වස්තුවේ දේපල මත සොයාගත හැකිය .
• මෙම __proto__දේපල prototypeඉදිකිරීම්කරු ශ්‍රිතයේ දේපල වෙත යොමු වේ.

උදාහරණයක්:

function Person (name) {
  this.name = name;
}

let me = new Person('willem');

console.log(Person.prototype) // Person has a prototype property

console.log(Person.prototype === me.__proto__) // the __proto__ property of the instance refers to prototype property of the function.

මෙය ප්‍රයෝජනවත් වන්නේ ඇයි:

'මූලාකෘති උරුමය' ලෙස හැඳින්වෙන වස්තූන්හි ගුණාංග සොයා බැලීමේදී ජාවාස්ක්‍රිප්ට් යාන්ත්‍රණයක් ඇත , මූලික වශයෙන් කරන්නේ මෙයයි:

• දේපල වස්තුව මත පිහිටා තිබේදැයි පළමුව පරීක්ෂා කරනු ලැබේ. එසේ නම් මෙම දේපල ආපසු ලබා දෙනු ලැබේ.
• දේපල වස්තුව මත පිහිටා නොමැති නම් එය 'ප්‍රොටොචේන් ඉහළට නගිනු ඇත'. එය මූලික වශයෙන් ප්‍රෝටෝ දේපල මගින් සඳහන් කරන වස්තුව දෙස බලයි . ප්‍රෝටෝ විසින් යොමු කරන ලද වස්තුව මත දේපල තිබේදැයි එහිදී පරීක්ෂා කරයි
• දේපල ප්‍රෝටෝ වස්තුව මත පිහිටා නොමැති නම්, එය වස්තු වස්තුව දක්වාම ප්‍රෝටෝ දාමය ඉහළට නගිනු ඇත .
• එයට වස්තුව හා එහි මූලාකෘති දාමයෙහි කොතැනකවත් දේපල සොයාගත නොහැකි නම් එය නිර්වචනය නොකෙරේ.

උදාහරණයක් වශයෙන්:

function Person(name) {
  this.name = name;
}

let mySelf = new Person('Willem');

console.log(mySelf.__proto__ === Person.prototype);

console.log(mySelf.__proto__.__proto__ === Object.prototype);

යාවත්කාලීන කිරීම:

මෙම __proto__එය පරමාදර්ශයක් වස්තුව යොමු ලබා ගැනීමට හොඳ ක්රමයක් වනු ඇත බොහෝ නවීන බ්රවුසරයන් ක්රියාත්මක වුවත් දේපල, අතහැර දමා ඇත:

Object.getPrototypeOf()

මෙම වර්ගයේ දේවල් තේරුම් ගැනීමේදී මම සැමවිටම ප්‍රතිසම වලට කැමතියි. මූලාකෘති වඩාත් සරල ආදර්ශයක් වුවද, මගේ මතය අනුව පන්ති බාස් උරුමය හා සැසඳීමේදී 'මූලාකෘති උරුමය' තරමක් ව්‍යාකූල ය. ඇත්ත වශයෙන්ම මූලාකෘති සමඟ, ඇත්ත වශයෙන්ම උරුමයක් නොමැත, එබැවින් නම සහ එයම නොමඟ යවන, එය වඩා 'නියෝජිත පිරිසකි'.

මෙය සිතා බලන්න ....

ඔබ උසස් පෙළ හදාරන අතර, ඔබ පන්තියේ සිටින අතර අද දින ප්‍රශ්නාවලියක් ඇත, නමුත් ඔබේ පිළිතුරු පිරවීමට පෑනක් නොමැත. දෝ!

ඔබ පෑනක් ඇති ඔබේ මිතුරා ෆිනියස් අසල වාඩි වී සිටී. ඔබ අසන අතර, ඔහු අසාර්ථක ලෙස ඔහුගේ මේසය දෙස බලයි, නමුත් "මට පෑනක් නැත" යැයි පැවසීම වෙනුවට ඔහු හොඳ මිතුරෙකි, ඔහු පෑනක් ඇත්දැයි ඔහුගේ අනෙක් මිතුරෙකු වන ඩර්ප් සමඟ පරීක්ෂා කරයි. ඩර්ප් සතුව අමතර පෑනක් ඇති අතර එය නැවත ෆිනියස් වෙත යවයි, ඔහු ඔබේ ප්‍රශ්නාවලිය සම්පූර්ණ කිරීම සඳහා එය ඔබ වෙත භාර දෙයි. ඩර්ප් විසින් පෑන ෆිනියස් වෙත භාර දී ඇති අතර ඔහු පෑන භාවිතය සඳහා ඔබට පවරා ඇත.

මෙහි ඇති වැදගත්ම දෙය නම් ඔබ ඔහු සමඟ relationship ජු සම්බන්ධතාවයක් නොමැති බැවින් ඩර්ප් ඔබට පෑන ලබා නොදේ .

මෙය, මූලාකෘති ක්‍රියා කරන ආකාරය පිළිබඳ සරල උදාහරණයකි, එහිදී ඔබ සොයන දේ සඳහා දත්ත ගසක් සොයනු ලැබේ.

__proto__ , මූලාකෘති සහ ඉදිකිරීම්කරුවන්ගේ සම්බන්ධතා පෙන්වන තවත් යෝජනා ක්‍රමයක් :

එය ඔබ සතුව දැනටමත් වස්තුවක් ඇති Object.newනමුත් ඉදිකිරීම්කරු සින්ටැක්ස් භාවිතා කරන විට ඔබට තවමත් වස්තුවක් නොමැත.

වස්තුවක මූලාකෘතිය (එය ලබා ගත හැකි Object.getPrototypeOf(obj)හෝ ක්ෂය කළ __proto__දේපල හරහා ලබා ගත හැකිය ) සහ prototypeඉදිකිරීම්කරුගේ කාර්යයන් අතර ඇති දේපල අතර වෙනසක් ඇති බව වටහා ගැනීම වැදගත්ය . පළමුවැන්න සෑම අවස්ථාවකම දේපල වන අතර දෙවැන්න ඉදිකිරීම්කරුගේ දේපල වේ. එනම්, Object.getPrototypeOf(new Foobar())එකම වස්තුවට සමාන Foobar.prototypeවේ.

යොමුව: https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object_prototypes

මෙම මූලාකෘති නිර්මාණය වස්තු පවතින උත්සහය විසින් වස්තුව . එබැවින් ඇත්ත වශයෙන්ම අපි මූලාකෘතිය ගැන සිතන විට අපට ක්ලෝන කිරීම හෝ යමක් සෑදීම වෙනුවට එහි පිටපතක් සෑදීම ගැන සිතිය හැකිය .