JavaScript හි නිත්ය ප්රකාශන වල ලොභය සීමා කිරීම
නිත්ය ප්රකාශන පෙරනිමියෙන් ලොභි වේ. මෙයින් අදහස් වන්නේ ඒවා උපරිම වශයෙන් හැකි අක්ෂර සංඛ්යාවක් අල්ලා ගන්නා බවයි. අපි උදාහරණයක් මගින් බලමු. අපට මේ වගේ අකුරු පේළියක් ඇතැයි සිතමු:
let str = 'aeeex zzz x kkk';
මෙම අකුරු පේළිය තුළ අපට උප අකුරු පේළිය
'aeeex' සොයා ගැනීමට අවශ්ය යැයි සිතමු: අකුර
'a', ඉන් පසු ඕනෑම අක්ෂරයක් එක් හෝ ඊට වැඩි වාර ගණනක්,
ඉන් පසු අකුර 'x'.
let res = str.replace(/a.+x/g, '!');
ප්රතිඵලයක් ලෙස විචල්යයට අකුරු පේළිය
'! zzz x kkk' ලියා ඇති බව අපි අපේක්ෂා කරමු. කෙසේ වෙතත්,
එය එසේ නොවේ - විචල්යයට ලැබෙන්නේ අකුරු පේළිය
'! kkk' ය.
ගැටලුව වන්නේ අපගේ නිත්ය ප්රකාශනය
අකුර 'a' සිට අකුර 'x' දක්වා සියලුම
අක්ෂර සොයන බවයි.
නමුත් අපගේ අකුරු පේළියේ අකුර 'x' දෙකක් තිබේ! ලොභය
හේතුවෙන් නිත්ය ප්රකාශනය අවසාන
'x' අකුර දක්වා සොයා ගැනීමට හේතු වන අතර, එමඟින් අප
අපේක්ෂා කළ දේ නොව අල්ලා ගනී.
ඇත්ත වශයෙන්ම, බොහෝ විට මෙවැනි හැසිරීමක් අපට අවශ්ය වේ. නමුත් මෙම නිශ්චිත අවස්ථාවේ දී අපට ලොභය අවලංගු කිරීමට හා නිත්ය ප්රකාශනයට පළමු 'x' අකුර දක්වා සොයන ලෙස කියන්නට අවශ්ය විය හැක.
ලොභය සීමා කිරීම සඳහා, පුනරාවර්තන ක්රියාකරු පසුව ප්රශ්නාර්ථ ලකුණ තැබිය යුතුය:
let res = str.replace(/a.+?x/g, '!');
ලොභය සියලු පුනරාවර්තන ක්රියාකරුවන්ට
සීමා කළ හැක: *, ?, සහ {}
- මේ ආකාරයට: *?, ?? සහ {}?.
අකුරු පේළියක් ලබා දී ඇත:
let str = 'aba accca azzza wwwwa';
නිත්ය ප්රකාශනයක් ලියන්න, එය සොයා ගනු ලබන සියලුම අකුරු පේළි
යාබදව අකුර 'a' ඇති,
සහ ඒ සෑම එකක්ම '!' සමඟ ප්රතිස්ථාපනය කරයි.
අකුරු 'a' අතර ඕනෑම අක්ෂරයක් තිබිය හැක (අකුර
'a' හැර).
