Rust භාෂාවට මාරු වීමේදී Python හෝ JavaScript වැනි උසස්-තල භාෂා වලින් පැමිණෙන වැඩිම ගැටලුවක් නම් string පද්ධතියයි. "String" සහ "&str" යන දෙකම වෙනම වර්ග දෙකක් බවත්, ඒවා මතකයේ කොහේද, කොහොමද ක්රියා කරන්නේ යන්න තේරුම් ගැනීමට කාලය ගත වෙයි.
මෙම ලිපියෙන් අපි literals, slices, සහ fat pointers යන තේමාවන් පිළිබඳව මූලික කරුණක් විග්රහ කරමු. Literal කියන්නේ ඔබේ .rs ගොනුවේ සෘජුවම ලියූ පෙළයි – උදා: "Hello, world!". මෙය &'static str වර්ගයක් වන අතර, ප්රධාන binary එකේ .rodata කොටසට ඇතුළත් වේ. Slice ( &str ) යනු මතකයේ ඇති UTF-8 බයිට් අනුක්රමයක් වෙත දර්ශනයක් පමණයි; එය දත්ත සොයා ගන්නේ නැත, නමුත් එහි ආරම්භය සහ දිග පමණක් දැනගෙන පවතී.
Rust හි &str යනු සාමාන්ය pointer එකක් නොව fat pointer එකක්. 64‑බිට් පද්ධතියක එය 16 බයිට් දෙකක් සමන්විත වේ: පළමුවෙන් පසුබැසීමේ මූලික ලිපිනය, දෙවැනි වරට අදාළ slice එකේ දිග. මෙය C භාෂාවේ null‑terminated string වලට වඩා වේගවත්, මතකය කාර්යක්ෂමව භාවිතා කරයි.
උදාහරණයක් ලෙස, පරිවර්තකයක් "Yummy!" යන literal එක ආපසු දෙන විට, එය මතකයේ .rodata හි අඩංගු වේ. ක්රමලේඛය එම ලිපිනය හා දිග (6) සමඟ fat pointer එකක් නිර්මාණය කර, ඒකම ආපසු දෙන අතර, කිසිදු byte copy කිරීමක් නොවේ. ඒ නිසා, function එකෙන් පසුද එම pointer එක ආරක්ෂිතයි.
ශ්රී ලංකාවට ඇති වැදගත්කම
- අධ්යයනයේ පහසුකම: Rust හි string මොඩලය පරිච්ඡේදනය කරගැනීම, ශ්රී ලංකාවේ විශ්වවිද්යාල සිසුන්ට memory safety සහ performance ගැන ගැඹුරු අවබෝධයක් ලබා දේ.
- විකසකයන්ට වාසිය: fat pointer නිසා slice එකක් pass කිරීමේදී copy‑ කිරීමේ වැය නැතිව, high‑performance backend සේවාවන් ඉක්මනින් ලියන්න පුළුවන්.
- ව්යාපාරික ආකාරය: ලොකු දත්ත සැකසීමේදී memory leaks අඩු කිරීම, server cost අඩු කරයි. එමඟින් ශ්රී ලංකාවේ IT සමාගම්ට තරඟකාරීත්වය වැඩි වේ.
අවසානයේ, Rust හි string පද්ධතියේ අභ්යන්තර ක්රියාකාරකම් තේරුම් ගැනීම, ඔබේ කේතය වේගවත්, ආරක්ෂිත, සහ පරිපාලන‑ආකාරයෙන් පිරිසිදු කරයි. මේ නිසා, නවතම තාක්ෂණික ව්යාපෘති වලට Rust යොදා ගැනීමට හොඳ අවස්ථාවක් වේ.
