Go
vertakking

Schakel verklaringen uit

Een eenvoudige switch :

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

Het bovenstaande voorbeeld is gelijk aan:

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

De default is optioneel en wordt uitgevoerd als en alleen als geen van de gevallen waar vergelijkt, zelfs als deze niet als laatste verschijnt, wat acceptabel is. Het volgende is semantisch hetzelfde als het eerste voorbeeld:

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

Dit kan handig zijn als u van plan bent de fallthrough instructie in de default te gebruiken, die de laatste instructie in een case moet zijn en ervoor zorgt dat het programma wordt uitgevoerd naar de volgende case:

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

Een lege schakeluitdrukking is impliciet true :

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

Switch-instructies ondersteunen een eenvoudige instructie die lijkt op if instructies:

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

Cases kunnen worden gecombineerd in een door komma's gescheiden lijst als ze dezelfde logica delen:

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

Als verklaringen

Een eenvoudige if verklaring:

if a == b {
    // do something
}

Merk op dat er geen haakjes rondom de aandoening staan en dat de krullende accolade { op dezelfde lijn moet staan. Het volgende wordt niet gecompileerd:

if a == b
{
    // do something
}

Een if instructie die else :

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

Volgens de documentatie van golang.org : "De uitdrukking kan worden voorafgegaan door een eenvoudige verklaring, die wordt uitgevoerd voordat de uitdrukking wordt geëvalueerd." Variabelen die in deze eenvoudige instructie worden gedeclareerd, vallen onder de if instructie en zijn niet toegankelijk buiten de instructie:

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

Type schakelaarverklaringen

Een eenvoudige typeschakelaar:

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

U kunt testen voor elk type, inclusief error , door de gebruiker gedefinieerde typen, interfacetypen en functietypen:

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

Ga naar verklaringen

Een goto instructie draagt de controle over aan de instructie met het bijbehorende label binnen dezelfde functie. Het uitvoeren van de goto instructie mag geen variabelen binnen bereik brengen die nog niet binnen het bereik van de goto stonden.

zie bijvoorbeeld de standaardbroncode van de bibliotheek: 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 verklaringen

De instructie break maakt bij uitvoering de huidige lus om exit te forceren

pakket hoofd

import "fmt"

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

De instructie continue, bij uitvoering, verplaatst het besturingselement naar het begin van de lus

import "fmt"

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

Breek / ga door lus in schakelaar

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