மாறிகள் மற்றும் மாறுதல்

ரஸ்டில், மாறி மற்றும் நினைவக மேலாண்மை இரண்டு அடிப்படைக் கொள்கைகளால் வழிநடத்தப்படுகிறது: பாதுகாப்பு மற்றும் கட்டுப்பாடு. இந்த காரணத்திற்காக, பல நிரலாக்க மொழிகளைப் போலல்லாமல், ரஸ்டில் உள்ள மாறிகள் இயல்புநிலையாக ** மாறாமல் இருக்கும்.

இதன் பொருள் ஒரு மாறிக்கு ஒரு மதிப்பு ஒதுக்கப்பட்டவுடன், அதை மாற்ற முடியாது. நீங்கள் அதை மாற்ற முயற்சித்தால், கம்பைலர் பிழையை எழுப்பும்.

மாறாத மாறிகள் மற்றும் 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 12

mut போலன்றி, நிழல் உங்களை அனுமதிக்கிறது:

1. ஒரே பெயரை வைத்துக்கொண்டு ஒரு மாறியின் தரவு வகையை மாற்றவும்.
2. மாற்றங்களுக்குப் பிறகு மாறியின் மாறாத தன்மையைப் பராமரிக்கவும்.

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

இந்த பொறிமுறையானது மிகவும் பாதுகாப்பானது மற்றும் திறமையானது, ஏனெனில் இது முற்றிலும் தொகுக்கும் நேரத்தில் நிகழ்கிறது, எந்த இயக்க நேர செயல்திறன் மேல்நிலை இல்லாமல் வகை பாதுகாப்பை உறுதி செய்கிறது.

நீங்களே முயற்சி செய்து பாருங்கள்