range इटरेशन में

range इटरेशन के बारे में

Go में for range किसी रेंज एक्सप्रेशन से मिलने वाली वैल्यू के लिए कोड का एक ब्लॉक दोहराता है। रेंज एक्सप्रेशन तय करता है कि हर इटरेशन एक वैल्यू देगा या दो।

रेंज एक्सप्रेशन

स्लाइस पर रेंज

स्लाइस पर range हर एलिमेंट का इंडेक्स और वैल्यू क्रम से देता है:

vals := []int{10, 20, 30}
for i, v := range vals {
    fmt.Println(i, v)
}
// 0 10
// 1 20
// 2 30

मैप पर रेंज

मैप पर range हर की और वैल्यू देता है, लेकिन इटरेशन का क्रम तय नहीं होता। Go जानबूझकर मैप के इटरेशन का क्रम अनियमित कर देता है, इसलिए एक ही प्रोग्राम हर बार अलग आउटपुट दे सकता है।

hash := map[int]int{9: 10, 99: 20, 999: 30}
for k, v := range hash {
    fmt.Println(k, v)
}
// 99 20
// 999 30
// 9 10

स्ट्रिंग पर रेंज

स्ट्रिंग पर range बाइट इंडेक्स और हर रून (यूनिकोड कोड पॉइंट) देता है। नीचे के उदाहरण में 子 तीन बाइट लेता है, इसलिए 猫 बाइट इंडेक्स 3 से शुरू होता है, 1 से नहीं।

for i, r := range "子猫" {
    fmt.Println(i, r, string(r))
}
// 0 23376 子
// 3 29483 猫

अगर आपको रून इंडेक्स चाहिए, तो स्ट्रिंग को रून के स्लाइस में बदल दीजिए:

for i, r := range []rune("子猫") {
    fmt.Println(i, r, string(r))
}
// 0 23376 子
// 1 29483 猫

पूर्णांक पर रेंज

range सीधे एक पूर्णांक पर भी इटरेशन कर सकता है, और 0 से लेकर उस पूर्णांक से एक कम तक की वैल्यू देता है। शून्य और ऋणात्मक वैल्यू मान्य हैं, लेकिन उनसे कोई इटरेशन नहीं होता।

for n := range 3 {
    fmt.Println(n)
}
// 0
// 1
// 2

इटरेटर पर रेंज

range iter.Seq[V] या iter.Seq2[K, V] टाइप का इटरेटर स्वीकार करता है। इटरेटर एक फंक्शन होता है जो एक बार में एक वैल्यू देते हुए वैल्यूओं का क्रम बनाता है। फिर range उन वैल्यूओं पर एक-एक करके आगे बढ़ सकता है।

text := "The quick brown fox"
for word := range strings.FieldsSeq(text) {
    fmt.Println(word)
}
// The
// quick
// brown
// fox

names := []string{"Alice", "Bob", "Vera"}
for i, v := range slices.All(names) {
    fmt.Println(i, ":", v)
}
// 0 : Alice
// 1 : Bob
// 2 : Vera

चैनल पर रेंज

अंत में, range चैनल से भेजी गई वैल्यूओं को तब तक प्राप्त कर सकता है जब तक कि वह चैनल कहीं और बंद न कर दिया जाए। चैनलों को ट्रैक के सिलेबस में आगे और विस्तार से समझाया गया है।

इंडेक्स या वैल्यू छोड़ना

अगर कोई वेरिएबल घोषित किया जाए लेकिन उसका उपयोग कभी न हो, तो Go उस कोड को कंपाइल नहीं करेगा।

vals := []int{10, 20, 30}
for i, v := range vals {
    fmt.Println(v)
}
// Go build failed: declared and not used: i

अगर सिर्फ वैल्यू चाहिए, तो इंडेक्स या की को _ में असाइन करके उसे छोड़ दीजिए।

vals := []int{10, 20, 30}
for _, v := range vals {
    fmt.Println(v)
}
// 10
// 20
// 30

अगर सिर्फ इंडेक्स चाहिए, तो इसे पूरी तरह छोड़ दीजिए:

vals := []int{10, 20, 30}
for i := range vals {
    fmt.Println(i)
}
// 0
// 1
// 2

अगर इंडेक्स और वैल्यू दोनों की ज़रूरत न हो, तो दोनों को छोड़ा जा सकता है:

vals := []int{10, 20, 30}
count := 0
for range vals {
    count++
}
// count == 3