JavaScript හි නිත්ය ප්රකාශන හඳුන්වාදීම
නිත්ය ප්රකාශන යනු සංකීර්ණ සෙවීම හා ප්රතිස්ථාපනය (හෝ සරල සෙවීම) සඳහා වන විධාන වේ. ඒවා ඉතා සිත්ගන්නාසුලු දේවල් කිරීමට ඉඩ සලසා දෙන නමුත්, අවාසනාවකට මෙන්, ඉගෙනීම තරමක් දුෂ්කර ය.
නිත්ය ප්රකාශන සමඟ වැඩකිරීම සඳහා JavaScript හි ක්රම කිහිපයක් පවතී. අපි ඒවා සමඟ
හඳුනාගන්නා ආරම්භ කරන්නේ replace ක්රමයේ උදාහරණය මතය.
ඔබ දැනටමත් මෙම ක්රමය හඳුනාගෙන සිටිනවා: එය පළමු
පරාමිතියක් ලෙස මාරු කළ යුතු දේ පිළිගන්නා අතර දෙවන පරාමිතිය
ලෙස - එය කුමක් සමඟ ප්රතිස්ථාපනය කළ යුතු ද යන්න පිළිගනී. තවද ක්රමයම යොදනු ලබන්නේ
ප්රතිස්ථාපනය සිදු කරන අකුරු පේළියට ය:
'bab'.replace('a', '!'); // returns 'b!b'
මෙම ක්රමයේ පළමු පරාමිතියක් ලෙස සරල අකුරු පේළියක් පමණක් නොව,
නිත්ය ප්රකාශනයක් ද පවරා දිය හැකිය.
නිත්ය ප්රකාශනයක් නිරූපණය කරන්නේ
කොටස් තුළ ඇති විධාන කට්ටලයක් /. මෙම
කොටස් හඳුන්වනු ලබන්නේ නිත්ය ප්රකාශනවල
සීමා කරන්නන් ලෙස ය.
නිත්ය ප්රකාශනම සමන්විත වන්නේ ක්රම දෙකකින් සංකේත වලින්: ඒවායේම නිරූපණය කරන ඒවාගෙන් සහ විධාන-සංකේත වලින්, ඒවා හඳුන්වනු ලබන්නේ විශේෂ සංකේත ලෙස ය.
අක්ෂර සහ සංඛ්යා ඒවායේම නිරූපණය කරයි. පහත
උදාහරණයේ දී අපි නිත්ය ප්රකාශනයක් භාවිතයෙන්
අක්ෂරය 'a' අක්ෂරයෙන් ! ක් ලෙස ප්රතිස්ථාපනය කරමු:
'bab'.replace(/a/, '!'); // returns 'b!b'
නමුත් ලක්ෂ්යය යනු විශේෂ සංකේතයක් වන අතර
එය ඕනෑම සංකේතයක් නිරූපණය කරයි. පහත
උදාහරණයේ දී අපි මෙම රටාවට අනුව අකුරු පේළියක් සොයා ගනිමු:
අක්ෂරය 'x', පසුව ඕනෑම සංකේතයක්, පසුව
යළිත් අක්ෂරය 'x':
'xax eee'.replace(/x.x/, '!'); // returns '! eee'
සීමා කරන්නන්ට පසුව ලිවිය හැකිය සංශෝධක
- විධාන, ඒවා නිත්ය ප්රකාශනයේ සාමාන්ය ගුණාංග
වෙනස් කරයි. උදාහරණයක් ලෙස, සංශෝධකය
g සර්වත්ර සෙවීමේ සහ ප්රතිස්ථාපන ක්රමය සක්රිය කරයි
- එය නොමැතිව නිත්ය ප්රකාශනය සෙවන්නේ පළමු
ගැලපීම පමණක් වන අතර, එය සමඟ - සියලුම ගැලපීම්.
පහත උදාහරණයේ දී සංශෝධකය
g නියම කර නැති අතර නිත්ය ප්රකාශනය සොයා ගනු ඇත්තේ පළමු
ගැලපීම පමණි:
'aab'.replace(/a/, '!'); // returns '!ab'
දැන් නිත්ය ප්රකාශනය සියලුම ගැලපීම් සොයා ගනී:
'aab'.replace(/a/g, '!'); // returns '!!b'
අකුරු පේළියක් දී ඇත:
let str = 'ahb acb aeb aeeb adcb axeb';
නිත්ය ප්රකාශනයක් ලියන්න, එය සොයා ගනු ඇත
අකුරු පේළි 'ahb', 'acb', 'aeb'
රටාවට අනුව: අක්ෂරය 'a', ඕනෑම සංකේතයක්,
අක්ෂරය 'b'.
අකුරු පේළියක් දී ඇත:
let str = 'aba aca aea abba adca abea';
නිත්ය ප්රකාශනයක් ලියන්න, එය සොයා ගනු ඇත
අකුරු පේළි 'abba', 'adca', 'abea'
රටාවට අනුව: අක්ෂරය 'a', 2
ඕනෑම සංකේත, අක්ෂරය 'a'.
අකුරු පේළියක් දී ඇත:
let str = 'aba aca aea abba adca abea';
නිත්ය ප්රකාශනයක් ලියන්න, එය සොයා ගනු ඇත
අකුරු පේළි 'abba' සහ 'abea', අල්ලා නොගෙන
'adca'.
