Go. में लूप्स के लिए समझ

लूप के लिए एक नियंत्रण प्रवाह विवरण है जिसका उपयोग कोड के एक ब्लॉक को बार-बार निष्पादित करने के लिए किया जाता है। गो में, लूप के लिए एकमात्र लूपिंग निर्माण है।

आप कोड के ब्लॉक को दोहराने के लिए लूप के लिए उपयोग कर सकते हैं और अन्य भाषाओं से लूप की पूरी श्रृंखला का अनुकरण कर सकते हैं, जिसमें for...each, जबकि लूप, और do...जबकि लूप शामिल हैं।

आरंभ करने के लिए स्थापित करें

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

पैकेट मुख्य
आयात "एफएमटी"
समारोहमुख्य() {
// कोड यहाँ जाता है
}

Go. में लूप के लिए एक तीन-घटक

यह शायद लूप के लिए सबसे आम है। जैसा कि नाम से पता चलता है, इसमें तीन घटक होते हैं: प्रारंभिक मान, एक शर्त और एक पोस्ट स्टेटमेंट। यहाँ वाक्य रचना है:

आरंभीकरण के लिए; स्थि‍ति; पद {
 बयान
}

इस लूप में, आरंभीकरण के बाद, स्थिति का मूल्यांकन किया जाता है। यदि सही है, तो लूप ब्लॉक में स्टेटमेंट निष्पादित होते हैं, उसके बाद पोस्ट स्टेटमेंट। कार्यक्रम इस प्रक्रिया को तब तक दोहराता है जब तक कि स्थिति का मूल्यांकन सत्य नहीं हो जाता। नीचे एक उदाहरण है।

मैं के लिए: = 1; मैं <= 5; मैं++ {
एफएमटी.प्रिंट्लन(मैं)
}

यहां:

• आरंभीकरण सेट मैं प्रति 1
• शर्त है मैं <= 5
• पोस्ट स्टेटमेंट है मैं++

यह लूप के लिए वर्तमान मान को प्रिंट करता है मैं यदि यह 5 से कम या उसके बराबर है। 'पोस्ट स्टेटमेंट' में 1 जोड़ा जाता है मैं प्रत्येक लूप के बाद और एक बार मैं 5 हो जाता है, लूप समाप्त हो जाता है। 'पोस्ट स्टेटमेंट' के बिना, लूप अनंत बार निष्पादित होगा और संभावित रूप से प्रोग्राम के क्रैश होने का कारण बन सकता है।

Go. में प्रत्येक लूप के लिए

गो के पास प्रत्येक लूप के लिए नहीं है, लेकिन आप तत्वों के संग्रह को पार करने के लिए लूप के लिए संशोधित कर सकते हैं। यहाँ वाक्य रचना है:

सूचकांक के लिए, मान: = श्रेणी संग्रह {
// तन
}

संग्रह एक सरणी, टुकड़ा, स्ट्रिंग या मानचित्र, या किसी चैनल पर प्राप्त मान हो सकता है। सूचकांक संग्रह में स्थिति है। मान सूचकांक का तत्व है।

यदि आप केवल मूल्य की परवाह करते हैं, तो इस तरह के सूचकांक को छोड़ दें:

_ के लिए, मान := श्रेणी टुकड़ा {}

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

सरणी: = [] स्ट्रिंग {"नमस्ते", "दुनिया"}
के लिये मैं, जे: = रेंज सरणी {
एफएमटी.प्रिंट्लन(मैं, जे)
}

Go. में एक समय लूप

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

मैं := 1
मैं के लिए <= 5 {
	मैं *= 2
}
एफएमटी.प्रिंट्लन(मैं)

इस कोड में, जबकि मैं 5 से कम या उसके बराबर है, हर बार लूप चलने पर इसे 2 से गुणा किया जाता है।

ए डू... जबकि लूप इन गो

डू... जबकि लूप, जबकि लूप से अलग है क्योंकि लूप बॉडी कम से कम एक बार निष्पादित होगी। गो में इसे लागू करने के दो तरीके हैं।

1. सुनिश्चित करें कि पहले पुनरावृत्ति की स्थिति सत्य पर सेट है।

   मैं := 10
   के लिये अगला:= सच; अगला; अगला = मैं <= 5 {
   एफएमटी.प्रिंट्लन(मैं)
    मैं++
   }
   // 10. प्रिंट करेगा 
   

   चूंकि प्रारंभिक स्थिति सत्य पर सेट है, मैं मुद्रित किया जाता है और फिर पहले पुनरावृत्ति में वृद्धि की जाती है। शर्त के बाद से (मैं <=5) दूसरे पुनरावृत्ति के दौरान गलत का मूल्यांकन करता है, लूप बाहर निकलता है।
2. स्थिति की जाँच करने से पहले एक बार लूप बॉडी को निष्पादित करें।

   मैं := 10
   के लिये {
   एफएमटी.प्रिंट्लन(मैं)
    मैं++
   अगर मैं >= 5 {
   टूटना;
    }
   }
   // 10. प्रिंट करेगा
   

   उपरोक्त लूप के लिए, 10, जो कि i का मान है, पहले मुद्रित होता है, फिर यदि कथन निष्पादित होता है। यदि स्थिति सत्य है, तो लूप टूट जाता है, अन्यथा लूप जारी रहता है।

अन्य नियंत्रण प्रवाह विवरण

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

गो संस्करण 1.18. में नया क्या है

आगे पढ़िए