Go
branching

Switch Statements

Una semplice dichiarazione di switch :

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

L'esempio sopra è equivalente a:

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

La clausola default è facoltativa e verrà eseguita se e solo se nessuno dei casi si confronta con vero, anche se non appare per ultimo, il che è accettabile. Quanto segue è semanticamente uguale al primo esempio:

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

Ciò potrebbe essere utile se si intende utilizzare l'istruzione fallthrough nella clausola default , che deve essere l'ultima istruzione in un caso e fa sì che l'esecuzione del programma passi al caso successivo:

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

Un'espressione switch vuota è implicitamente true :

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

Le istruzioni switch supportano una semplice istruzione simile alle istruzioni if :

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

I casi possono essere combinati in un elenco separato da virgole se condividono la stessa logica:

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

Se le dichiarazioni

Una semplice dichiarazione if :

if a == b {
    // do something
}

Si noti che non ci sono parentesi che circondano la condizione e che la parentesi graffa di apertura { deve essere sulla stessa linea. Quanto segue non verrà compilato:

if a == b
{
    // do something
}

Un'istruzione if che fa uso di else :

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

La documentazione di Per golang.org , "L'espressione può essere preceduta da una semplice istruzione, che viene eseguita prima che l'espressione venga valutata." Le variabili dichiarate in questa semplice istruzione sono associate all'istruzione if e non possono essere accessibili al di fuori di essa:

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

Digitare istruzioni switch

Un semplice interruttore di tipo:

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

È possibile eseguire test per qualsiasi tipo, inclusi error , tipi definiti dall'utente, tipi di interfaccia e tipi di funzione:

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

Dichiarazioni Goto

goto trasferisce il controllo all'istruzione con l'etichetta corrispondente all'interno della stessa funzione. L'esecuzione dell'istruzione goto non deve far entrare in campo le variabili che non erano già in ambito al punto del goto .

per esempio vedi il codice sorgente della libreria 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) 

Dichiarazioni Break-continue

L'istruzione break, durante l'esecuzione, rende il loop corrente forzato all'uscita

pacchetto principale

import "fmt"

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

L'istruzione continue, durante l'esecuzione sposta il controllo all'inizio del ciclo

import "fmt"

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

Interruttore di interruzione / continuazione del circuito interno

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