Go
लूप्स

परिचय

बेसिक लूप

for केवल लूप स्टेटमेंट है, इसलिए एक बुनियादी लूप कार्यान्वयन इस तरह दिख सकता है:

// like if, for doesn't use parens either.
// variables declared in for and if are local to their scope.
for x := 0; x < 3; x++ { // ++ is a statement.
    fmt.Println("iteration", x)
}

// would print:
// iteration 0
// iteration 1
// iteration 2

तोड़ो और जारी रखो

लूप से बाहर निकलना और अगले पुनरावृत्ति को जारी रखना भी गो में समर्थित है, जैसे कई अन्य भाषाओं में:

for x := 0; x < 10; x++ { // loop through 0 to 9
    if x < 3 { // skips all the numbers before 3
        continue
    } 
    if x > 5 { // breaks out of the loop once x == 6
        break
    }
    fmt.Println("iteration", x)
}

// would print:
// iteration 3
// iteration 4
// iteration 5

break और continue बयान अतिरिक्त रूप से एक वैकल्पिक लेबल को स्वीकार करते हैं, जिसका उपयोग कथन के साथ लक्षित करने के लिए बाहरी छोरों की पहचान करने के लिए किया जाता है:

OuterLoop:
for {
    for {
        if allDone() {
            break OuterLoop
        }
        if innerDone() {
            continue OuterLoop
        }
        // do something
    }
}

सशर्त लूप

for कीवर्ड भी सशर्त छोरों के लिए प्रयोग किया जाता है पारंपरिक रूप से while अन्य प्रोग्रामिंग भाषाओं में छोरों।

package main

import (
    "fmt"
)

func main() {
    i := 0
    for i < 3 { // Will repeat if condition is true
        i++
        fmt.Println(i)
    }
}

इसे खेल के मैदान पर खेलें

उत्पादन होगा:

1
2
3

अनंत लूप:

for {
    // This will run until a return or break.
}

विभिन्न प्रकार के लूप के लिए

एक चर का उपयोग करते हुए सरल रूप:

for i := 0; i < 10; i++ {
    fmt.Print(i, " ")
}

दो चर (या अधिक) का उपयोग करना:

for i, j := 0, 0; i < 5 && j < 10; i, j = i+1, j+2 {
    fmt.Println(i, j)
}

आरंभीकरण कथन का उपयोग किए बिना:

i := 0
for ; i < 10; i++ {
    fmt.Print(i, " ")
}

परीक्षण अभिव्यक्ति के बिना:

for i := 1; ; i++ {
    if i&1 == 1 {
        continue
    }
    if i == 22 {
        break
    }
    fmt.Print(i, " ")
}

वेतन वृद्धि की अभिव्यक्ति के बिना:

for i := 0; i < 10; {
    fmt.Print(i, " ")
    i++
}

जब तीनों आरंभीकरण, परीक्षण और वृद्धि के भाव हटा दिए जाते हैं, तो लूप अनंत हो जाता है:

i := 0
for {
    fmt.Print(i, " ")
    i++
    if i == 10 {
        break
    }
}

यह शून्य के साथ शुरू काउंटर के साथ अनंत लूप का एक उदाहरण है:

for i := 0; ; {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
    i++
}

जब केवल परीक्षण अभिव्यक्ति का उपयोग किया जाता है (लूप करते समय एक ठेठ की तरह काम करता है):

i := 0
for i < 10 {
    fmt.Print(i, " ")
    i++
}

सिर्फ वेतन वृद्धि अभिव्यक्ति का उपयोग करना:

i := 0
for ; ; i++ {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
}

सूचकांक और मूल्य का उपयोग करते हुए मूल्यों की एक सीमा से अधिक:

ary := [5]int{0, 1, 2, 3, 4}
for index, value := range ary {
    fmt.Println("ary[", index, "] =", value)
}

सिर्फ इंडेक्स का उपयोग करके एक सीमा से अधिक का परिवर्तन करें:

for index := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

सिर्फ इंडेक्स का उपयोग करके एक सीमा से अधिक का परिवर्तन करें:

for index, _ := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

केवल मूल्य का उपयोग करके एक सीमा से अधिक का परिवर्तन करें:

for _, value := range ary {
    fmt.Print(value, " ")
}

मानचित्र के लिए कुंजी और मान का उपयोग करते हुए एक सीमा से अधिक हो (क्रम में नहीं हो सकता है):

mp := map[string]int{"One": 1, "Two": 2, "Three": 3}
for key, value := range mp {
    fmt.Println("map[", key, "] =", value)
}

नक्शे के लिए बस कुंजी का उपयोग कर एक सीमा से अधिक हो सकता है (क्रम में नहीं हो सकता):

for key := range mp {
    fmt.Print(key, " ") //One Two Three
}

नक्शे के लिए बस कुंजी का उपयोग कर एक सीमा से अधिक हो सकता है (क्रम में नहीं हो सकता):

for key, _ := range mp {
    fmt.Print(key, " ") //One Two Three
}

नक्शे के लिए सिर्फ मान का उपयोग कर एक सीमा से अधिक हो सकता है (क्रम में नहीं हो सकता है):

for _, value := range mp {
    fmt.Print(value, " ") //2 3 1
}

चैनलों के लिए एक सीमा से अधिक मिटाएं (यदि चैनल बंद है तो बाहर निकलता है):

ch := make(chan int, 10)
for i := 0; i < 10; i++ {
    ch <- i
}
close(ch)

for i := range ch {
    fmt.Print(i, " ")
}

स्ट्रिंग के लिए एक सीमा से अधिक पाएं (यूनिकोड कोड अंक देता है):

utf8str := "B = \u00b5H" //B = µH
for _, r := range utf8str {
    fmt.Print(r, " ") //66 32 61 32 181 72
}
fmt.Println()
for _, v := range []byte(utf8str) {
    fmt.Print(v, " ") //66 32 61 32 194 181 72
}
fmt.Println(len(utf8str)) //7

जैसा कि आप देख रहे हैं कि utf8str में 6 रन (यूनिकोड कोड पॉइंट) और 7 बाइट्स हैं।

समय पर लूप

package main

import(
    "fmt"
    "time"
)

func main() {
    for _ = range time.Tick(time.Second * 3) {
        fmt.Println("Ticking every 3 seconds")
    }
}