JavaScript හි IIFE හි පිහිනුම් ගල්
කේත කොටස් දෙකක් ගැන සලකා බලමු.
පළමුවැන්න:
let result = 1
+function() {
return 2;
}();
console.log(result);
දෙවැන්න:
let result = 1;
+function() {
return 2;
}();
console.log(result);
මෙම කේත කොටස් දෙක පාහේ සමාන වේ,
නමුත් ඒවා ක්රියාත්මක කළ විට ප්රතිඵලය වෙනස් වේ.
පළමු කේතය කොන්සෝලයේ අංකය 3 පෙන්වයි,
දෙවැන්න අංකය 1 පෙන්වයි.
මෙවැනි වෙනසක් ඇති වීමට හේතුව: එක් අවස්ථාවක පළමු පේළියේ අවසානයේ අර්ධ විරාමය (සෙමිකෝලන්) නොමැතිවීමයි, දෙවන අවස්ථාවේදී - එය පවතී.
ඔබ ප්රශ්න කරන්නේ: කෙසේද, JavaScript හි විධානයක අවසානයේ අර්ධ විරාමය අනිවාර්ය නොවේ නම්! ඇත්ත වශයෙන්ම මෙය සම්පූර්ණයෙන් සත්ය නොවේ. අපි සොයා බලමු, සැබවින්ම කුමක් සිදුවේද කියා.
පළමු කේතය මෙසේ නැවත ලිවිය හැකිය:
let result = 1 + function() {
return 2;
}();
console.log(result); // පෙන්වන්නේ 3
දැන් වහාම පැහැදිලි වන්නේ,
එකකට එකතු වන්නේ තැනින් ම ක්රියාත්මක වන ශ්රිතයේ
ප්රතිඵලය, එනම් 2 බවයි. එමනිසා අවසාන
ප්රතිඵලය වන්නේ 3 ය.
නමුත් එකකට පසුව අර්ධ විරාමය දැමුවහොත්, කේතය අර්ථකථනය කිරීමේ යන්ත්රය විසින් වෙනස් ලෙස ග්රහණය කරනු ලැබේ:
// පළමු විධානය:
let result = 1;
// දෙවන විධානය:
+function() {
return 2;
}();
// තෙවන විධානය:
console.log(result); // පෙන්වන්නේ 1
එනම්, විචල්යයට අගය පැවරීම සහ තැනින් ම ශ්රිත ක්රියාත්මක කිරීම වෙනස් විධාන බවට පත් වේ. සියල්ලම අර්ධ විරාමයේ පැවැත්ම නිසා!
පෙනෙන පරිදි, මෙම අවස්ථාවේදී තැනින් ම ශ්රිත ක්රියාත්මක කිරීම
කිසිවක් කරන්නේ නැත - සරලව
කිසිදු තැනකට අංකය 2 ආපසු ලබා දෙයි, එය
විචල්යය result මත කිසිදු ආකාරයක බලපෑමක් නොකරයි.
එහෙනම් අපි සොයා බලමු, JavaScript හි අපට සාමාන්යයෙන් අර්ධ විරාමය ලිවිය නොහැක්කේ ඇයි කියා. අපට අර්ධ විරාම නොමැතිව මෙවැනි කේතයක් ඇතැයි සිතමු:
let result = 1 // result ට 1 ලියනු ලැබේ
let test = 2 // test ට 2 ලියනු ලැබේ
එය නිවැරදිව ක්රියා කරයි, මන්ද අර්ථකථන යන්ත්රය ස්වයංක්රීයව එක් එක් පේළිය අවසානයේ අර්ධ විරාමය තබයි.
නමුත් මෙම කේතය දෙස බලන්න:
let result = 1
+ 2; // result ට 3 ලියනු ලැබේ
දැන් පළමු පේළියේ අවසානයේ අර්ධ විරාමය ස්වයංක්රීයව තබා නොගනී, මන්ද අර්ථකථන යන්ත්රයට තේරෙන්නේ දෙවන පේළියේ විධානය - එය පළමු පේළියේ විධානයේ කොටසක් බවයි.
නමුත් අප විසින්ම අර්ධ විරාමය තැබුවහොත් - ප්රතිඵලය සම්පූර්ණයෙන්ම වෙනස් වේ:
let result = 1; // result ට 1 ලියනු ලැබේ
+ 2; // විධානය කිසිවක් නොකරයි, නමුත් දෝෂයක්ද නොමැත
පෙනෙන පරිදි, අර්ථකථන යන්ත්රය ස්වයංක්රීයව අර්ධ විරාමය තබන්නේ, පහත විධානය පෙර විධානයේ කොටසක් නොවේ නම් පමණි.
දැන් මෙම කේතය දෙස බලන්න:
let result = 1
+function() {
return 2;
}();
console.log(result);
ඇත්ත වශයෙන්ම, දෙවන පේළිය - සරලව පළමු පේළියේ විධානයේ දිගට ක්රියා කිරීමක් වන අතර අර්ථකථන යන්ත්රය අර්ධ විරාමය ස්වයංක්රීයව නොතබයි. එබැවින්ම, අප විසින්ම පළමු පේළිය අවසානයේ අර්ධ විරාමය ලියා ඇත්නම් - ප්රතිඵලය සම්පූර්ණයෙන්ම වෙනස් වේ. මෙයින් පෙන්නුම් කරන්නේ ගැටලු වළක්වා ගැනීම සඳහා, අවශ්ය ස්ථානවල සැමවිටම අර්ධ විරාමය තැබීම වඩාත්ම හොඳය.
