Rust භාෂාවේ වැඩ කරන ඔබට "lifetime" කියන පදය අහන්න ඇති. එය සරලව කියනවා නම්, රෙෆරන්ස් එකක් කවදාවත් වලංගු වෙලා ඉන්න කාලයයි. මේ ලිපියෙන් අපි අලුත්ම Rust 1.11.1 ආදර්ශන, Borrow Checker ක්රියාකාරීත්වය, සහ Generic Lifetimes ගැන පළමු කොටසක් විස්තර කරමු.
මුලින්ම, රෙෆරන්ස් එකක් ගන්නා විට එහි lifetime එක ආරම්භ වේ. ඒ රෙෆරන්ස් භාවිතා කරමින් සිටින අතරතුර, ඒ රෙෆරන්ස් සම්බන්ධිත වාරිකය (variable) වෙනස් වුවහෝ අවසන් වුවහෝ, එහි lifetime එක අවසන් වේ. වැඩිම පරිමාණයෙන්, compiler එක මේක සියල්ල අඳුනා ගනී.
Borrow Checker එකේ කාර්යය නම්, රෙෆරන්ස් එකේ lifetime එක තවමත් සක්රියදැයි පරීක්ෂා කිරීමයි. එය රෙෆරන්ස් එක ලැබූ ස්ථානයට ආපසු යාමෙන්, මාර්ගය පුරා ඕනෑම ගැටළුවක් නොමැතිද කියා තහවුරු කරයි. උදාහරණයක් ලෙස, rand crate එකේ random function එක භාවිතා කරමින්, mutable සහ immutable රෙෆරන්ස් එකම කාලය තුළ භාවිතා නොකළ හැකි බව පෙන්වා දී ඇත. ඒත්, if-else ශරීරය තුළ එකම රෙෆරන්ස් එක වෙනත් ශරීරයකට ගොස් නොමැති නිසා, Borrow Checker එක එය ආරක්ෂිතයි කියා පිළිගනී.
තවත් උදාහරණයක් ලෙස, ලූප් එකක් තුළ රෙෆරන්ස් එක නැවත ලබා දීමේදී, Rust නව රෙෆරන්ස් එකක් ලෙස සලකා, පරණ lifetime එක අවසන් කරයි. එම නිසා, එකම රෙෆරන්ස් එක දිගටම භාවිතා නොකළත්, Borrow Checker එකේ දෝෂයක් නොමැත.
ශ්රී ලංකාවට ඇති වැදගත්කම
ශ්රී ලංකාවේ තරුණ සංවර්ධකයින්, විශ්ව විද්යාල සිසුන්, සහ තාක්ෂණික ව්යාපාර සඳහා මේ දැනුම ඉතා ප්රයෝජනවත්.
- සිසුන් – Rust පාඨමාලා හෝ ව්යාපෘති වලදී lifetimes සහ borrow checker පිළිබඳ නවතම තොරතුරු අත්කරගැනීමෙන්, කේතයේ ආරක්ෂාව වැඩි කර ගත හැක.
- සංවර්ධකයින් – පරිශීලක අතුරුදන්වීම (memory safety) අවශ්ය වූ high‑performance යෙදුම් නිර්මාණය කිරීමේදී, lifetimes නිවැරදිව භාවිතා කිරීමෙන් බග් අවම කරගත හැක.
- ව්යාපාර – Rust භාවිතා කරන ආයතන සඳහා, code audit කාර්ය සාධනය ඉක්මනින් කරගත හැකි බැවින්, development cycle කාලය හා පිරිවැය අඩු කරයි.
ඉදිරි කාලයේ Rust භාෂාව තවත් ප්රචලිත වෙමින් පවතී. Lifetimes සහ Borrow Checker වැනි මූලික කරුණු තේරුම් ගැනීම, ශ්රී ලංකාවේ තාක්ෂණික පරිසරය තවත් ශක්තිමත් කරනු ඇත.
අවසන් වශයෙන්, Rust හි lifetimes, borrow checking, සහ generic lifetimes යන අදහස් පරිපූර්ණව අධ්යයනය කරගෙන, ඔබේ කේතය තවත් ආරක්ෂිත, කාර්යක්ෂම, සහ නවීන තාක්ෂණික අවශ්යතා සමඟ සකස් කර ගන්න.
