Rust में ऑपरेटर्स और कंट्रोल फ्लो – Operators and Control Flow in Rust

इस अध्याय में हम Rust प्रोग्रामिंग भाषा में ऑपरेटर्स और कंट्रोल फ्लो की मूलभूत अवधारणाओं पर ध्यान देंगे। Rust में कई प्रकार के ऑपरेटर्स होते हैं जैसे arithmetic, comparison, logical आदि, जिनका उपयोग वैल्यूज के बीच गणना करने के लिए होता है। इसके साथ ही, प्रोग्राम के प्रवाह को नियंत्रित करने के लिए कंट्रोल फ्लो statements का उपयोग किया जाता है, जैसे कि if-else, match, और loops।

इस अध्याय के अंत तक, आप Rust में विभिन्न ऑपरेटर्स का उपयोग और प्रोग्राम की लॉजिक को कंट्रोल फ्लो structures के माध्यम से प्रबंधित करना सीखेंगे।

Arithmetic और Comparison ऑपरेटर्स (Arithmetic and Comparison Operators)

Rust प्रोग्रामिंग भाषा में Arithmetic और Comparison ऑपरेटर्स का उपयोग वैल्यूज के बीच गणनाएँ करने और उनकी तुलना करने के लिए किया जाता है। ये ऑपरेटर्स किसी भी प्रोग्रामिंग भाषा के बुनियादी हिस्से होते हैं और विभिन्न प्रकार की गणनाओं व लॉजिक का निर्माण करने में मदद करते हैं। आइए, Rust में इन ऑपरेटर्स के बारे में विस्तार से जानें।

Arithmetic ऑपरेटर्स (Arithmetic Operators)

Arithmetic ऑपरेटर्स का उपयोग मूल गणितीय ऑपरेशंस को अंजाम देने के लिए किया जाता है, जैसे जोड़ना, घटाना, गुणा करना, और भाग देना। Rust में निम्नलिखित Arithmetic ऑपरेटर्स होते हैं:

उदाहरण:

fn main() {
    let sum = 5 + 3;     // जोड़
    let difference = 10 - 4;  // घटाव
    let product = 4 * 2;  // गुणा
    let quotient = 10 / 3;  // भाग
    let remainder = 10 % 3;  // शेषफल

    println!("जोड़: {}", sum);
    println!("घटाव: {}", difference);
    println!("गुणा: {}", product);
    println!("भागफल: {}", quotient);
    println!("शेषफल: {}", remainder);
}

ध्यान दें: जब आप दो integers का division करते हैं, तो परिणाम भी integer ही होगा। यदि आप floating-point division चाहते हैं, तो आपको float प्रकार के वैरिएबल्स का उपयोग करना होगा।

Comparison ऑपरेटर्स (Comparison Operators)

Comparison ऑपरेटर्स का उपयोग दो वैल्यूज के बीच तुलना करने के लिए किया जाता है। ये ऑपरेटर्स boolean (true या false) वैल्यू वापस करते हैं, जो कंट्रोल फ्लो statements में निर्णय लेने के लिए उपयोग किए जा सकते हैं।

उदाहरण:

fn main() {
    let a = 5;
    let b = 3;

    println!("a == b: {}", a == b);  // बराबर
    println!("a != b: {}", a != b);  // बराबर नहीं
    println!("a > b: {}", a > b);    // बड़ा
    println!("a < b: {}", a < b);    // छोटा
    println!("a >= b: {}", a >= b);  // बड़ा या बराबर
    println!("a <= b: {}", a <= b);  // छोटा या बराबर
}

If-Else और Match (Conditional Statements – If-Else, Match)

किसी भी प्रोग्राम में निर्णय लेने की क्षमता महत्वपूर्ण होती है। Rust में निर्णय लेने के लिए if-else और match स्टेटमेंट्स का उपयोग किया जाता है। ये conditional statements प्रोग्राम को विभिन्न स्थितियों के आधार पर विभिन्न कार्य करने की अनुमति देते हैं। आइए, इन दोनों स्टेटमेंट्स के बारे में विस्तार से जानें।

If-Else स्टेटमेंट (If-Else Statement)

Rust में if स्टेटमेंट का उपयोग तब किया जाता है जब हमें किसी शर्त (condition) के आधार पर निर्णय लेना हो। अगर शर्त सही होती है (i.e., true), तो संबंधित कोड ब्लॉक चलता है। यदि शर्त गलत होती है (i.e., false), तो else ब्लॉक (यदि हो) चलता है।

सिंटैक्स (Syntax):

if शर्त {
    // यदि शर्त सही है, तो यह कोड चलेगा
} else {
    // यदि शर्त गलत है, तो यह कोड चलेगा
}

उदाहरण:

fn main() {
    let number = 7;

    if number < 5 {
        println!("संख्या 5 से छोटी है");
    } else {
        println!("संख्या 5 से बड़ी या बराबर है");
    }
}

इस उदाहरण में, Rust सबसे पहले यह जाँचता है कि क्या number 5 से छोटा है। अगर शर्त सही होती, तो पहला कोड ब्लॉक चलता, लेकिन क्योंकि number 7 है, else ब्लॉक का कोड चलेगा और आउटपुट होगा: “संख्या 5 से बड़ी या बराबर है।”

If-Else if-Else चेन (If-Else if-Else Chain):

आप एक से अधिक शर्तों की जाँच करने के लिए else if का भी उपयोग कर सकते हैं। जब तक एक शर्त सही न हो, तब तक Rust सभी शर्तों की जाँच करता है।

fn main() {
    let number = 7;

    if number < 5 {
        println!("संख्या 5 से छोटी है");
    } else if number == 7 {
        println!("संख्या 7 है");
    } else {
        println!("संख्या 5 से बड़ी है लेकिन 7 नहीं है");
    }
}

इस उदाहरण में, Rust सबसे पहले यह जाँचता है कि क्या number 5 से छोटा है, फिर वह जाँचता है कि क्या number 7 के बराबर है। चूंकि यह शर्त सही है, दूसरा कोड ब्लॉक चलेगा और आउटपुट होगा: “संख्या 7 है।”

Match स्टेटमेंट (Match Statement)

Rust का match स्टेटमेंट एक शक्तिशाली और अधिक लचीला विकल्प है, जो कई स्थितियों की जाँच करने के लिए उपयोग किया जाता है। यह स्विच-किसी भी वैल्यू के आधार पर सही स्थिति का मिलान करता है और उससे जुड़े कोड ब्लॉक को चलाता है।

सिंटैक्स (Syntax):

match वैरिएबल {
    मान1 => {
        // जब वैरिएबल का मान 'मान1' के बराबर हो
    },
    मान2 => {
        // जब वैरिएबल का मान 'मान2' के बराबर हो
    },
    _ => {
        // 'default' केस, जब कोई अन्य मान न मिले
    },
}

उदाहरण:

fn main() {
    let number = 3;

    match number {
        1 => println!("संख्या 1 है"),
        2 => println!("संख्या 2 है"),
        3 => println!("संख्या 3 है"),
        _ => println!("यह संख्या 1, 2 या 3 नहीं है"),
    }
}

इस उदाहरण में, Rust number का मान 3 के साथ मिलान करता है, इसलिए वह तीसरा केस चलाता है और आउटपुट होगा: “संख्या 3 है”। अगर कोई मान match नहीं करता, तो _ केस चलेगा, जो default केस के रूप में काम करता है।

Pattern Matching के साथ Match:

Match स्टेटमेंट का सबसे बड़ा फायदा यह है कि आप पैटर्न मैचिंग कर सकते हैं। यह बहुत शक्तिशाली होता है और इसे आप enums, tuples और अन्य जटिल डेटा संरचनाओं के साथ भी उपयोग कर सकते हैं।

उदाहरण (Tuple Match):

fn main() {
    let point = (0, 1);

    match point {
        (0, 0) => println!("बिंदु उत्पत्ति पर है"),
        (0, _) => println!("बिंदु y-अक्ष पर है"),
        (_, 0) => println!("बिंदु x-अक्ष पर है"),
        _ => println!("बिंदु किसी अन्य स्थान पर है"),
    }
}

यहाँ, हम एक tuple के साथ काम कर रहे हैं और पैटर्न के आधार पर विभिन्न स्थितियों को संभाल रहे हैं।

If-Else बनाम Match:

1. If-Else का उपयोग तब करें जब:
   • आपको केवल boolean शर्तों की आवश्यकता हो।
   • लॉजिक सीधा हो और कई जाँच की आवश्यकता न हो।
2. Match का उपयोग तब करें जब:
   • आपको एक वैल्यू को कई पैटर्न के साथ मिलाना हो।
   • आप enums, tuples, या अन्य जटिल डेटा प्रकारों के साथ काम कर रहे हों।

Loops: For, While और Loop (Looping Constructs in Rust)

किसी भी प्रोग्रामिंग भाषा में लूप्स (loops) का उपयोग कोड को बार-बार चलाने के लिए किया जाता है। Rust में तीन मुख्य प्रकार के लूप्स होते हैं: for लूप, while लूप, और loop। इन सभी का उपयोग विभिन्न परिस्थितियों में किया जाता है, और प्रत्येक लूप के अपने फायदे हैं। आइए, Rust में इन लूप्स के बारे में विस्तार से जानें।

1. For लूप (For Loop)

For लूप का उपयोग तब किया जाता है जब हमें किसी कलेक्शन, रेंज, या इटरेटर पर क्रमिक रूप से लूप चलाना हो। Rust में for लूप बेहद शक्तिशाली और सुरक्षित होते हैं, क्योंकि यह स्वचालित रूप से इटरेटर के प्रत्येक आइटम को संभालता है और इटरेटर को ओवरफ्लो नहीं होने देता।

सिंटैक्स (Syntax):

for वैल्यू in कलेक्शन {
    // कोड जो हर वैल्यू पर चलेगा
}

उदाहरण:

fn main() {
    let numbers = [1, 2, 3, 4, 5];

    for number in numbers.iter() {
        println!("संख्या: {}", number);
    }
}

इस उदाहरण में, for लूप numbers array के प्रत्येक आइटम पर चलता है और हर संख्या को प्रिंट करता है।

रेंज के साथ For लूप (For Loop with Range):

आप किसी निश्चित रेंज पर भी for लूप चला सकते हैं। Rust में रेंज का उपयोग start..end के रूप में किया जाता है।

fn main() {
    for number in 1..5 {
        println!("रेंज में संख्या: {}", number);
    }
}

इस उदाहरण में, 1..5 रेंज 1 से शुरू होकर 4 तक चलेगी। यह 5 को शामिल नहीं करेगी।

2. While लूप (While Loop)

While लूप का उपयोग तब किया जाता है जब आपको किसी शर्त (condition) के सही होने तक लूप चलाना हो। जब तक शर्त true रहती है, लूप चलता रहता है। जैसे ही शर्त false हो जाती है, लूप समाप्त हो जाता है।

सिंटैक्स (Syntax):

while शर्त {
    // कोड जो तब तक चलेगा जब तक शर्त true है
}

उदाहरण:

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{} पर लूप चल रहा है", number);
        number -= 1;
    }

    println!("लूप समाप्त");
}

इस उदाहरण में, लूप तब तक चलता है जब तक number 0 नहीं हो जाता। हर बार number को 1 घटाया जाता है और लूप समाप्त होता है जब शर्त गलत हो जाती है (number == 0)।

3. Loop (Infinite Loop)

Loop लूप Rust में एक अनंत (infinite) लूप बनाने का सबसे सीधा तरीका है। यह तब तक चलता रहेगा जब तक आप उसे मैन्युअली रोकते नहीं। इसे रोकने के लिए आप break स्टेटमेंट का उपयोग कर सकते हैं। अनंत लूप का उपयोग अक्सर तब किया जाता है जब आपको एक लूप को किसी शर्त या विशेष स्थिति में रोकना हो।

सिंटैक्स (Syntax):

loop {
    // कोड जो तब तक चलेगा जब तक break नहीं किया जाता
}

उदाहरण:

fn main() {
    let mut count = 0;

    loop {
        count += 1;
        println!("गिनती: {}", count);

        if count == 5 {
            break; // लूप को 5 पर रोकना
        }
    }

    println!("लूप समाप्त");
}

इस उदाहरण में, लूप तब तक चलता है जब तक count की वैल्यू 5 नहीं हो जाती। जब यह 5 हो जाती है, तब लूप से break स्टेटमेंट के माध्यम से बाहर आ जाते हैं।

Break और Continue स्टेटमेंट्स (Break and Continue Statements)

1. Break: लूप को बीच में ही समाप्त करने के लिए उपयोग किया जाता है।

   fn main() {
       let mut i = 0;
   
       loop {
           i += 1;
   
           if i == 3 {
               break;  // लूप 3 पर समाप्त होगा
           }
   
           println!("i: {}", i);
       }
   }
   

    

2. Continue: वर्तमान लूप iteration को छोड़कर अगले iteration पर जाने के लिए उपयोग किया जाता है।

   fn main() {
       for i in 1..6 {
           if i == 3 {
               continue;  // 3 को छोड़कर लूप अगली iteration पर जाएगा
           }
   
           println!("i: {}", i);
       }
   }
   

    

कब कौन सा लूप चुनें? (When to Use Which Loop)

• For लूप: जब आपको किसी कलेक्शन, इटरेटर, या रेंज पर लूप चलाना हो। यह सबसे सुरक्षित और स्पष्ट लूप है।
• While लूप: जब आपको किसी शर्त के सही होने तक लूप चलाना हो। यह तब उपयोगी होता है जब शर्त लूप के अंदर ही बदलती है।
• Loop (अनंत लूप): जब आपको अनंत लूप की आवश्यकता हो, खासकर तब जब लूप को किसी खास स्थिति में रोकना हो। इस लूप का उपयोग सावधानी से करें।