දත්ත වර්ග ස්වයංක්රීයව පරිවර්තනය කිරීම
ඔබ දැනටමත් දන්නා පරිදි, JavaScript හි අකුරු පේළි උද්දහන ලකුණු තුළ ගත යුතුය. අකුරු පේළියේ සියලුම සංකේත ඉලක්කම් විය හැකිය:
let a = '123';
මෙම අවස්ථාවේ දී, a විචල්යය ද
අකුරු පේළියක් වේ, නමුත් ඇතැම් සූක්ෂ්මතාවයක් සමඟ.
සූක්ෂ්මතාවයේ සාරය පහත පරිදිය: ඉලක්කම් සහිත අකුරු පේළියක් ඉහත යම් ගණිතමය ක්රියාවක් සිදු කළහොත් - මෙම ක්රියාව සිදු වන්නේ අපට ඇත්තෙන්ම සංඛ්යා ඇති බවක් මෙන්, අකුරු පේළි නොවේ:
alert('2' * '3'); // 6 ප්රදර්ශනය කරයි
මෙම අවස්ථාවේ දී JavaScript දකී, අපි අකුරු පේළි සඳහා අනුමත නොවන, නමුත් සංඛ්යා සඳහා අනුමත ක්රියාවක් සිදු කිරීමට උත්සාහ කරන බව.
ඔහු එසේම දකී, අපගේ අකුරු පේළි යථාර්ථයේ දී උද්දහන ලකුණු තුළ ඇති සංඛ්යා වේ. එබැවින් JavaScript මෙම අකුරු පේළි ස්වයංක්රීයව සංඛ්යා බවට පරිවර්තනය කර ඒවා ඉහත අදාළ ගණිතමය ක්රියාව සිදු කරයි.
මෙය ක්රියාත්මක වන්නේ, අපගේ අකුරු පේළිවල ඇත්තේ
ඉලක්කම් පමණක් නම්.
එහි අකුරක්වත් තිබේ නම්
- JavaScript ක්රියාව වලංගු නොවන ලෙස සලකා
එහි ප්රතිඵලය NaN අගය කරයි:
alert('2' * '3s'); // NaN ප්රදර්ශනය කරයි
ඊට අමතරව, ස්වයංක්රීය පරිවර්තනය සිදු වන්නේ, ක්රියාව ගණිතමය වශයෙන් වලංගු නම්, නමුත් අකුරු පේළි සඳහා අනුමත නොවේ නම්.
උදාහරණයක් ලෙස, අකුරු පේළි ගුණ කිරීමට, බෙදීමට, අඩු කිරීමට නොහැකිය (නමුත් සංඛ්යා හැකිය), එබැවින් එවැනි සියලු ක්රියාවන්හිදී ඉලක්කම් සහිත අකුරු පේළි ස්වයංක්රීයව සංඛ්යා බවට පරිවර්තනය වේ.
කෙසේ වෙතත්, අකුරු පේළි, සංඛ්යා මෙන්, එකතු කරනු ලබන්නේ
+ මෙහෙයුම්කරු භාවිතයෙනි. මෙයින් අදහස් කරන්නේ,
එකතු කිරීමේ දී ස්වයංක්රීය පරිවර්තනය
සිදු නොවනු ඇති බවයි:
let a = '1' + '2';
alert(a); // '12' ප්රදර්ශනය කරයි - අකුරු පේළි එකතු විය
එක් එකතු කිරීමක් සංඛ්යාවක් නම්, අනෙක - අකුරු පේළියක් නම්, සෑම විටම අකුරු පේළිය ජය ගනී:
let a = 1 + '2';
alert(a); // '12' ප්රදර්ශනය කරයි
එවැනි අවස්ථාවන්හිදී JavaScript, ඊට ප්රතිවිරුද්ධව, ස්වයංක්රීයව සංඛ්යා අකුරු පේළි බවට පරිවර්තනය කර අකුරු පේළි එකතු කිරීම සිදු කරයි.
කෙසේ වෙතත්, සූක්ෂ්මතා ඇත, එකතු කිරීම් දෙකට වඩා වැඩි විට: මෙම අවස්ථාවේ දී, නිශ්චිත වර්ගයකට පරිවර්තනය ක්රියා සිදු කිරීමේ අනුපිළිවෙල මත රඳා පවතී.
පහත උදාහරණයේ දී මුලින්ම 2 සහ 3
සංඛ්යා ලෙස එකතු වනු ඇත, ඉන්පසු ප්රතිඵලය එකතු වනු ඇත
අකුරු පේළියට '1' දැනටමත් අකුරු පේළියක් ලෙස '5',
අවසානයේදී අකුරු පේළිය '15' ලබා දෙයි:
let a = '1' + (2 + 3);
alert(a); // '15' ප්රදර්ශනය කරයි
වරහන් ඉවත් කළහොත්, සියල්ල එකතු වනු ඇත
වමේ සිට දකුණට. එනම් මුලින්ම අකුරු පේළියට '1'
සංඛ්යාව 2 එකතු වනු ඇති අතර ප්රතිඵලයක් ලෙස
අකුරු පේළිය '12' ලැබේ. ඉන්පසු මෙම
අකුරු පේළියට සංඛ්යාව 3 එකතු වනු ඇති අතර ප්රතිඵලයක් ලෙස
අකුරු පේළිය '123' ලැබේ:
let a = '1' + 2 + 3;
alert(a); // '123' ප්රදර්ශනය කරයි
නමුත් පහත උදාහරණයේ දී සංඛ්යා 2
සහ 3 ආරම්භයේ දී ලියා ඇත, එබැවින් මුලින්ම
ඒවා සංඛ්යා ලෙස එකතු වී ප්රතිඵලයක් ලෙස
සංඛ්යාව 5 ලබා දෙනු ඇත, ඉන්පසු මෙම සංඛ්යාවට එකතු වනු ඇත
අකුරු පේළිය '1', අවසානයේදී අකුරු පේළිය '51' ලබා දෙයි:
let a = 2 + 3 + '1';
alert(a); // '51' ප්රදර්ශනය කරයි
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' + '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' + 2;
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = 5 + '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = 5 + 2;
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' * '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' - '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' / '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' % '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5s' * '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5s' + '2';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = (-'5') + (-'2');
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' * 1 + '2' * 1;
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '5' * '1' + '2' * '1';
alert(a);
කේතය ක්රියාත්මක නොකර, තිරයේ දිස්වන්නේ කුමක්දැයි නිර්ණය කරන්න:
let a = '' + 3 + 1;
alert(a);
