मॉड्यूल पाठ (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 नाम का एक परिवर्तनशील चर घोषित करें। इसके बाद, x में 10 जोड़ें और println का उपयोग करके इसे स्क्रीन पर प्रिंट करें! मैक्रो.
संकेत दिखाएँ
वेरिएबल को `let mut x = 5;` के साथ घोषित करें, फिर इसे `x += 10;` (या `x = x + 10;`) के साथ बढ़ाएं और अंत में इसे `println!('{}', x);` के साथ प्रिंट करें।
3 प्रयासों के बाद समाधान उपलब्ध है
10 के मान के साथ एक अपरिवर्तनीय चर y घोषित करें। इसके पिछले मान को 2 से गुणा करने के साथ इसे फिर से घोषित करके y को छाया दें, और अंत में 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 प्रयासों के बाद समाधान उपलब्ध है