ජාවාස්ක්‍රිප්ට් හි 'නව' යතුර කුමක්ද?


1751

newජාවාස්ක්‍රිප්ට් හි මූල පදය පළමු වරට හමු වූ විට එය ව්‍යාකූල විය හැකිය, මන්ද ජාවාස්ක්‍රිප්ට් යනු වස්තු-නැඹුරු වැඩසටහන්කරණ භාෂාවක් නොවන බව මිනිසුන් සිතීමට පෙළඹේ.

  • එය කුමක් ද?
  • එය විසඳන්නේ කුමන ගැටලු ද?
  • එය සුදුසු වන්නේ කවදාද සහ කවදාද?

10
එසේම, අදාළ නූල් - stackoverflow.com/questions/383402/...
Chetan එස්

මෙම උදාහරණ පළමු ජනතාවට දැනෙන කියවන්න, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
Martian2049

Answers:


2152

එය දේවල් 5 ක් කරයි:

  1. එය නව වස්තුවක් නිර්මාණය කරයි. මෙම වස්තුවේ වර්ගය හුදෙක් වස්තුවකි .
  2. එය මෙම නව වස්තුවේ අභ්‍යන්තර, ප්‍රවේශ කළ නොහැකි, [[මූලාකෘති]] (එනම් __proto__ ) දේපල ඉදිකිරීම්කරුගේ කාර්යයේ බාහිර, ප්‍රවේශ විය හැකි, මූලාකෘති වස්තුවක් බවට පත් කරයි (සෑම ක්‍රියාකාරී වස්තුවකටම ස්වයංක්‍රීයව මූලාකෘති ගුණාංගයක් ඇත).
  3. එය thisඅළුතින් සාදන ලද වස්තුවට විචල්‍ය ලක්ෂ්‍යය කරයි.
  4. අළුතින් සාදන ලද වස්තුව thisසඳහන් වන සෑම අවස්ථාවකම එය භාවිතා කරමින් ඉදිකිරීම්කරුගේ ක්‍රියාකාරිත්වය ක්‍රියාත්මක කරයි .
  5. ඉදිකිරීම්කරුගේ ශ්‍රිතය 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

අවසාන වශයෙන් මෙම පිටුව සොයා ගැනීමට පෙර මම මෙම විෂය පිළිබඳ කුණු ටොන් ගණනක් කියවා ඇත්තෙමි , එහිදී මෙය හොඳ රූපසටහන් සමඟ ඉතා හොඳින් විස්තර කර ඇත.


47
එකතු කිරීමට අවශ්‍යය: ඇත්ත වශයෙන්ම __proto__ විසින් අභ්‍යන්තර [[මූලාකෘති]] වෙත ප්‍රවේශ වීමට ක්‍රමයක් තිබේ. කෙසේ වෙතත් මෙය සම්මත නොවන අතර සාපේක්ෂව නව බ්‍රව්සර් මගින් පමණක් සහාය දක්වයි (සහ ඒවා සියල්ලම නොවේ). Object.getPrototypeOf (obj) නම් ප්‍රමිතිගත ක්‍රමයක් පැමිණෙමින් පවතී, නමුත් එය Ecmascript3.1 වන අතර එය නව බ්‍රවුසර සඳහා පමණක් සහය දක්වයි - නැවතත්. සාමාන්‍යයෙන් එම දේපල භාවිතා නොකිරීමට රෙකමදාරු කරනු ලැබේ.
බ්ලබ්

9
ප්‍රශ්නය: ObjMakerඅගයක් ලබා දෙන ශ්‍රිතයක් ලෙස අර්ථ දැක්වුවහොත් වෙනස් ලෙස කුමක් සිදුවේද ?
ජිම් බ්ලැක්ලර්

13
OneLonelyPixel newපවතින බැවින් ඔබට කාර්යයන් / වස්තු තැනීමට / පිටපත් කිරීමට කර්මාන්තශාලා ක්‍රම ලිවීමට අවශ්‍ය නොවේ . එහි තේරුම, "මෙය පිටපත් කරන්න, එය එහි මව් පන්තියට සමාන කරන්න; එය කාර්යක්ෂමව හා නිවැරදිව කරන්න; මට පමණක් ප්‍රවේශ විය හැකි උරුම තොරතුරු ගබඩා කරන්න, ජේඑස්, අභ්‍යන්තරව". එසේ කිරීම සඳහා, එය prototypeසම්භාව්‍ය OO උරුම දාමයන් අනුකරණය කරමින් (ධාවන කාල වෙනස් කළ නොහැකි) නව වස්තුවෙහි වෙනත් ආකාරයකින් ප්‍රවේශ විය නොහැකි අභ්‍යන්තරය වෙනස් කරයි. ඔබට මෙය නොමැතිව අනුකරණය කළ හැකිය new, නමුත් උරුමය ධාවන කාල වෙනස් කළ හැකිය. හොඳ? නරක? ඔබට බාරයි.
ඉංජිනේරු

11
එකතු කිරීමට කුඩා කරුණක්: නව මූල පදයට පෙර ඉදිකිරීම්කරුවකුට ඇමතුමක්, සාදන ලද වස්තුව ස්වයංක්‍රීයව ආපසු ලබා දෙයි; ඉදිකිරීම්කරු තුළ සිට එය පැහැදිලිව ආපසු යැවීමේ අවශ්‍යතාවයක් නොමැත.
චාලි රොබට්ස්

7
එහි සටහනක් තිබේ Notice that this pattern is deprecated!. පංතියක මූලාකෘතිය සැකසීමට නිවැරදි යාවත්කාලීන රටාව කුමක්ද?
ටොම් පැයුරෙක්

400

ඔබට මෙම කාර්යය ඇතැයි සිතමු:

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. ඕනෑම කාර්යයක් ඉදිකිරීම්කරුවෙකු විය හැකිය, එය සැමවිටම අර්ථවත් නොවේ.


7
ක්‍රියාත්මක කිරීමේ සන්දර්භය මත රඳා පවතී. මගේ කාරණයේදී (Qt ස්ක්‍රිප්ටින්) එය ගෝලීය වස්තුවක් පමණි.
මැක්සිම්

2
මෙය වැඩි මතක භාවිතයකට හේතු වේද?
ජර්ගන් පෝල්

2
කවුළුව යනු ශ්‍රිතය ලෙස හැඳින්වෙන වස්තුව වන බැවින් විය යුතුය: කවුළුව යනු ශ්‍රිතය අඩංගු වස්තුව වන බැවිනි .
ඩේවිඩ් හෝර්වාත්

1
A ටෝරස් වෙබ් බ්‍රව්සරයක ක්‍රම නොවන ශ්‍රිතයක් windowව්‍යංගයෙන් ක්‍රමයක් වනු ඇත . වසා දැමීමේදී පවා, නිර්නාමික වුවද. කෙසේ වෙතත්, උදාහරණයේ දී එය කවුළුවේ සරල ක්‍රමවේදය වේ: Foo();=> [default context].Foo();=> window.Foo();. මෙම ප්රකාශනය තුළ windowතමයි සන්දර්භය (පමණක් නොව, ඇමතුම ප්රශ්නයක් නොවන,).
ඩේවිඩ් හෝර්වාත්

1
A ටෝරස් මූලික වශයෙන් ඔව්. කෙසේ වෙතත් ECMA 6 සහ 7 හි දේවල් වඩාත් සංකීර්ණ වේ (ලැම්බඩා, පන්ති ආදිය බලන්න).
ඩේවිඩ් හෝර්වාත්

164

ඩැනියෙල් හොවාර්ඩ්ගේ පිළිතුරට අමතරව, කරන්නේ කුමක්ද 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);

73
ජාවාස්ක්‍රිප්ට් ඉංග්‍රීසි
භාෂාවට

විශිෂ්ට පිළිතුර. සඳහා කෙසේද එය කළ හැකි විය හැක: මම ඉතා කුඩා ප්රශ්නයක් තියෙනවා func.prototypeවෙන්න null? කරුණාකර ඔබට ඒ ගැන ටිකක් විස්තර කළ හැකිද?
ටොම් පැයුරෙක්

6
සරලව ලිවීමෙන් ඔබට මූලාකෘති දේපල අභිබවා යා හැකිය, A.prototype = null;එම අවස්ථාවේ new A()දී වස්තුව මත සිදුවනු ඇත, එය අභ්‍යන්තර මූලාකෘති Objectවස්තුව වෙත යොමු කරයි : jsfiddle.net/Mk42Z
basilikum

2
ධාරක වස්තුවකට "වස්තුව" හෝ "ශ්‍රිතය" ට වඩා වෙනස් දෙයක් නිපදවිය හැකි බැවින් යතුරු ලියනය පරීක්ෂා කිරීම වැරදිය. යමක් වස්තුවක් දැයි පරීක්ෂා කිරීමට, මම වඩාත් කැමැත්තෙමි Object(ret) === ret.
ඔරියෝල්

2
Ori ඔරියෝල් අදහස් දැක්වීමට ස්තූතියි. ඔබ පවසන දෙය සත්‍යයක් වන අතර ඕනෑම සත්‍ය පරීක්ෂණයක් වඩාත් ශක්තිමත් ආකාරයකින් කළ යුතුය. කෙසේ වෙතත්, මම සිතන්නේ මෙම සංකල්පීය පිළිතුර සඳහා, typeofපරීක්ෂණය මඟින් තිරය පිටුපස සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීම පහසු කරයි.
බැසිලිකම්

109

ආරම්භකයින්ට එය වඩා හොඳින් තේරුම් ගැනීමට

බ්‍රව්සර් කොන්සෝලය තුළ පහත කේතය උත්සාහ කරන්න.

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

දැන් ඔබට ප්‍රජා විකී පිළිතුර කියවිය හැකිය :)


4
හොඳ පිළිතුරක්. එසේම - පිටවීමෙන් return this;එකම ප්‍රතිදානය ලැබේ.
නෙළු

37

එබැවින් එය බොහෝ විට වස්තු අවස්ථා නිර්මාණය කිරීම සඳහා නොවේ

එය හරියටම ඒ සඳහා භාවිතා කරයි. ඔබ එසේ ක්‍රියාකරවන්නෙකු ලෙස අර්ථ දක්වයි:

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

var john = new Person('John');

කෙසේ වෙතත් ECMAScript හි ඇති අමතර වාසිය නම් ඔබට .prototypeදේපල සමඟ විස්තාරණය කළ හැකි නිසා අපට එවැනි දෙයක් කළ හැකිය ...

Person.prototype.getName = function() { return this.name; }

මෙම ඉදිකිරීම්කරුගෙන් සාදන ලද සියලුම වස්තූන් වලට දැන් getNameප්‍රවේශ විය හැක්කේ මූලාකෘති දාමය නිසාය.


6
ශ්‍රිත ඉදිකිරීම්කරුවන් පන්ති මෙන් භාවිතා කරයි, classයතුරු පදයක් නැත, නමුත් ඔබට එකම දේ කළ හැකිය.
meder omuraliev

එහි පංතියේ මූලික පදයක් ඇත - පන්තිය අනාගත භාවිතය සඳහා වෙන් කර ඇත
ග්‍රෙග්

11
CSS පන්තියක් සැකසීමට ඔබ .className නොවේ .class භාවිතා කරන්නේ එබැවිනි
ග්‍රෙග්

23
එය සම්මුතියෙන් පුද්ගලයා ප්‍රාග්ධනීකරණය කළ යුතුය.
eomeroff

27

ජාවාස්ක්‍රිප්ට් යනු වස්තු-නැඹුරු ක්‍රමලේඛන භාෂාවක් වන අතර එය හරියටම අවස්ථා නිර්මාණය කිරීම සඳහා භාවිතා කරයි. එය පන්ති පදනම් කරගත් ඒවාට වඩා මූලාකෘති මත පදනම් වූ නමුත් එයින් අදහස් කරන්නේ එය වස්තු-නැඹුරු නොවන බවයි.


6
ජාවාස්ක්‍රිප්ට් එම සියලු පන්ති පදනම් කරගත් භාෂාවන්ට වඩා වස්තු-නැඹුරු බව පෙනේ. ජාවාස්ක්‍රිප්ට් හි ඔබ ලියන සෑම දෙයක්ම ක්ෂණිකව වස්තුවක් බවට පත්වේ, නමුත් පන්ති පදනම් කරගත් භාෂාවලින් ඔබ පළමුව ප්‍රකාශන ලියන අතර පසුව පමණක් ඔබ පන්තිවල නිශ්චිත අවස්ථා (වස්තු) නිර්මාණය කරයි. ජාවාස්ක්‍රිප්ට් මූලාකෘතිය පන්ති පදනම් කරගත් භාෂාවන් සඳහා VTABLE දේවල් අපැහැදිලි ලෙස මතක් කර ඇති බව පෙනේ.
JustAMartin

14

ජාවාස්ක්‍රිප්ට් යනු ගතික ක්‍රමලේඛන භාෂාවක් වන අතර එය වස්තු දිශානත ක්‍රමලේඛන ආදර්ශයට සහාය වන අතර එය වස්තුවේ නව අවස්ථා නිර්මාණය කිරීම සඳහා භාවිතා කරයි.

වස්තූන් සඳහා පන්ති අවශ්‍ය නොවේ - ජාවාස්ක්‍රිප්ට් යනු මූලාකෘති පදනම් කරගත් භාෂාවකි.


12

මේ වන විටත් ඉතා හොඳ පිළිතුරු කිහිපයක් ඇත, නමුත් ඔබ විසින් සිදුකරන ලද ශ්‍රිතයක පැහැදිලි ප්‍රතිලාභ ප්‍රකාශයක් ඇති විට කුමක් සිදුවේද යන්න පිළිබඳව පහත දැක්වෙන තුන්වන අවස්ථාව පිළිබඳ මගේ නිරීක්ෂණය අවධාරණය කිරීමට මම නව එකක් පළ කරමි 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.

මෙම ත්‍රෙඩ් එකේ ඔවුන් අතර ඇති වෙනස ගැන ඔබට කියවිය හැකිය .


ඔබේ නඩුව 3, gr8 නිරීක්‍ෂණයකි
appu

5

සමහර විට කේත වචන වලට වඩා පහසු ය:

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 විලාසිතාව භාවිතා කරමි.


3
B1 = new func2(2); <- මෙය නොතිබෙන්නේ B1.y ඇයි?
sunny_dev

unSunny_dev මම JS විශේෂ expert යෙක් නොවෙමි , නමුත් බොහෝ විට func2 අභ්‍යන්තර අගයන් සමඟ වැඩ කිරීම / නැවත පැමිණීම වෙනුවට සෘජුවම වටිනාකමක් (z වස්තුවක්) ලබා දෙන නිසා (මෙය)
ඊගල්

5

මෙම newමූල පදය උත්සවයට ලකුණු වීම හා එම සන්දර්භය සූචකය වන යටතේ සන්දර්භය වෙනස් වෙනවා.

ඔබ newමූල පදය භාවිතා නොකරන විට , ශ්‍රිතය ක්‍රියාත්මක වන සන්දර්භය ඔබ ශ්‍රිතය Vehicle()ලෙස හඳුන්වන සන්දර්භය Vehicleවේ. මෙම thisඉඟි පද එම සන්දර්භය වෙත යොමු කරනු ඇත. ඔබ භාවිතා කරන විට new Vehicle(), නව සන්දර්භයක් නිර්මාණය වන බැවින් thisශ්‍රිතය තුළ ඇති ප්‍රධාන පදය නව සන්දර්භය වෙත යොමු වේ. ඔබට ආපසු ලැබෙන්නේ අලුතින් සාදන ලද සන්දර්භයයි.


විෂය පථය අනුව එය ඉතා බුද්ධිමත් පිළිතුරකි. Gr8 පිළිතුරට එකතු කිරීම.
appu

3

මෙම newමූල පදය නව වස්තුව අවස්ථා නිර්මාණය කිරීම සඳහා වේ. ඔව්, ජාවාස්ක්‍රිප්ට් යනු ගතික ක්‍රමලේඛන භාෂාවක් වන අතර එය වස්තු දිශානත ක්‍රමලේඛන ආදර්ශයට සහාය වේ. වස්තු නම් කිරීම පිළිබඳ සම්මුතිය නම්, සෑම විටම නව මූල පදයෙන් ක්ෂණිකව දැක්විය යුතු වස්තූන් සඳහා ලොකු අකුර භාවිතා කරන්න.

obj = new Element();

1

ප්‍රධාන newපදය මඟින් ඉදිකිරීම්කරුවෙකු ලෙස කාර්යයන් භාවිතා කරන වස්තූන්ගේ අවස්ථා නිර්මාණය කරයි. උදාහරණයක් වශයෙන්:

var Foo = function() {};
Foo.prototype.bar = 'bar';

var foo = new Foo();
foo instanceof Foo; // true

ඉදි කරන්නන්ගේ ශ්‍රිතයෙන් අවස්ථා උරුම prototypeවේ. ඉහත උදාහරණය අනුව ...

foo.bar; // 'bar'

2
නව මූල පදය මූලික වශයෙන් දැනටමත් ඉදිකිරීම්කරු ලෙස ශ්‍රිතය සම්බන්ධ කරයි; ඔබට කිසිවක් ආපසු ලබා දීමට අවශ්‍ය නැත. ඔබට කළ හැක්කේ: ශ්‍රිතය foo (x) {this.bar = x; } var obj = නව foo (10); ඇඟවීම් (obj.bar);
reko_t

යම් අරමුණක් සඳහා ඔබට නිශ්චිතවම අවශ්‍ය නම් මිස, ඉදිකිරීම්කරුගේ ශ්‍රිතයෙන් වස්තු ආපසු ලබා දිය යුතු නොවේ. උදාහරණයක් ලෙස, සෑම විටම නව වස්තුවක් නිර්මාණය කරනවා වෙනුවට නිශ්චිත වස්තුවක් නැවත ලබා දිය යුතු නම් (කුමන හේතුවක් නිසා හෝ). කෙසේ වෙතත්, ඔබේ උදාහරණයේ එය සම්පූර්ණයෙන්ම අනවශ්‍යය.
චෙතන් එස්

හොඳයි, එය උදාහරණයක්. ඔබට වස්තුවක් ආපසු ලබා දිය හැකිය . මෙම තත්වය තුළ බොහෝ රටා භාවිතා කර ඇත, මම එකක් "උදාහරණයක් ලෙස" ලබා දුන්නෙමි, එබැවින් මගේ වචන "උදාහරණයක් ලෙස".
අක්ෂි රහිත බව

1

සෑම ජාවාස්ක්‍රිප්ට් එකක්ම වේදිකාවෙන් වේදිකාවට බෙහෙවින් වෙනස් විය හැකි බැවින් එය සෑම විටම මුල් පිරිවිතර EcmaScript ක්‍රියාත්මක කිරීමකි.

කෙසේ වෙතත්, ක්‍රියාත්මක කිරීමෙන් ස්වාධීනව, එක්මාස්ක්‍රිප්ට් පිරිවිතර අයිතිය අනුගමනය කරන සියලුම ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම් මඟින් ඔබට වස්තු දිශානත භාෂාවක් ලබා දෙනු ඇත. ES ප්‍රමිතියට අනුව:

ECMAScript යනු ධාරක පරිසරයක් තුළ ගණනය කිරීම් සිදු කිරීම සහ පරිගණකමය වස්තු හැසිරවීම සඳහා වස්තු-නැඹුරු වැඩසටහන්කරණ භාෂාවකි.

ජාවාස්ක්‍රිප්ට් යනු එක්මාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමක් බවත් එබැවින් එය වස්තු-නැඹුරු භාෂාවක් බවත් දැන් අපි එකඟ වී ඇත්තෙමු. newඕනෑම වස්තුවකට නැඹුරු භාෂාවක මෙහෙයුමේ අර්ථ දැක්වීම , එවැනි යතුරු පදයක් එක්තරා වර්ගයක පන්තියකින් (නිර්නාමික වර්ග ඇතුළුව, සී # වැනි අවස්ථාවන්හිදී) වස්තු නිදසුනක් නිර්මාණය කිරීමට භාවිතා කරන බව පවසයි.

EcmaScript හි ඔබට පිරිවිතර වලින් කියවිය හැකි පරිදි අපි පන්ති භාවිතා නොකරමු:

ECMAScript C ++, Smalltalk, හෝ Java වැනි පන්ති භාවිතා නොකරයි. ඒ වෙනුවට වස්තූන් වචනානුසාරයෙන් අංකනය කිරීම හරහා හෝ වස්තු නිර්මාණය කරන ඉදිකිරීම්කරුවන් හරහා විවිධ ආකාරවලින් නිර්මාණය කළ හැකි අතර පසුව ඒවායේ ගුණාංගවලට ආරම්භක අගයන් ලබා දීමෙන් ඒවා සියල්ලම හෝ කොටසක් ආරම්භ කරන කේතය ක්‍රියාත්මක කරන්න. සෑම ඉදිකිරීම්කරුවෙකුම - මූලාකෘති පදනම් කරගත් උරුමයක් සහ හවුල් දේපල ක්‍රියාත්මක කිරීම සඳහා භාවිතා කරන - මූලාකෘති as නම් වූ දේපලක් ඇති ශ්‍රිතයකි.
නව ප්‍රකාශනවල ඉදිකිරීම්කරුවන් භාවිතා කිරීමෙන් වස්තු නිර්මාණය වේ ; උදාහරණයක් ලෙස, නව දිනය (2009,11) නව දිනය වස්තුවක් නිර්මාණය කරයි. අළුත් භාවිතා නොකර ඉදිකිරීම්කරුවකුට ආයාචනා කිරීම ඉදිකිරීම්කරු මත රඳා පවතින ප්‍රතිවිපාක ඇත. නිදසුනක් ලෙස, දිනය () මඟින් වස්තුවකට වඩා වත්මන් දිනය හා වේලාව නිරූපණය කරයි.


1

සාරාංශය:

මෙම newමූල පදය වන ඉදිකිරීමටත් කාර්යය සිට වස්තුව නිර්මාණය කිරීමට ජාවාස්ක්රිප්ට් භාවිතා වේ. ප්‍රධාන newපදය ඉදිකිරීම්කරුගේ ක්‍රියාකාරී ඇමතුම ඉදිරියේ තැබිය යුතු අතර පහත සඳහන් දේ කරනු ඇත:

  1. නව වස්තුවක් නිර්මාණය කරයි
  2. මෙම වස්තුවේ මූලාකෘතිය ඉදිකිරීම්කරුගේ ශ්‍රිතයේ මූලාකෘති ගුණාංගයට සකසයි
  3. thisඅළුතින් සාදන ලද වස්තුවට යතුරු පදය බන්ධනය කර ඉදිකිරීම්කරුගේ ක්‍රියාකාරිත්වය ක්‍රියාත්මක කරයි
  4. අලුතින් සාදන ලද වස්තුව ලබා දෙයි

උදාහරණයක්:

function Dog (age) {
  this.age = age;
}

const doggie = new Dog(12);

console.log(doggie);
console.log(Object.getPrototypeOf(doggie) === Dog.prototype) // true

හරියටම සිදුවන්නේ කුමක්ද:

  1. const doggie පවසයි: විචල්‍යයක් ප්‍රකාශ කිරීම සඳහා අපට මතකය අවශ්‍යයි.
  2. පැවරුම් ක්‍රියාකරු =පවසයි: අපි මෙම විචල්‍යය ප්‍රකාශනයෙන් පසුව ආරම්භ කිරීමට යන්නෙමු=
  3. ප්‍රකාශනය new Dog(12). JS එන්ජිම නව මූල පදය දකින අතර, නව වස්තුවක් නිර්මාණය කර Dog.prototype වෙත මූලාකෘතිය සකසයි
  4. ඉදිකිරීම්කරුගේ ශ්‍රිතය thisනව වස්තුවට සකසා ඇති අගය සමඟ ක්‍රියාත්මක වේ . මෙම පියවරේදී අළුත් නිර්මාණය කරන ලද සුනඛ වස්තුවට වයස නියම කර ඇත.
  5. අලුතින් සාදන ලද වස්තුව ආපසු ලබා දී විචල්ය සුනඛයාට පවරනු ලැබේ.
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.