Go
Förgrening

Byt uttalanden

Ett enkelt switch uttalande:

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

Exemplet ovan motsvarar:

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

default är valfri och kommer att köras om och bara om ingen av fallen jämförs sant, även om den inte visas sist, vilket är acceptabelt. Följande är semantiskt samma som det första exemplet:

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

Detta kan vara användbart om du tänker använda fallthrough uttalande i default , som måste vara det sista uttalandet i ett ärende och får programmets körning att fortsätta till nästa fall:

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

Ett tomt switchuttryck är implicit true :

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

Byt uttalanden stöder ett enkelt uttalande som liknar if uttalanden:

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

Fall kan kombineras i en kommaseparerad lista om de delar samma logik:

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

Om uttalanden

Ett enkelt if uttalande:

if a == b {
    // do something
}

Observera att det inte finns några parenteser kring tillståndet och att öppningens lockiga stag { måste vara på samma linje. Följande kommer inte att sammanställas:

if a == b
{
    // do something
}

En if uttalande som använder sig av else :

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

Per golang.orgs dokumentation , "Uttrycket kan föregås av ett enkelt uttalande, som körs innan uttrycket utvärderas." Variabler som deklareras i detta enkla uttalande skopas till if uttalandet och kan inte nås utanför det:

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

Skriv omkopplarmeddelanden

En enkel switch:

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

Du kan testa för alla typer, inklusive error , användardefinierade typer, gränssnittstyper och funktionstyper:

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 uttalanden

Ett goto uttalande överför kontrollen till uttalandet med motsvarande etikett inom samma funktion. Att utföra goto uttalandet får inte få några variabler att komma in i omfattning som inte redan fanns inom räckvidden vid goto punkten.

se till exempel källkoden för bibliotekets standard: 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 uttalanden

Brottmeddelandet vid körning gör den nuvarande slingan för att tvinga utgången

paketets huvud

import "fmt"

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

Fortsättningsförklaringen vid körning flyttar kontrollen till loopens början

import "fmt"

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

Bryt / fortsätt slingan inuti omkopplaren

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