Go
Verzweigung

Wechseln Sie die Anweisungen

Eine einfache switch Anweisung:

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

Das obige Beispiel ist äquivalent zu:

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

Die default ist optional und wird nur dann ausgeführt, wenn keine der Fälle wahr ist, auch wenn sie nicht zuletzt default wird. Dies ist akzeptabel. Das folgende ist semantisch dasselbe wie beim ersten Beispiel:

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

Dies kann nützlich sein, wenn Sie die fallthrough Anweisung in der default verwenden fallthrough , die die letzte Anweisung in einem Fall sein muss und dazu führt, dass die Programmausführung zum nächsten Fall fallthrough :

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

Ein leerer Schalterausdruck ist implizit true :

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

Switch-Anweisungen unterstützen eine einfache Anweisung ähnlich der if Anweisung:

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

Fälle können in einer durch Kommas getrennten Liste zusammengefasst werden, wenn sie dieselbe Logik verwenden:

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

Wenn Aussagen

Eine einfache if Anweisung:

if a == b {
    // do something
}

Beachten Sie, dass der Zustand nicht in Klammern steht und dass sich die öffnende geschweifte Klammer { in derselben Zeile befinden muss. Folgendes wird nicht kompiliert:

if a == b
{
    // do something
}

Eine if Anweisung, die else :

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

Laut golang.org-Dokumentation "Dem Ausdruck kann eine einfache Anweisung vorangestellt werden, die ausgeführt wird, bevor der Ausdruck ausgewertet wird." In dieser einfachen Anweisung deklarierte Variablen beziehen sich auf die if Anweisung und können nicht außerhalb der Anweisung aufgerufen werden:

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

Typwechselanweisungen

Ein einfacher Schalter:

// 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
}

Sie können für jeden Typ testen, einschließlich error , benutzerdefinierte Typen, Schnittstellentypen und Funktionsarten:

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!")
    }
}

Springen Sie Anweisungen

Eine goto Anweisung überträgt die Kontrolle an die Anweisung mit dem entsprechenden Label innerhalb derselben Funktion. Die Ausführung der goto Anweisung darf nicht dazu führen, dass Variablen in den Gültigkeitsbereich fallen, die zum Zeitpunkt des goto noch nicht im Gültigkeitsbereich waren.

Siehe zum Beispiel den Standard-Quellcode der Bibliothek: 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) 

Break-Continue-Anweisungen

Die break-Anweisung bewirkt bei Ausführung, dass die aktuelle Schleife das Beenden erzwingt

Paket Haupt

import "fmt"

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

Die continue-Anweisung bewegt das Steuerelement bei der Ausführung an den Anfang der Schleife

import "fmt"

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

Schleife im Schalter unterbrechen / fortsetzen

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)
    }
}