మాడ్యూల్ పాఠాలు (1/2)
వేరియబుల్స్ మరియు మ్యుటబిలిటీ
రస్ట్‌లో, వేరియబుల్ మరియు మెమరీ నిర్వహణ రెండు ప్రాథమిక సూత్రాల ద్వారా మార్గనిర్దేశం చేయబడుతుంది: భద్రత మరియు నియంత్రణ. ఈ కారణంగా, అనేక ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల మాదిరిగా కాకుండా, రస్ట్‌లోని వేరియబుల్స్ డిఫాల్ట్‌గా ** మారకుండా ఉంటాయి.
దీని అర్థం వేరియబుల్‌కు విలువను కేటాయించిన తర్వాత, దానిని మార్చలేము. మీరు దానిని సవరించడానికి ప్రయత్నిస్తే, కంపైలర్ లోపాన్ని లేవనెత్తుతుంది.
మార్పులేని వేరియబుల్స్ మరియు mut కీవర్డ్
వేరియబుల్‌ని ప్రకటించడానికి, మేము let కీవర్డ్‌ని ఉపయోగిస్తాము:
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.మీరు వేరియబుల్ విలువను సవరించాల్సిన అవసరం ఉన్నట్లయితే, మీరు let తర్వాత mut కీవర్డ్‌ని ఉపయోగించడం ద్వారా స్పష్టంగా మార్చగలిగేలా చేయాలి:
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);mut ఉపసర్గను ఉపయోగించడం ద్వారా కంపైలర్‌కి మరియు కోడ్‌ని చదివే ఎవరికైనా అమలు సమయంలో విలువ మారుతుందని స్పష్టంగా తెలియజేస్తుంది.
షాడోయింగ్
రస్ట్ let కీవర్డ్‌ని మళ్లీ ఉపయోగించి అదే పేరుతో ఉన్న వేరియబుల్ యొక్క రీ-డిక్లరేషన్ అయిన షేడోయింగ్ భావనను కూడా అనుమతిస్తుంది. కొత్త వేరియబుల్ "షాడోస్" (లేదా కవర్లు) మునుపటిది:
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12mut వలె కాకుండా, నీడ మిమ్మల్ని వీటిని అనుమతిస్తుంది:
- అదే పేరును ఉంచుతూ వేరియబుల్ యొక్క డేటా రకాన్ని మార్చండి.
- రూపాంతరాల తర్వాత వేరియబుల్ యొక్క మార్పులేని స్థితిని నిర్వహించండి.
let spaces = " "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)షాడోయింగ్ మరియు స్కోప్‌ల ఉపయోగం
నీడ అనేది ఒకే బ్లాక్‌కు పరిమితం కాదు; విలువను తాత్కాలికంగా భర్తీ చేయడానికి ఇది సమూహ బ్లాక్‌లలో ({}) ఉపయోగించబడుతుంది. లోపలి బ్లాక్ ముగిసినప్పుడు, అసలు వేరియబుల్ మళ్లీ కనిపిస్తుంది:
let x = 5;
{
let x = x * 2; // Shadowing valid only inside the block
println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5ఈ మెకానిజం చాలా సురక్షితమైనది మరియు సమర్థవంతమైనది ఎందుకంటే ఇది పూర్తిగా కంపైల్-టైమ్‌లో జరుగుతుంది, ఎటువంటి రన్‌టైమ్ పనితీరు ఓవర్‌హెడ్ లేకుండా టైప్ భద్రతను నిర్ధారిస్తుంది.
మీరే ప్రయత్నించండి
ప్రారంభ విలువ 5తో x అనే మ్యూటబుల్ వేరియబుల్‌ని డిక్లేర్ చేయండి. తర్వాత, 10కి xని జోడించి, printlnని ఉపయోగించి స్క్రీన్‌పై ప్రింట్ చేయండి! స్థూల.
సూచనను చూపించు
వేరియబుల్‌ను `లెట్ మ్యూట్ x = 5;`తో డిక్లేర్ చేసి, ఆపై దాన్ని `x += 10;` (లేదా `x = x + 10;`)తో పెంచి, చివరకు `println!('{}', x);`తో ప్రింట్ చేయండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
10 విలువ కలిగిన మార్పులేని చరరాశి yని ప్రకటించండి. షాడో yని దాని మునుపటి విలువను 2తో గుణించేలా మళ్లీ ప్రకటించి, చివరకు printlnని ఉపయోగించి ప్రింట్ చేయండి!.
సూచనను చూపించు
Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.
సూచనను చూపించు
Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది