Go
Ramification

Instructions de commutation

Une simple déclaration de switch :

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

L'exemple ci-dessus est équivalent à:

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

La clause default est facultative et sera exécutée si et seulement si aucun des cas ne se compare à true, même si cela ne semble pas le dernier, ce qui est acceptable. Ce qui suit est sémantiquement identique au premier exemple:

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

Cela peut être utile si vous avez l'intention d'utiliser l'instruction fallthrough dans la clause default , qui doit être la dernière instruction d'un cas et provoque l'exécution du programme au cas suivant:

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

Une expression de commutateur vide est implicitement true :

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

Les instructions switch prennent en charge une instruction simple similaire aux instructions if :

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

Les cas peuvent être combinés dans une liste séparée par des virgules s'ils partagent la même logique:

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

Si déclarations

Une simple déclaration if :

if a == b {
    // do something
}

Notez qu'il n'y a pas de parenthèses entourant la condition et que l'accolade ouvrante { doit être sur la même ligne. Les éléments suivants ne seront pas compilés:

if a == b
{
    // do something
}

Une déclaration if utilisant else :

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

Selon la documentation de golang.org , "l'expression peut être précédée d'une simple instruction, qui s'exécute avant que l'expression soit évaluée." Les variables déclarées dans cette instruction simple sont étendues à l'instruction if et ne sont pas accessibles en dehors de celle-ci:

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

Relevés de type

Un simple commutateur de type:

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

Vous pouvez tester tout type, y compris l' error , les types définis par l'utilisateur, les types d'interface et les types de fonction:

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 déclarations

Une goto transfère le contrôle à l'instruction avec l'étiquette correspondante dans la même fonction. L'exécution de l' goto ne doit pas entraîner la portée des variables qui n'étaient pas déjà présentes au point du goto .

Par exemple, consultez le code source de la bibliothèque 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) 

Déclarations de rupture

L'instruction break, lors de l'exécution, oblige la boucle courante à quitter

paquet principal

import "fmt"

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

L'instruction continue, à l'exécution, déplace le contrôle au début de la boucle

import "fmt"

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

Casser / continuer la boucle à l'intérieur du commutateur

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