Go
разветвление

Записи переключателей

Простой оператор switch :

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

Вышеприведенный пример эквивалентен:

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

Предложение по default является необязательным и будет выполняться тогда и только тогда, когда ни один из случаев не сравнится с истинным, даже если он не отображается последним, что является приемлемым. Следующее семантически такое же, как в первом примере:

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

Это может быть полезно, если вы намереваетесь использовать инструкцию fallthrough в предложении по default , которое должно быть последним оператором в случае, и заставляет выполнение программы перейти к следующему случаю:

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

Выражение пустого оператора неявно true :

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

Операторы switch поддерживают простой оператор, аналогичный операторам if :

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

Случаи могут объединяться в список, разделенный запятыми, если они имеют одну и ту же логику:

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

Если заявления

Простая инструкция if :

if a == b {
    // do something
}

Обратите внимание, что нет скобок, окружающих условие, и что открывающая фигурная скобка { должна находиться в одной строке. Следующие не будут компилироваться:

if a == b
{
    // do something
}

Утверждение if использующее else :

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

В документации к golang.org «выражению может предшествовать простой оператор, который выполняется до вычисления выражения». Переменные, объявленные в этом простом заявлении, привязаны к оператору if и не могут быть доступны за его пределами:

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

Заявления о переключателях типов

Простой переключатель типа:

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

Вы можете протестировать любой тип, включая error , пользовательские типы, типы интерфейсов и типы функций:

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 передает управление выражению с соответствующей меткой в ​​пределах одной и той же функции. Выполнение инструкции goto не должно приводить к тому, что какие-либо переменные попадают в область видимости, которые еще не были в области видимости в точке goto .

например, см. стандартный исходный код библиотеки: 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, при выполнении делает текущий цикл принудительным выходом

основной пакет

import "fmt"

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

Оператор continue, при выполнении перемещает элемент управления в начало цикла

import "fmt"

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

Перерыв / продолжение цикла внутри переключателя

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