தொகுதி பாடங்கள் (1/2)
வாழ்நாள் மற்றும் குறிப்புகள்
ரஸ்டில், ஒவ்வொரு குறிப்புக்கும் வாழ்நாள் உள்ளது, இது அந்த குறிப்பு செல்லுபடியாகும் நோக்கத்துடன் ஒத்துப்போகிறது. பெரும்பாலான நேரங்களில், ஆயுட்காலம் மறைமுகமாகவும், வாழ்நாள் நீக்குதல் விதிகளுக்கு நன்றி தொகுப்பாளரால் அனுமானிக்கப்படுகிறது. இருப்பினும், வெவ்வேறு குறிப்புகளின் ஆயுட்காலங்களுக்கிடையேயான தொடர்பு தெளிவற்றதாக இருக்கும்போது, அவற்றை நாம் வெளிப்படையாகக் குறிப்பிட வேண்டும்.
வாழ்நாளின் முக்கிய நோக்கம் ** தொங்கும் குறிப்புகளைத் தடுப்பதாகும்** (நினைவகத்திலிருந்து ஏற்கனவே ஒதுக்கப்பட்ட தரவுகளுக்கான குறிப்புகள்).
வாழ்நாள் சிறுகுறிப்பு தொடரியல்
வாழ்நாள் பெயர்கள் அபோஸ்ட்ரோபியுடன் தொடங்கும் (') மற்றும் பொதுவாக சிறிய சிறிய எழுத்துக்கள் ('a போன்றவை). வாழ்நாள் சிறுகுறிப்புகள் மாறிகளின் உண்மையான வாழ்நாளை மாற்றாது, ஆனால் அவை உள்ளீடுகள் மற்றும் வெளியீடுகளின் செல்லுபடியாகும் தன்மைக்கு இடையே உள்ள தொடர்பை கம்பைலருக்குக் குறிக்கின்றன.
எடுத்துக்காட்டாக, ஒரு செயல்பாடு இரண்டு சரம் குறிப்பு அளவுருக்களை எடுத்து ஒரு சரம் குறிப்பை வழங்கினால், இரண்டு உள்ளீட்டு அளவுருக்கள் செல்லுபடியாகும் வரை திரும்பிய குறிப்பு செல்லுபடியாகும் என நாங்கள் விரும்பினால், நாங்கள் பயன்படுத்துகிறோம்:
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}தரவு கட்டமைப்புகளில் வாழ்நாள்
ஒரு கட்டமைப்பில் குறிப்பான புலம் இருந்தால், அது குறிப்பிடும் தரவை விட struct இன்ஸ்டான்ஸ் வாழ முடியாது என்பதை உறுதிசெய்ய, அந்த குறிப்பில் வாழ்நாளை நாம் வெளிப்படையாக குறிப்பிட வேண்டும்:
struct ImportantExcerpt<'a> {
part: &'a str,
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().unwrap();
let i = ImportantExcerpt {
part: first_sentence,
};
}நிலையான வாழ்நாள்
'static வாழ்நாள் என்பது ஒரு சிறப்பு வாழ்நாள் ஆகும், இது திட்டத்தின் முழு காலத்திற்கு நீடிக்கும். அனைத்து ஸ்டிரிங் லிட்டரல்களும் (&str) மறைமுகமாக 'static ஆயுட்காலத்தைக் கொண்டிருக்கின்றன, ஏனெனில் அவை நேரடியாக பைனரி எக்ஸிகியூட்டபிள் உள்ளே சேமிக்கப்படுகின்றன.
let s: &'static str = "I have a static lifetime.";நீங்களே முயற்சி செய்து பாருங்கள்
பயிற்சி 1: மிக நீண்ட செயல்பாடு
x வகை &'a str மற்றும் y வகை &'a str ஆகிய இரண்டு அளவுருக்களை ஏற்று, &'a str வகையின் மதிப்பை வழங்கும் நீளமான<'a> என்ற செயல்பாட்டை எழுதவும். செயல்பாட்டின் உள்ளே, y ஐ விட நீளம் அதிகமாக இருந்தால் x ஐ வழங்க if/else பிளாக்கைப் பயன்படுத்தவும், இல்லையெனில் y ஐத் திருப்பி அனுப்பவும்.
குறிப்பைக் காட்டு
`fn நீளமான<'a>(x: &'a str, y: &'a str) -> &'a str`உடன் கையொப்பத்தை அறிவிக்கவும். பிறகு`if x.len() > y.len() { x } else { y }` ஐப் பயன்படுத்தவும்.
3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்
பயிற்சி 2: குறிப்புகள் கொண்ட கட்டமைப்புகள்
&'a str வகையின் ஒரு பகுதி என்ற ஒற்றை புலத்தைக் கொண்ட பகுதி<'a> என்ற கட்டமைப்பை வரையறுக்கவும். முக்கிய செயல்பாட்டில், உரை என பெயரிடப்பட்ட ஒரு சரம் மாறியை உருவாக்கவும் மற்றும் உரைக்கான குறிப்பைக் கடனாகப் பெறுவதன் மூலம் எக்செர்ப்ட் வகையின் மாறி பகுதியை உடனடியாக உருவாக்கவும். அச்சு பகுதி.பகுதி.
குறிப்பைக் காட்டு
`struct Excerpt<'a> { part: &'a str }`ஐப் பயன்படுத்தவும். முக்கியமாக அதை`பகுதி {பகுதி: &உரை }` உடன் உடனடியாகச் செய்யவும்.
3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்
பயிற்சி 3: நிலையான குறிப்புகள்
நிலையான வாழ்நாளில் (&'static str) வெளிப்படையான வகை சிறுகுறிப்புடன் ஒரு மாறி பெயரிடப்பட்ட செய்தியை அறிவிக்கவும், அதற்கு ஒரு சரத்தை வழங்கவும். செய்தியின் மதிப்பை அச்சிடவும்.
குறிப்பைக் காட்டு
நிலையான வாழ்நாளை வெளிப்படையாகக் குறிப்பிடுவதற்கு `let message: &'static str = 'Messaggio statico!';` தொடரியல் பயன்படுத்தவும்.
3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்