Go में संख्याओं की श्रेणी पर पुनरावृत्ति: 3 शक्तिशाली तरीके

प्रश्न "Is there a way to iterate over a range of integers?" इतना लोकप्रिय क्यों है?

यदि आप कभी Python से Go में आए हैं, तो आपको शायद सुरुचिपूर्ण for i in range(10): याद होगा। Python में यह घड़ी की तरह काम करता है। Go में... चीज़ें थोड़ी अलग हैं। Stack Overflow पर इस शीर्षक वाले प्रश्न को हज़ारों बार देखा गया है - और यह कोई संयोग नहीं है। उच्च-स्तरीय अमूर्तताओं के आदी डेवलपर अक्सर Go के न्यूनतम सिंटैक्स का सामना करने पर भ्रमित हो जाते हैं।

इस लेख में, हम Go में पूर्णांकों की श्रेणी पर पुनरावृत्ति करने के सभी तरीकों पर चर्चा करेंगे: क्लासिक for से लेकर आधुनिक उपयोगिताओं तक। आप जानेंगे कि अधिकतम प्रदर्शन के लिए कौन सा तरीका चुनना है, और कोड की पठनीयता के लिए कौन सा। चलिए शुरू करते हैं!

तरीका नंबर 1: क्लासिक for (मुहावरेदार Go)

Go व्यावहारिक लोगों की भाषा है। इसमें संख्याओं के लिए कोई अंतर्निहित range नहीं है, लेकिन एक शक्तिशाली for है। सबसे सरल और सबसे कुशल तरीका तीन-घटक वाले लूप का उपयोग करना है:

package main\n\nimport "fmt"\n\nfunc main() {\n    // 0 से 9 तक पुनरावृत्ति (कुल 10 तत्व)\n    for i := 0; i < 10; i++ {\n        fmt.Println(i)\n    }\n}

यह कोड अत्यधिक कुशल है: कंपाइलर इसे एक साधारण रजिस्टर इंक्रीमेंट में बदल देता है। कोई मेमोरी आवंटन नहीं, कोई ओवरहेड नहीं। प्रोडक्शन में Go डेवलपर ठीक इसी तरह लिखते हैं।

क्लासिक for के विविध रूप

आप आसानी से प्रारंभिक मान और चरण बदल सकते हैं:

// 5 से 15 तक\nfor i := 5; i <= 15; i++ {\n    fmt.Println(i)\n}\n\n// 0 से 20 तक केवल सम संख्याएँ\nfor i := 0; i <= 20; i += 2 {\n    fmt.Println(i)\n}\n\n// उल्टा क्रम: 10 से 1 तक\nfor i := 10; i >= 1; i-- {\n    fmt.Println(i)\n}

यह तरीका Go में संख्याओं की श्रेणी पर पुनरावृत्ति के लिए स्वर्ण मानक है। यह सरल, समझने योग्य है और इसमें अतिरिक्त पैकेज आयात करने की आवश्यकता नहीं है।

तरीका नंबर 2: स्लाइस के साथ range का उपयोग (Python प्रेमियों के लिए)

यदि आप Python शैली को बहुत याद करते हैं, तो आप एक स्लाइस बना सकते हैं और range के माध्यम से उस पर पुनरावृत्ति कर सकते हैं। लेकिन सावधान रहें: यह प्रदर्शन को बहुत प्रभावित करता है।

package main\n\nimport "fmt"\n\nfunc main() {\n    // 0 से 9 तक संख्याओं का एक स्लाइस बनाएँ\n    numbers := make([]int, 10)\n    for i := range numbers {\n        numbers[i] = i\n    }\n\n    // अब पुनरावृत्ति के लिए range का उपयोग करें\n    for _, num := range numbers {\n        fmt.Println(num)\n    }\n}

यह खराब क्यों है? मेमोरी आवंटन। हर बार जब आप एक स्लाइस बनाते हैं, Go हीप में मेमोरी आवंटित करता है। 10 तत्वों की श्रेणी के लिए यह ध्यान देने योग्य नहीं है, लेकिन 10 मिलियन के लिए यह एक समस्या है।

बेंचमार्क: for बनाम स्लाइस के साथ range

आइए आंकड़ों पर नज़र डालें (1,000,000 संख्याओं पर पुनरावृत्ति):

\n
• क्लासिक for: ~2.5 मि.से., 0 आवंटन
\n
• स्लाइस के साथ range: ~45 मि.से., 1 आवंटन (8 MB)
\n

अंतर 18 गुना है! और यह केवल दस लाख तत्वों के लिए है। बड़ी श्रेणियों के लिए, अंतर और बढ़ जाता है।

तरीका नंबर 3: लाइब्रेरीज़ का उपयोग (iter, lo, और अन्य)

Go समुदाय स्थिर नहीं है। ऐसी तृतीय-पक्ष लाइब्रेरीज़ मौजूद हैं जो श्रेणी पर पुनरावृत्ति के लिए सिंटैक्टिक शुगर जोड़ती हैं। आइए दो लोकप्रिय लाइब्रेरीज़ पर नज़र डालें:

3.1 iter पैकेज (प्रायोगिक, Go 1.23+)

Go 1.23 से शुरू होकर, मानक लाइब्रेरी में एक प्रायोगिक पैकेज iter जोड़ा गया है, जो इटरेटर बनाने की अनुमति देता है। यह अभी तक स्थिर नहीं है, लेकिन पहले से ही उपलब्ध है:

package main\n\nimport (\n    "fmt"\n    "iter"\n)\n\nfunc main() {\n    // 0 से 9 तक एक इटरेटर बनाएँ\n    seq := iter.Seq[int](func(yield func(int) bool) {\n        for i := 0; i < 10; i++ {\n            if !yield(i) {\n                return\n            }\n        }\n    })\n\n    for num := range seq {\n        fmt.Println(num)\n    }\n}