TypeScript හි ජෙනරික් සීමාවන්
කලින් පාඩම් වලින් එකකදී, අපි සාමාන්ය ආකාරයේ (generic) වර්ගයේ ශ්රිතයක් නිර්මාණය කලෙමු. එයට ලබා දෙන පරාමිතියේ දිග මුද්රණය කිරීමට සැලැස්වීමට අපට අවශ්ය විය. කෙසේ වෙතත්, සම්පාදනය කිරීමේදී දෝෂයක් ලැබුණි, මන්ද සියලු වර්ග දිගක් තිබිය නොහැකිය:
function myFunc < T > (data: T): T {
console.log(data.length); // දෝෂය
return data;
}
එම අවස්ථාවේදී, අපි සාමාන්ය වර්ගය ජෙනරික් අරා (generic array)
වර්ගයකට වෙනස් කර අවස්ථාව නිවරදි කලෙමු.
නමුත් TypeScript හි ජෙනරික් සීමාවන් (constraints) නිර්මාණය
කිරීමේ හැකියාවක් පවතී. මෙය සිදු කිරීම සඳහා, කෝණීය වරහන්
තුළ, T විචල්යයට පසුව,
extends යන මූලික වචනය ලියන්න. ඊට පසුව
කර්ලීය වරහන් තුළ නව
විචල්යයක් str ලියන්න, එය සිදුරු වර්ගයේ (string type) වේ.
ශ්රිතයේ ඉතිරි කේතය වෙනස් නොකර තබන්න:
function myFunc <T extends {str: string}> (data: T): void {
console.log(data.str.length);
}
එබැවින්, ජෙනරික් වර්ගය කර්ලීය වරහන් තුළ දක්වා ඇති
str විචල්යයේ වර්ගය උරුම කර ගනී. දැන් අපි අපගේ
ශ්රිතයේ ක්රියාකාරිත්වය පරීක්ෂා කර බලමු සහ myStr
විචල්යයක් නිර්මාණය කරමු, එය str වර්ගයට යොමු වන අතර,
කර්ලීය වරහන් තුළ එයට අගයක් පවරමු:
let myStr: {str: string} = {str: 'abcde'};
අපි myFunc ශ්රිතය ලෙස හඳුන්වමු,
එහි වර්ගය නැවත දක්වන අතර myStr
විචල්යය පරාමිතියක් ලෙස යොමු කරමු:
myFunc <{str: string}> (myStr);
පාඩමේදී සලකා බැලූ උදාහරණය මත පදනම්ව, සංඛ්යාත්මක අරාවක දිග සොයා ගැනීම සඳහා ශ්රිතයක් ලියන්න.
