Go
शाखाओं में

विवरण स्विच करें

एक साधारण switch स्टेटमेंट:

switch a + b {
case c:
    // do something
case d:
    // do something else
default:
    // do something entirely different
}

उपरोक्त उदाहरण इसके बराबर है:

if a + b == c {
    // do something
} else if a + b == d {
    // do something else
} else {
    // do something entirely different
}

default क्लॉज वैकल्पिक है और इसे तब ही अंजाम दिया जाएगा जब तक कि कोई भी मामले की तुलना सही न हो, भले ही वह अंतिम दिखाई न दे, जो स्वीकार्य है। निम्नलिखित शब्दार्थ पहले उदाहरण के समान है:

switch a + b {
default:
    // do something entirely different
case c:
    // do something
case d:
    // do something else
}

यह उपयोगी हो सकता है यदि आप default क्लॉज में fallthrough स्टेटमेंट का उपयोग करने का इरादा रखते हैं, जो कि किसी केस में अंतिम स्टेटमेंट होना चाहिए और प्रोग्राम के निष्पादन को अगले केस पर आगे बढ़ने का कारण बनता है:

switch a + b {
default:
    // do something entirely different, but then also do something
    fallthrough
case c:
    // do something
case d:
    // do something else
}

एक खाली स्विच अभिव्यक्ति स्पष्ट रूप से true :

switch {
case a + b == c:
    // do something
case a + b == d:
    // do something else
}

if कथन कथन के समान है, if स्विच स्टेटमेंट सरल कथन का समर्थन करते हैं:

switch n := getNumber(); n {
case 1:
    // do something
case 2:
    // do something else
}

यदि वे समान तर्क साझा करते हैं, तो मामले को अल्पविराम से अलग की गई सूची में जोड़ा जा सकता है:

switch a + b {
case c, d:
    // do something
default:
    // do something entirely different
}

यदि विवरण

एक सरल if बयान:

if a == b {
    // do something
}

ध्यान दें कि इस स्थिति के आसपास कोई कोष्ठक नहीं हैं और यह कि खुले रूप से ब्रेस ब्रेस { एक ही लाइन पर होना चाहिए। निम्नलिखित संकलन नहीं होगा:

if a == b
{
    // do something
}

एक बयान if else उपयोग कर रहा else :

if a == b {
    // do something
} else if a == c {
    // do something else
} else {
    // do something entirely different
}

प्रति golang.org के दस्तावेज़ में , "अभिव्यक्ति एक सरल कथन से पहले हो सकती है, जो अभिव्यक्ति का मूल्यांकन करने से पहले निष्पादित होती है।" इस साधारण कथन में घोषित चर को if कथन से अलग किया जाता है और इसे इसके बाहर नहीं पहुँचा जा सकता है:

if err := attemptSomething(); err != nil {
    // attemptSomething() was successful!
} else {
    // attemptSomething() returned an error; handle it
}
fmt.Println(err) // compiler error, 'undefined: err'

स्विच स्टेटमेंट टाइप करें

एक सरल प्रकार स्विच:

// assuming x is an expression of type interface{}
switch t := x.(type) {
case nil:
    // x is nil
    // t will be type interface{}
case int: 
    // underlying type of x is int
    // t will be int in this case as well
case string:
    // underlying type of x is string
    // t will be string in this case as well
case float, bool:
    // underlying type of x is either float or bool
    // since we don't know which, t is of type interface{} in this case
default:
    // underlying type of x was not any of the types tested for
    // t is interface{} in this type
}

आप किसी भी प्रकार के लिए परीक्षण कर सकते हैं, जिसमें error , उपयोगकर्ता-परिभाषित प्रकार, इंटरफ़ेस प्रकार और फ़ंक्शन प्रकार शामिल हैं:

switch t := x.(type) {
case error:
    log.Fatal(t)
case myType:
    fmt.Println(myType.message)
case myInterface:
    t.MyInterfaceMethod()
case func(string) bool:
    if t("Hello world?") {
        fmt.Println("Hello world!")
    }
}

गोटो के बयान

एक goto स्टेटमेंट एक ही फ़ंक्शन में संबंधित लेबल के साथ स्टेटमेंट पर नियंत्रण स्थानांतरित करता है। निष्पादित goto बयान किसी भी चर के बिंदु पर दायरे में पहले से ही नहीं थे दायरे में आने के लिए कारण नहीं होना चाहिए goto ।

उदाहरण के लिए मानक पुस्तकालय स्रोत कोड देखें: https://golang.org/src/math/gamma.go :

    for x < 0 {
        if x > -1e-09 {
            goto small
        }
        z = z / x
        x = x + 1
    }
    for x < 2 {
        if x < 1e-09 {
            goto small
        }
        z = z / x
        x = x + 1
    }

    if x == 2 {
        return z
    }

    x = x - 2
    p = (((((x*_gamP[0]+_gamP[1])*x+_gamP[2])*x+_gamP[3])*x+_gamP[4])*x+_gamP[5])*x + _gamP[6]
    q = ((((((x*_gamQ[0]+_gamQ[1])*x+_gamQ[2])*x+_gamQ[3])*x+_gamQ[4])*x+_gamQ[5])*x+_gamQ[6])*x + _gamQ[7]
    return z * p / q

small:
    if x == 0 {
        return Inf(1)
    }
    return z / ((1 + Euler*x) * x) 

ब्रेक-जारी बयान

निष्पादन पर ब्रेक स्टेटमेंट, वर्तमान लूप को बाहर निकलने के लिए मजबूर करता है

पैकेज मुख्य

import "fmt"

func main() {
    i:=0
    for true {
      if i>2 {
        break
        }
    fmt.Println("Iteration : ",i)
    i++
    }
}

निष्पादन पर जारी बयान, नियंत्रण को लूप की शुरुआत तक ले जाता है

import "fmt"

func main() {
    j:=100
    for j<110 {
     j++
     if j%2==0 {
        continue
        } 
    fmt.Println("Var : ",j)        
    }
}

स्विच के अंदर लूप को तोड़ें / जारी रखें

import "fmt"

func main() {
    j := 100

loop:
    for j < 110 {
        j++

        switch j % 3 {
        case 0:
            continue loop
        case 1:
            break loop
        }

        fmt.Println("Var : ", j)
    }
}