Go
Rozgałęzienie

Instrukcje zamiany

Prosta instrukcja switch :

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

Powyższy przykład jest równoważny z:

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

default klauzula jest opcjonalna i zostanie wykonana wtedy i tylko wtedy, gdy żaden z przypadków nie porówna się z prawdą, nawet jeśli nie pojawi się ona na końcu, co jest dopuszczalne. Poniższe jest semantycznie takie samo jak w pierwszym przykładzie:

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

Może to być przydatne, jeśli zamierzasz użyć instrukcji fallthrough w klauzuli default , która musi być ostatnią instrukcją w sprawie i powoduje przejście programu do następnej sprawy:

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

Puste wyrażenie przełącznika jest domyślnie true :

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

Instrukcje switch obsługują proste instrukcje podobne do instrukcji if :

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

Przypadki można łączyć na liście oddzielonej przecinkami, jeśli mają tę samą logikę:

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

Jeśli oświadczenia

Prosta instrukcja if :

if a == b {
    // do something
}

Zauważ, że nie ma nawiasów otaczających warunek i że nawias klamrowy otwierający { musi znajdować się w tej samej linii. Następujące elementy nie zostaną skompilowane:

if a == b
{
    // do something
}

Instrukcja if korzystająca z else :

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

Według dokumentacji golang.org: „Wyrażenie może być poprzedzone prostą instrukcją, która jest wykonywana przed obliczeniem wyrażenia”. Zmienne zadeklarowane w tej prostej instrukcji mają zakres do instrukcji if i nie można uzyskać do niej dostępu poza nią:

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

Instrukcje typu przełącznika

Prosty przełącznik typu:

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

Możesz przetestować dowolny typ, w tym error , typy zdefiniowane przez użytkownika, typy interfejsów i typy funkcji:

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

Idź do oświadczeń

Instrukcja goto przenosi kontrolę na instrukcję z odpowiednią etykietą w ramach tej samej funkcji. Wykonanie instrukcji goto nie może powodować wejścia w zakres żadnych zmiennych, które nie były już w zasięgu w punkcie goto .

na przykład zobacz standardowy kod źródłowy biblioteki: 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) 

Instrukcje Break-Continue

Instrukcja break po wykonaniu powoduje, że bieżąca pętla wymusza wyjście

pakiet główny

import "fmt"

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

Instrukcja Kontynuuj po wykonaniu przenosi kontrolkę na początek pętli

import "fmt"

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

Przerwij / kontynuuj pętlę wewnątrz przełącznika

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