जंग नियंत्रण संरचनाएं और उनका उपयोग कैसे करें

नियंत्रण संरचनाएं एक प्रोग्रामिंग निर्माण हैं जो आपको अपने कार्यक्रमों में निष्पादन के प्रवाह को नियंत्रित करने की अनुमति देती हैं। नियंत्रण संरचनाएं आपको कुछ शर्तों को पूरा करने पर ही चलाने के लिए निर्देश निर्दिष्ट करने देती हैं।

प्रोग्राम प्रवाह के प्रबंधन के लिए रस्ट की नियंत्रण संरचनाएं महत्वपूर्ण हैं, जटिल कार्यों को छोटे, पुन: प्रयोज्य घटकों में सरल करते हुए कुशल कोड निष्पादन को सक्षम करती हैं।

जंग सशर्त बयान

सशर्त बयान ऐसे निर्माण हैं जो आपको शर्तों के आधार पर कोड चलाने की अनुमति देते हैं। निर्णय लेने के लिए सशर्त बयान काम में आते हैं क्योंकि कार्यक्रम का निष्पादन इस बात पर निर्भर करता है कि क्या स्थिति का मूल्यांकन किया जाता है सत्य या असत्य. जंग प्रदान करता है अगर, अन्य, और मिलान निर्णय लेने के लिए बयान।

जंग कार्यक्रमों में, अगर कथन परीक्षण करता है कि क्या एक निश्चित स्थिति सत्य का मूल्यांकन करती है। यदि ऐसा होता है, तो प्रोग्राम कोड के संबद्ध ब्लॉक को चलाता है। यदि स्थिति गलत का मूल्यांकन करती है, तो प्रोग्राम कोड के उस ब्लॉक को छोड़ देता है और अगले स्टेटमेंट पर चला जाता है या रन करता है

अन्य स्टेटमेंट ब्लॉक अगर कोई है।

मिलान बयान एक शक्तिशाली नियंत्रण प्रवाह निर्माण है जो एक कार्यक्रम को पैटर्न की एक श्रृंखला के खिलाफ मूल्यों से मिलान करने और मिलान पैटर्न के आधार पर कोड निष्पादित करने की अनुमति देता है।

रस्ट के if स्टेटमेंट्स

आप घोषित करेंगे अगर आपके रस्ट प्रोग्राम में बयानों के साथ अगर एक शर्त के बाद कीवर्ड:

अगर स्थिति {
// स्थिति सही होने पर निष्पादित करने के लिए कोड
}

यहां एक उदाहरण दिया गया है कि आप अपने रस्ट प्रोग्राम में if स्टेटमेंट का उपयोग कैसे कर सकते हैं:

fnमुख्य() {
होने देना एक्स = 15;
अगर एक्स > 10 {
प्रिंटल!("एक्स 10 से अधिक है");
 }
}

एक्स वेरिएबल में 32-बिट पूर्णांक होता है, और if स्टेटमेंट यह जांचता है कि x का मान प्रिंट करने वाले कोड के ब्लॉक को चलाने से पहले दस से अधिक है या नहीं।

रस्ट के अन्य कथन

आप उपयोग करेंगे अन्य कीवर्ड कोड के एक ब्लॉक को निष्पादित करने के लिए जब आप अनुमान लगाते हैं कि a अगर कथन का मूल्यांकन असत्य के रूप में होगा।

अगर स्थिति {
// स्थिति सही होने पर निष्पादित करने के लिए कोड
} अन्य {
// कोड निष्पादित करने के लिए यदि स्थिति झूठी है
}

यहाँ एक उदाहरण है जहाँ एक्स 10 से अधिक नहीं है, अगर कथन मूल्यांकन करता है असत्य, और एक अन्य कथन चलता है।

fnमुख्य(){
होने देना एक्स = 5;
अगर एक्स > 10 {
प्रिंटल!("एक्स 10 से अधिक है");
 } अन्य {
प्रिंटल!("एक्स 10 से अधिक नहीं है");
 }
}

तब से एक्स 5 है और 5 10 से अधिक नहीं है, कार्यक्रम छोड़ देता है अगर ब्लॉक और निष्पादित करता है अन्य अवरोध पैदा करना।

रस्ट का मैच स्टेटमेंट

आप उपयोग करेंगे मिलान पैटर्न की एक श्रृंखला की जांच करने और पैटर्न मिलान के आधार पर कोड निष्पादित करने के लिए जटिल निर्णय लेने के लिए कीवर्ड। मैच स्टेटमेंट समान हैं सी # में स्विच स्टेटमेंट, जाओ, और सी ++।

यहाँ एक रस्ट मैच स्टेटमेंट की संरचना है:

मिलान कीमत {
 पैटर्न1 => {
// कोड निष्पादित करने के लिए यदि मान पैटर्न 1 से मेल खाता है
 },
 पैटर्न2 => {
// कोड निष्पादित करने के लिए यदि मान पैटर्न 2 से मेल खाता है
 },
// वगैरह।
}

यहां बताया गया है कि आप अपने प्रोग्राम में मैच स्टेटमेंट का उपयोग कैसे कर सकते हैं:

होने देना ग्रेड = 'बी';
मिलान श्रेणी {
'ए' => प्रिंटल!("उत्कृष्ट कार्य!"),
'बी' => प्रिंटल!("अच्छी नौकरी।"),
'सी' => प्रिंटल!("आप बेहतर कर सकते थे।"),
 _ => प्रिंटल!("यह एक वैध ग्रेड नहीं है।"),
}

श्रेणी चर एक वर्ण है, और मिलान => ऑपरेटर के बाद कोड निष्पादित करने से पहले स्टेटमेंट चेक करता है कि कौन से कैरेक्टर ग्रेड वेरिएबल के मान का मूल्यांकन करते हैं। आप उन मानों से मेल खाने के लिए अंडरस्कोर (_) पैटर्न का उपयोग कर सकते हैं जो अन्य पैटर्न (डिफ़ॉल्ट पैटर्न) से मेल नहीं खाते।

जंग में लूप्स

लूप एक मूलभूत निर्माण है जिसका उपयोग दोहराए जाने वाले कार्यों के लिए किया जाता है वेब स्क्रेपिंग और अन्य स्वचालित क्रियाएं। जंग विभिन्न प्रकार के लूप प्रदान करता है, जिनमें शामिल हैं जबकि लूप्स, के लिए लूप्स, और कुंडली कुंडली।

जंग के समय लूप्स

जबकि लूप्स कोड के एक ब्लॉक को तब तक दोहराते हैं जब तक कि एक निर्दिष्ट स्थिति सत्य का मूल्यांकन करती है। शर्त निर्दिष्ट करने से पहले, आप जंग में लूप के दौरान निर्दिष्ट करेंगे जबकि कीवर्ड।

जबकि स्थिति {
// कोड निष्पादित करने के लिए
}

स्थिति एक बूलियन अभिव्यक्ति होनी चाहिए जो लूप की निरंतरता को निर्धारित करती है। जब स्थिति का मूल्यांकन गलत होता है, तो लूप बाहर निकल जाता है।

यहां रस्ट जबकि लूप का एक उदाहरण दिया गया है जो एक से पांच तक की संख्या को प्रिंट करता है।

fnमुख्य() {
होने देनामुठ मैं = 1;
जबकि मैं <= 5 {
प्रिंटल!("{}", मैं);
 मैं + = 1;
 }
}

जबकि लूप में मुख्य फ़ंक्शन वृद्धि करते समय संख्या एक से पांच तक जाता है मैं एक के बाद एक परिवर्तनशील मैं चर पाँच से अधिक है, जहाँ लूप समाप्त होता है।

लूप लूप

कुंडली कीवर्ड एक अनंत लूप बनाता है जब तक कि आप इसके साथ बाहर नहीं निकलते तोड़ना कीवर्ड।

कुंडली {
// कोड निष्पादित करने के लिए
अगर स्थिति {
तोड़ना;
 }
}

कोड में कुंडली ब्लॉक तब तक क्रियान्वित होता रहेगा जब तक कि लूप का सामना नहीं हो जाता तोड़ना कीवर्ड।

यहाँ उपयोग करने का एक उदाहरण है कुंडली निर्दिष्ट करने से पहले संख्याओं को एक से पांच तक प्रिंट करने के लिए लूप तोड़ना बाहर निकलने के लिए कीवर्ड।

fnमुख्य() {
होने देनामुठ मैं = 1;
कुंडली {
प्रिंटल!("{}", मैं);
 मैं + = 1;
अगर मैं > 5 {
तोड़ना;
 }
 }
}

मुख्य फ़ंक्शन लूप को निष्पादित करता है, और अगर कथन में वृद्धि करता है मैं चर। अगर कथन लूप समाप्ति को निर्दिष्ट करता है जब मैं चर पाँच से अधिक है।

लूप्स के लिए जंग

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

के लिए चर में श्रेणी {
// कोड निष्पादित करने के लिए
}

श्रेणी एक अभिव्यक्ति है जो मूल्यों के अनुक्रम का मूल्यांकन करती है, और चर एक चर है जो अनुक्रम में प्रत्येक मान को बदले में लेता है। अनुक्रम में प्रत्येक मान के लिए कोड ब्लॉक एक बार निष्पादित होगा।

यहां for लूप का एक उदाहरण दिया गया है जो एक से लेकर दस तक के मानों को प्रिंट करता है।

fnमुख्य() {
के लिए मैं में1..=10 {
प्रिंटल!("{}", मैं);
 }
}

लूप 1 से 10 के मानों के माध्यम से पुनरावृति करता है। प्रत्येक पुनरावृत्ति पर, चर (i) अगला मान रखता है, कि प्रिंटल! मैक्रो तब प्रिंट आउट करता है।

आप उपयोग कर सकते हैं जारी रखना for-loops में मानों को छोड़ने के लिए कीवर्ड। यहां बताया गया है कि किसी श्रेणी पर काम करते समय आप सम संख्याओं को कैसे छोड़ सकते हैं:

fnमुख्य() {
के लिए अंक में1..=10 {
अगर अंक % 2 == 0 {
जारी रखना; // सम संख्याओं को छोड़ें
 }
प्रिंटल!("{}", संख्या); // विषम संख्या प्रिंट करें
 }
}

अगर कथन का उपयोग करता है जारी रखना कीवर्ड यह निर्दिष्ट करने के लिए कि लूप को दो से विभाज्य संख्याओं को छोड़ देना चाहिए।

इसके अतिरिक्त, आप के साथ फॉर-लूप से बाहर निकल सकते हैं तोड़ना कीवर्ड। मिलने पर लूप समाप्त हो जाता है तोड़ना कीवर्ड।

fnमुख्य() {
के लिए अंक में1..=10 {
अगर संख्या == 5 {
तोड़ना; // लूप से बाहर निकलें जब संख्या 5 के बराबर हो
 }
प्रिंटल!("{}", संख्या); // प्रिंट संख्या 1 से 4
 }
}

अगर कथन निर्दिष्ट करता है कि लूप को तब समाप्त होना चाहिए जब मैं चर पाँच के बराबर है।

भाषा में महारत हासिल करने के लिए डेटा प्रकारों के साथ रस्ट की नियंत्रण संरचनाओं का उपयोग करें

जंग इन लचीली नियंत्रण संरचनाओं को अंतर्निहित और कस्टम डेटा प्रकारों पर संचालन के लिए प्रदान करता है। आप इन नियंत्रण संरचनाओं का उपयोग सरणियों, वैक्टर, संरचना और एनम जैसे यौगिक और समग्र डेटा संरचनाओं पर काम करने के लिए कर सकते हैं।

जंग भी संरचना प्रदान करता है। स्ट्रक्चर डेटा स्ट्रक्चर हैं जो संबंधित मानों को एक ऑब्जेक्ट में समूहित करते हैं। वे वस्तु-उन्मुख भाषाओं में कक्षाओं के समान हैं, और आप उन पर विधियों को परिभाषित भी कर सकते हैं।