मुख्य सामग्री पर जाएं
मॉड्यूल 1 · पाठ 1 का 2पाठ्यक्रम में 1/14~10 min
मॉड्यूल पाठ (1/2)

चर और परिवर्तनशीलता

रस्ट में, चर और मेमोरी प्रबंधन दो मूलभूत सिद्धांतों द्वारा निर्देशित होता है: सुरक्षा और नियंत्रण। इस कारण से, कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, रस्ट में वेरिएबल डिफ़ॉल्ट रूप से अपरिवर्तनीय होते हैं।

इसका मतलब यह है कि एक बार किसी वेरिएबल को कोई मान निर्दिष्ट कर दिया जाए, तो उसे बदला नहीं जा सकता है। यदि आप इसे संशोधित करने का प्रयास करते हैं, तो कंपाइलर एक त्रुटि उत्पन्न करेगा।

अपरिवर्तनीय चर और mut कीवर्ड

एक वेरिएबल घोषित करने के लिए, हम let कीवर्ड का उपयोग करते हैं:

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

यदि आपको किसी वेरिएबल के मान को संशोधित करने की आवश्यकता है, तो आपको let के ठीक बाद mut कीवर्ड का उपयोग करके इसे स्पष्ट रूप से परिवर्तनीय बनाना होगा:

Rust
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 कीवर्ड का फिर से उपयोग करके उसी नाम के साथ एक वेरिएबल की पुनः घोषणा है। नया वेरिएबल पिछले वाले को "छाया" (या कवर) करता है:

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

mut के विपरीत, छायांकन आपको इसकी अनुमति देता है:

  1. एक ही नाम रखते हुए एक वेरिएबल का डेटा प्रकार बदलें।
  2. परिवर्तनों के बाद चर की अपरिवर्तनीयता बनाए रखें।
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

शैडोइंग और स्कोप्स की उपयोगिता

छायांकन एक ही ब्लॉक तक सीमित नहीं है; किसी मान को अस्थायी रूप से ओवरराइड करने के लिए इसका उपयोग नेस्टेड ब्लॉक ({}) के भीतर किया जा सकता है। जब आंतरिक ब्लॉक समाप्त हो जाता है, तो मूल चर फिर से दिखाई देने लगता है:

Rust
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

यह तंत्र बेहद सुरक्षित और कुशल है क्योंकि यह पूरी तरह से संकलन-समय पर होता है, बिना किसी रनटाइम प्रदर्शन ओवरहेड के प्रकार की सुरक्षा सुनिश्चित करता है।


खुद कोशिश करना

व्यायाम#rust.m1.l1.e1
प्रयास: 0लोड हो रहा है...

5 के प्रारंभिक मान के साथ x नाम का एक परिवर्तनशील चर घोषित करें। इसके बाद, x में 10 जोड़ें और println का उपयोग करके इसे स्क्रीन पर प्रिंट करें! मैक्रो.

संपादक लोड हो रहा है...
संकेत दिखाएँ

वेरिएबल को `let mut x = 5;` के साथ घोषित करें, फिर इसे `x += 10;` (या `x = x + 10;`) के साथ बढ़ाएं और अंत में इसे `println!('{}', x);` के साथ प्रिंट करें।

3 प्रयासों के बाद समाधान उपलब्ध है

व्यायाम#rust.m1.l1.e2
प्रयास: 0लोड हो रहा है...

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 प्रयासों के बाद समाधान उपलब्ध है

व्यायाम#rust.m1.l1.e3
प्रयास: 0लोड हो रहा है...

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 प्रयासों के बाद समाधान उपलब्ध है