new
ජාවාස්ක්රිප්ට් හි මූල පදය පළමු වරට හමු වූ විට එය ව්යාකූල විය හැකිය, මන්ද ජාවාස්ක්රිප්ට් යනු වස්තු-නැඹුරු වැඩසටහන්කරණ භාෂාවක් නොවන බව මිනිසුන් සිතීමට පෙළඹේ.
- එය කුමක් ද?
- එය විසඳන්නේ කුමන ගැටලු ද?
- එය සුදුසු වන්නේ කවදාද සහ කවදාද?
new
ජාවාස්ක්රිප්ට් හි මූල පදය පළමු වරට හමු වූ විට එය ව්යාකූල විය හැකිය, මන්ද ජාවාස්ක්රිප්ට් යනු වස්තු-නැඹුරු වැඩසටහන්කරණ භාෂාවක් නොවන බව මිනිසුන් සිතීමට පෙළඹේ.
Answers:
එය දේවල් 5 ක් කරයි:
this
අළුතින් සාදන ලද වස්තුවට විචල්ය ලක්ෂ්යය කරයි.this
සඳහන් වන සෑම අවස්ථාවකම එය භාවිතා කරමින් ඉදිකිරීම්කරුගේ ක්රියාකාරිත්වය ක්රියාත්මක කරයි .null
වස්තු නොවන යොමු කිරීමක් ලබා නොදෙන්නේ නම් එය අලුතින් සාදන ලද වස්තුව නැවත ලබා දෙයි . මෙම අවස්ථාවේදී, ඒ වස්තු යොමු කිරීම ඒ වෙනුවට ලබා දෙනු ලැබේ.සටහන: ඉදිකිරීම්කරුගේ ශ්රිතය යන්නෙන් අදහස් කෙරෙනුයේ new
යතුරු පදයට පසුව ඇති ශ්රිතයයි
new ConstructorFunction(arg1, arg2)
මෙය සිදු කිරීමෙන් පසු, නව වස්තුවෙහි නිර්වචනය නොකළ දේපලක් ඉල්ලා සිටියහොත්, ස්ක්රිප්ට් විසින් ඒ වෙනුවට දේපල සඳහා [[මූලාකෘති]] වස්තුව පරීක්ෂා කරනු ඇත . ජාවාස්ක්රිප්ට් හි සාම්ප්රදායික පන්ති උරුමයට සමාන දෙයක් ඔබට ලබා ගත හැකි ආකාරය මෙයයි.
මෙහි ඇති වඩාත්ම දුෂ්කර කොටස ලක්ෂ්ය අංක 2 වේ. සෑම වස්තුවකටම (කාර්යයන් ඇතුළුව) මෙම අභ්යන්තර දේපල [[මූලාකෘති]] ලෙස හැඳින්වේ . එය සැකසිය හැක්කේ වස්තු නිර්මාණය කරන වේලාවේදී, අළුත් , Object.create සමඟ හෝ වචනානුසාරයෙන් (Function.prototype වෙත පෙරනිමියෙන් ක්රියා කරන සංඛ්යා, අංක අංක ප්රොටොටයිපයට අංක ආදිය). එය කියවිය හැක්කේ Object.getPrototypeOf (someObject) සමඟ පමණි . නැත කිසිදු මෙම අගය සකස් කිරීම හෝ කියවීම සඳහා වෙනත් ක්රමයක්.
සැඟවුණු [[මූලාකෘති]] දේපල වලට අමතරව කාර්යයන් ද මූලාකෘති ලෙස හැඳින්වෙන දේපලක් ඇති අතර , ඔබ විසින් සාදන ලද වස්තූන් සඳහා උරුම වූ දේපල සහ ක්රම ලබා දීම සඳහා ඔබට ප්රවේශ විය හැකි හා වෙනස් කළ හැකිය.
මෙන්න උදාහරණයක්:
ObjMaker = function() {this.a = 'first';};
// ObjMaker is just a function, there's nothing special about it that makes
// it a constructor.
ObjMaker.prototype.b = 'second';
// like all functions, ObjMaker has an accessible prototype property that
// we can alter. I just added a property called 'b' to it. Like
// all objects, ObjMaker also has an inaccessible [[prototype]] property
// that we can't do anything with
obj1 = new ObjMaker();
// 3 things just happened.
// A new, empty object was created called obj1. At first obj1 was the same
// as {}. The [[prototype]] property of obj1 was then set to the current
// object value of the ObjMaker.prototype (if ObjMaker.prototype is later
// assigned a new object value, obj1's [[prototype]] will not change, but you
// can alter the properties of ObjMaker.prototype to add to both the
// prototype and [[prototype]]). The ObjMaker function was executed, with
// obj1 in place of this... so obj1.a was set to 'first'.
obj1.a;
// returns 'first'
obj1.b;
// obj1 doesn't have a property called 'b', so JavaScript checks
// its [[prototype]]. Its [[prototype]] is the same as ObjMaker.prototype
// ObjMaker.prototype has a property called 'b' with value 'second'
// returns 'second'
එය පන්ති උරුමය හා සමාන ය, මන්ද දැන් ඔබ භාවිතා කරන ඕනෑම වස්තුවක් new ObjMaker()
ද 'ආ' දේපල උරුම කරගෙන ඇති බව පෙනේ.
ඔබට උප පංතියක් වැනි දෙයක් අවශ්ය නම්, ඔබ මෙය කරන්නේ:
SubObjMaker = function () {};
SubObjMaker.prototype = new ObjMaker(); // note: this pattern is deprecated!
// Because we used 'new', the [[prototype]] property of SubObjMaker.prototype
// is now set to the object value of ObjMaker.prototype.
// The modern way to do this is with Object.create(), which was added in ECMAScript 5:
// SubObjMaker.prototype = Object.create(ObjMaker.prototype);
SubObjMaker.prototype.c = 'third';
obj2 = new SubObjMaker();
// [[prototype]] property of obj2 is now set to SubObjMaker.prototype
// Remember that the [[prototype]] property of SubObjMaker.prototype
// is ObjMaker.prototype. So now obj2 has a prototype chain!
// obj2 ---> SubObjMaker.prototype ---> ObjMaker.prototype
obj2.c;
// returns 'third', from SubObjMaker.prototype
obj2.b;
// returns 'second', from ObjMaker.prototype
obj2.a;
// returns 'first', from SubObjMaker.prototype, because SubObjMaker.prototype
// was created with the ObjMaker function, which assigned a for us
අවසාන වශයෙන් මෙම පිටුව සොයා ගැනීමට පෙර මම මෙම විෂය පිළිබඳ කුණු ටොන් ගණනක් කියවා ඇත්තෙමි , එහිදී මෙය හොඳ රූපසටහන් සමඟ ඉතා හොඳින් විස්තර කර ඇත.
ObjMaker
අගයක් ලබා දෙන ශ්රිතයක් ලෙස අර්ථ දැක්වුවහොත් වෙනස් ලෙස කුමක් සිදුවේද ?
new
පවතින බැවින් ඔබට කාර්යයන් / වස්තු තැනීමට / පිටපත් කිරීමට කර්මාන්තශාලා ක්රම ලිවීමට අවශ්ය නොවේ . එහි තේරුම, "මෙය පිටපත් කරන්න, එය එහි මව් පන්තියට සමාන කරන්න; එය කාර්යක්ෂමව හා නිවැරදිව කරන්න; මට පමණක් ප්රවේශ විය හැකි උරුම තොරතුරු ගබඩා කරන්න, ජේඑස්, අභ්යන්තරව". එසේ කිරීම සඳහා, එය prototype
සම්භාව්ය OO උරුම දාමයන් අනුකරණය කරමින් (ධාවන කාල වෙනස් කළ නොහැකි) නව වස්තුවෙහි වෙනත් ආකාරයකින් ප්රවේශ විය නොහැකි අභ්යන්තරය වෙනස් කරයි. ඔබට මෙය නොමැතිව අනුකරණය කළ හැකිය new
, නමුත් උරුමය ධාවන කාල වෙනස් කළ හැකිය. හොඳ? නරක? ඔබට බාරයි.
Notice that this pattern is deprecated!
. පංතියක මූලාකෘතිය සැකසීමට නිවැරදි යාවත්කාලීන රටාව කුමක්ද?
ඔබට මෙම කාර්යය ඇතැයි සිතමු:
var Foo = function(){
this.A = 1;
this.B = 2;
};
ඔබ මෙය හුදකලා ශ්රිතයක් ලෙස හැඳින්වුවහොත්:
Foo();
මෙම ශ්රිතය ක්රියාත්මක කිරීමෙන් window
වස්තුවට ගුණාංග දෙකක් එකතු වේ ( A
සහ B
). එය එය එකතු window
නිසා window
ඔබ ඒ වගේ එය ක්රියාත්මක කරන විට එම උත්සවයට කැඳවා ඇති වස්තුවක් වන අතර, this
එය ක්රියාත්මක වන්නේ කාර්යය විය යුතු බවත් වස්තුවකි. ජාවාස්ක්රිප්ට් හි අවම වශයෙන්.
දැන්, මේ සමඟ මෙය අමතන්න new
:
var bar = new Foo();
ඔබ new
ශ්රිත ඇමතුමකට එකතු කළ විට සිදුවන්නේ නව වස්තුවක් නිර්මාණය කිරීම (යන්තම් var bar = new Object()
) සහ this
ශ්රිතය තුළ ඇති ශ්රිතය Object
ලෙස හැඳින්වෙන්නේ ඔබ විසින් නිර්මාණය කරන ලද නවයට ය. ඒ නිසා bar
දැන් ගුණ ඇති වස්තුවක් A
හා B
. ඕනෑම කාර්යයක් ඉදිකිරීම්කරුවෙකු විය හැකිය, එය සැමවිටම අර්ථවත් නොවේ.
window
ව්යංගයෙන් ක්රමයක් වනු ඇත . වසා දැමීමේදී පවා, නිර්නාමික වුවද. කෙසේ වෙතත්, උදාහරණයේ දී එය කවුළුවේ සරල ක්රමවේදය වේ: Foo();
=> [default context].Foo();
=> window.Foo();
. මෙම ප්රකාශනය තුළ window
තමයි සන්දර්භය (පමණක් නොව, ඇමතුම ප්රශ්නයක් නොවන,).
ඩැනියෙල් හොවාර්ඩ්ගේ පිළිතුරට අමතරව, කරන්නේ කුමක්ද new
(හෝ අවම වශයෙන් පෙනෙන පරිදි):
function New(func) {
var res = {};
if (func.prototype !== null) {
res.__proto__ = func.prototype;
}
var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
return ret;
}
return res;
}
අතර
var obj = New(A, 1, 2);
සමාන වේ
var obj = new A(1, 2);
func.prototype
වෙන්න null
? කරුණාකර ඔබට ඒ ගැන ටිකක් විස්තර කළ හැකිද?
A.prototype = null;
එම අවස්ථාවේ new A()
දී වස්තුව මත සිදුවනු ඇත, එය අභ්යන්තර මූලාකෘති Object
වස්තුව වෙත යොමු කරයි : jsfiddle.net/Mk42Z
Object(ret) === ret
.
typeof
පරීක්ෂණය මඟින් තිරය පිටුපස සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීම පහසු කරයි.
බ්රව්සර් කොන්සෝලය තුළ පහත කේතය උත්සාහ කරන්න.
function Foo() {
return this;
}
var a = Foo(); //returns window object
var b = new Foo(); //returns empty object of foo
a instanceof Window; // true
a instanceof Foo; // false
b instanceof Window; // false
b instanceof Foo; // true
දැන් ඔබට ප්රජා විකී පිළිතුර කියවිය හැකිය :)
return this;
එකම ප්රතිදානය ලැබේ.
එබැවින් එය බොහෝ විට වස්තු අවස්ථා නිර්මාණය කිරීම සඳහා නොවේ
එය හරියටම ඒ සඳහා භාවිතා කරයි. ඔබ එසේ ක්රියාකරවන්නෙකු ලෙස අර්ථ දක්වයි:
function Person(name) {
this.name = name;
}
var john = new Person('John');
කෙසේ වෙතත් ECMAScript හි ඇති අමතර වාසිය නම් ඔබට .prototype
දේපල සමඟ විස්තාරණය කළ හැකි නිසා අපට එවැනි දෙයක් කළ හැකිය ...
Person.prototype.getName = function() { return this.name; }
මෙම ඉදිකිරීම්කරුගෙන් සාදන ලද සියලුම වස්තූන් වලට දැන් getName
ප්රවේශ විය හැක්කේ මූලාකෘති දාමය නිසාය.
class
යතුරු පදයක් නැත, නමුත් ඔබට එකම දේ කළ හැකිය.
ජාවාස්ක්රිප්ට් යනු වස්තු-නැඹුරු ක්රමලේඛන භාෂාවක් වන අතර එය හරියටම අවස්ථා නිර්මාණය කිරීම සඳහා භාවිතා කරයි. එය පන්ති පදනම් කරගත් ඒවාට වඩා මූලාකෘති මත පදනම් වූ නමුත් එයින් අදහස් කරන්නේ එය වස්තු-නැඹුරු නොවන බවයි.
ජාවාස්ක්රිප්ට් යනු ගතික ක්රමලේඛන භාෂාවක් වන අතර එය වස්තු දිශානත ක්රමලේඛන ආදර්ශයට සහාය වන අතර එය වස්තුවේ නව අවස්ථා නිර්මාණය කිරීම සඳහා භාවිතා කරයි.
වස්තූන් සඳහා පන්ති අවශ්ය නොවේ - ජාවාස්ක්රිප්ට් යනු මූලාකෘති පදනම් කරගත් භාෂාවකි.
මේ වන විටත් ඉතා හොඳ පිළිතුරු කිහිපයක් ඇත, නමුත් ඔබ විසින් සිදුකරන ලද ශ්රිතයක පැහැදිලි ප්රතිලාභ ප්රකාශයක් ඇති විට කුමක් සිදුවේද යන්න පිළිබඳව පහත දැක්වෙන තුන්වන අවස්ථාව පිළිබඳ මගේ නිරීක්ෂණය අවධාරණය කිරීමට මම නව එකක් පළ කරමි new
. පහත අවස්ථා දෙස බලන්න:
පළමු නඩුව :
var Foo = function(){
this.A = 1;
this.B = 2;
};
console.log(Foo()); //prints undefined
console.log(window.A); //prints 1
ඉහත දක්වා ඇත්තේ නිර්නාමික ශ්රිතය පෙන්වා දෙන සරල අවස්ථාවකි Foo
. ඔබ මෙම ශ්රිතය අමතන විට එය නැවත පැමිණේ undefined
. පැහැදිලි ප්රතිලාභ ප්රකාශයක් නොමැති බැවින් ජාවාස්ක්රිප්ට් පරිවර්තකය return undefined;
ශ්රිතය අවසානයේ ප්රකාශයක් බලහත්කාරයෙන් ඇතුළු කරයි . මෙහි කවුළුව යනු this
නව A
සහ B
ගුණාංග ලබා ගන්නා ආයාචනා වස්තුවයි (සන්දර්භීය ) .
නඩු II :
var Foo = function(){
this.A = 1;
this.B = 2;
};
var bar = new Foo();
console.log(bar()); //illegal isn't pointing to a function but an object
console.log(bar.A); //prints 1
මෙහිදී ජාවාස්ක්රිප්ට් පරිවර්තකය new
යතුරු පදය දැකීමෙන් නව වස්තුවක් නිර්මාණය වන අතර එය this
පෙන්වා දෙන නිර්නාමික ශ්රිතයේ ආයාචනා වස්තුව (සන්දර්භීය ) ලෙස ක්රියා කරයි Foo
. මෙම අවස්ථාවේදී A
සහ B
අලුතින් සාදන ලද වස්තුවෙහි ගුණාංග බවට පත් වන්න (කවුළු වස්තුව වෙනුවට). ඔබට පැහැදිලි ප්රතිලාභ ප්රකාශයක් නොමැති බැවින්, ජාවාස්ක්රිප්ට් පරිවර්තකය යතුරුපදය භාවිතා කිරීම හේතුවෙන් නිර්මාණය කරන ලද නව වස්තුව ආපසු ලබා දීම සඳහා ආපසු ප්රකාශයක් බලහත්කාරයෙන් ඇතුළත් කරයි new
.
නඩු III :
var Foo = function(){
this.A = 1;
this.B = 2;
return {C:20,D:30};
};
var bar = new Foo();
console.log(bar.C);//prints 20
console.log(bar.A); //prints undefined. bar is not pointing to the object which got created due to new keyword.
මෙහිදී නැවතත් ජාවාස්ක්රිප්ට් පරිවර්තකය new
යතුරු පදය දැකීමෙන් නව වස්තුවක් නිර්මාණය වන අතර එය this
පෙන්වා දෙන නිර්නාමික ශ්රිතයේ ආයාචනා වස්තුව (සන්දර්භීය ) ලෙස ක්රියා කරයි Foo
. නැවතත්, A
සහ B
අලුතින් නිර්මාණය වස්තුවක් මත ගුණ බවට පත් වේ. නමුත් මෙම කාලය ඔබ පැහැදිලි ආපසු ප්රකාශයක් JavaScript භාෂණ ඇත එසේ තිබිය නොහැකි , එහි ම දෙයක් කරන්න.
III දී සැලකිල්ලට ගත යුතු කාරණය නම්, new
මූලික පදය නිසා නිර්මාණය වන වස්තුව ඔබේ රේඩාර් වෙතින් නැති වී යාමයි. යතුරුපදය bar
නිසා ජාවාස්ක්රිප්ට් පරිවර්තකය නිර්මාණය කළ සම්පූර්ණයෙන්ම වෙනස් වස්තුවකට යොමු නොවේ new
.
ජාවාස්ක්රිපිට් වෙතින් ඩේවිඩ් ෆ්ලැනගන් උපුටා දැක්වීම: නිශ්චිත මාර්ගෝපදේශය (6 වන සංස්කරණය), චි. 4, පිටුව # 62:
වස්තු නිර්මාණය කිරීමේ ප්රකාශනය ඇගයීමට ලක් කළ විට, ජාවාස්ක්රිප්ට් මුලින්ම නව හිස් වස්තුවක් නිර්මාණය කරයි. ඊළඟට, එය මෙම පරාමිතියෙහි අගය ලෙස නව වස්තුව පසුකරමින් නිශ්චිත තර්ක සමඟ නිශ්චිත ශ්රිතය ඉල්ලා සිටී. අළුතින් සාදන ලද වස්තුවේ ගුණාංග ආරම්භ කිරීම සඳහා ශ්රිතයට මෙය භාවිතා කළ හැකිය. ඉදිකිරීම්කරුවන් ලෙස භාවිතා කිරීම සඳහා ලියා ඇති කාර්යයන් වටිනාකමක් ලබා නොදෙන අතර වස්තු නිර්මාණය කිරීමේ ප්රකාශනයේ වටිනාකම අළුතින් සාදන ලද සහ ආරම්භක වස්තුව වේ. ඉදිකිරීම්කරුවෙකු වස්තු අගයක් ආපසු ලබා දෙන්නේ නම්, එම අගය වස්තු නිර්මාණය කිරීමේ ප්රකාශනයේ වටිනාකම බවට පත්වන අතර අලුතින් සාදන ලද වස්තුව ඉවතලනු ලැබේ.
--- අමතර තොරතුරු ---
ඉහත අවස්ථා වල කේත ස්නිපටයේ භාවිතා කරන කාර්යයන් පහත පරිදි JS ලෝකයේ විශේෂ නම් ඇත:
නඩුව I සහ II - ඉදිකිරීම්කරුගේ ක්රියාකාරිත්වය
නඩු III - කර්මාන්තශාලා ක්රියාකාරිත්වය. වත්මන් ත්රෙඩ් එකේ සංකල්පය පැහැදිලි කිරීම සඳහා මා විසින් කර ඇති යතුරු පද සමඟ කර්මාන්තශාලා කාර්යයන් භාවිතා නොකළ යුතුය new
.
මෙම ත්රෙඩ් එකේ ඔවුන් අතර ඇති වෙනස ගැන ඔබට කියවිය හැකිය .
සමහර විට කේත වචන වලට වඩා පහසු ය:
var func1 = function (x) { this.x = x; } // used with 'new' only
var func2 = function (x) { var z={}; z.x = x; return z; } // used both ways
func1.prototype.y = 11;
func2.prototype.y = 12;
A1 = new func1(1); // has A1.x AND A1.y
A2 = func1(1); // undefined ('this' refers to 'window')
B1 = new func2(2); // has B1.x ONLY
B2 = func2(2); // has B2.x ONLY
මට නම්, මම මූලාකෘතියක් නොමැති තාක් කල්, මම func2 විලාසිතාව භාවිතා කරමි.
B1 = new func2(2);
<- මෙය නොතිබෙන්නේ B1.y
ඇයි?
මෙම new
මූල පදය උත්සවයට ලකුණු වීම හා එම සන්දර්භය සූචකය වන යටතේ සන්දර්භය වෙනස් වෙනවා.
ඔබ new
මූල පදය භාවිතා නොකරන විට , ශ්රිතය ක්රියාත්මක වන සන්දර්භය ඔබ ශ්රිතය Vehicle()
ලෙස හඳුන්වන සන්දර්භය Vehicle
වේ. මෙම this
ඉඟි පද එම සන්දර්භය වෙත යොමු කරනු ඇත. ඔබ භාවිතා කරන විට new Vehicle()
, නව සන්දර්භයක් නිර්මාණය වන බැවින් this
ශ්රිතය තුළ ඇති ප්රධාන පදය නව සන්දර්භය වෙත යොමු වේ. ඔබට ආපසු ලැබෙන්නේ අලුතින් සාදන ලද සන්දර්භයයි.
මෙම new
මූල පදය නව වස්තුව අවස්ථා නිර්මාණය කිරීම සඳහා වේ. ඔව්, ජාවාස්ක්රිප්ට් යනු ගතික ක්රමලේඛන භාෂාවක් වන අතර එය වස්තු දිශානත ක්රමලේඛන ආදර්ශයට සහාය වේ. වස්තු නම් කිරීම පිළිබඳ සම්මුතිය නම්, සෑම විටම නව මූල පදයෙන් ක්ෂණිකව දැක්විය යුතු වස්තූන් සඳහා ලොකු අකුර භාවිතා කරන්න.
obj = new Element();
ප්රධාන new
පදය මඟින් ඉදිකිරීම්කරුවෙකු ලෙස කාර්යයන් භාවිතා කරන වස්තූන්ගේ අවස්ථා නිර්මාණය කරයි. උදාහරණයක් වශයෙන්:
var Foo = function() {};
Foo.prototype.bar = 'bar';
var foo = new Foo();
foo instanceof Foo; // true
ඉදි කරන්නන්ගේ ශ්රිතයෙන් අවස්ථා උරුම prototype
වේ. ඉහත උදාහරණය අනුව ...
foo.bar; // 'bar'
සෑම ජාවාස්ක්රිප්ට් එකක්ම වේදිකාවෙන් වේදිකාවට බෙහෙවින් වෙනස් විය හැකි බැවින් එය සෑම විටම මුල් පිරිවිතර EcmaScript ක්රියාත්මක කිරීමකි.
කෙසේ වෙතත්, ක්රියාත්මක කිරීමෙන් ස්වාධීනව, එක්මාස්ක්රිප්ට් පිරිවිතර අයිතිය අනුගමනය කරන සියලුම ජාවාස්ක්රිප්ට් ක්රියාත්මක කිරීම් මඟින් ඔබට වස්තු දිශානත භාෂාවක් ලබා දෙනු ඇත. ES ප්රමිතියට අනුව:
ECMAScript යනු ධාරක පරිසරයක් තුළ ගණනය කිරීම් සිදු කිරීම සහ පරිගණකමය වස්තු හැසිරවීම සඳහා වස්තු-නැඹුරු වැඩසටහන්කරණ භාෂාවකි.
ජාවාස්ක්රිප්ට් යනු එක්මාස්ක්රිප්ට් ක්රියාත්මක කිරීමක් බවත් එබැවින් එය වස්තු-නැඹුරු භාෂාවක් බවත් දැන් අපි එකඟ වී ඇත්තෙමු. new
ඕනෑම වස්තුවකට නැඹුරු භාෂාවක මෙහෙයුමේ අර්ථ දැක්වීම , එවැනි යතුරු පදයක් එක්තරා වර්ගයක පන්තියකින් (නිර්නාමික වර්ග ඇතුළුව, සී # වැනි අවස්ථාවන්හිදී) වස්තු නිදසුනක් නිර්මාණය කිරීමට භාවිතා කරන බව පවසයි.
EcmaScript හි ඔබට පිරිවිතර වලින් කියවිය හැකි පරිදි අපි පන්ති භාවිතා නොකරමු:
ECMAScript C ++, Smalltalk, හෝ Java වැනි පන්ති භාවිතා නොකරයි. ඒ වෙනුවට වස්තූන් වචනානුසාරයෙන් අංකනය කිරීම හරහා හෝ වස්තු නිර්මාණය කරන ඉදිකිරීම්කරුවන් හරහා විවිධ ආකාරවලින් නිර්මාණය කළ හැකි අතර පසුව ඒවායේ ගුණාංගවලට ආරම්භක අගයන් ලබා දීමෙන් ඒවා සියල්ලම හෝ කොටසක් ආරම්භ කරන කේතය ක්රියාත්මක කරන්න. සෑම ඉදිකිරීම්කරුවෙකුම - මූලාකෘති පදනම් කරගත් උරුමයක් සහ හවුල් දේපල ක්රියාත්මක කිරීම සඳහා භාවිතා කරන - මූලාකෘති as නම් වූ දේපලක් ඇති ශ්රිතයකි.
නව ප්රකාශනවල ඉදිකිරීම්කරුවන් භාවිතා කිරීමෙන් වස්තු නිර්මාණය වේ ; උදාහරණයක් ලෙස, නව දිනය (2009,11) නව දිනය වස්තුවක් නිර්මාණය කරයි. අළුත් භාවිතා නොකර ඉදිකිරීම්කරුවකුට ආයාචනා කිරීම ඉදිකිරීම්කරු මත රඳා පවතින ප්රතිවිපාක ඇත. නිදසුනක් ලෙස, දිනය () මඟින් වස්තුවකට වඩා වත්මන් දිනය හා වේලාව නිරූපණය කරයි.
මෙම new
මූල පදය වන ඉදිකිරීමටත් කාර්යය සිට වස්තුව නිර්මාණය කිරීමට ජාවාස්ක්රිප්ට් භාවිතා වේ. ප්රධාන new
පදය ඉදිකිරීම්කරුගේ ක්රියාකාරී ඇමතුම ඉදිරියේ තැබිය යුතු අතර පහත සඳහන් දේ කරනු ඇත:
this
අළුතින් සාදන ලද වස්තුවට යතුරු පදය බන්ධනය කර ඉදිකිරීම්කරුගේ ක්රියාකාරිත්වය ක්රියාත්මක කරයිfunction Dog (age) {
this.age = age;
}
const doggie = new Dog(12);
console.log(doggie);
console.log(Object.getPrototypeOf(doggie) === Dog.prototype) // true
හරියටම සිදුවන්නේ කුමක්ද:
const doggie
පවසයි: විචල්යයක් ප්රකාශ කිරීම සඳහා අපට මතකය අවශ්යයි.=
පවසයි: අපි මෙම විචල්යය ප්රකාශනයෙන් පසුව ආරම්භ කිරීමට යන්නෙමු=
new Dog(12)
. JS එන්ජිම නව මූල පදය දකින අතර, නව වස්තුවක් නිර්මාණය කර Dog.prototype වෙත මූලාකෘතිය සකසයිthis
නව වස්තුවට සකසා ඇති අගය සමඟ ක්රියාත්මක වේ . මෙම පියවරේදී අළුත් නිර්මාණය කරන ලද සුනඛ වස්තුවට වයස නියම කර ඇත.