Go
Derivación

Cambiar declaraciones

Una simple declaración de switch :

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

El ejemplo anterior es equivalente a:

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

La cláusula default es opcional y se ejecutará si y solo si ninguno de los casos se compara como verdadero, incluso si no aparece en último lugar, lo que es aceptable. Lo siguiente es semánticamente igual al primer ejemplo:

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

Esto podría ser útil si tiene la intención de usar la declaración de fallthrough en la cláusula default , que debe ser la última declaración en un caso y hace que la ejecución del programa continúe con el siguiente caso:

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

Una expresión de interruptor vacía es implícitamente true :

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

Las instrucciones de cambio admiten una instrucción simple similar a las declaraciones if :

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

Los casos se pueden combinar en una lista separada por comas si comparten la misma lógica:

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

Si las declaraciones

Una simple declaración if :

if a == b {
    // do something
}

Tenga en cuenta que no hay paréntesis alrededor de la condición y que la llave de apertura { debe estar en la misma línea. Lo siguiente no se compilará:

if a == b
{
    // do something
}

Una declaración if haciendo uso de else :

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

Según la documentación de golang.org , "la expresión puede estar precedida por una declaración simple, que se ejecuta antes de que se evalúe la expresión". Las variables declaradas en esta simple declaración tienen el alcance de la instrucción if y no se puede acceder a ellas desde fuera:

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

Tipo de cambio de instrucciones

Un simple interruptor de 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
}

Puede probar cualquier tipo, incluidos error , tipos definidos por el usuario, tipos de interfaz y tipos de funciones:

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 declaraciones

Una instrucción goto transfiere el control a la instrucción con la etiqueta correspondiente dentro de la misma función. La ejecución de la instrucción goto no debe hacer que ninguna variable entre en el alcance que aún no estuviera dentro del alcance en el punto del goto .

por ejemplo, consulte el código fuente de la biblioteca estándar: 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) 

Declaraciones de ruptura de continuar

La instrucción break, en la ejecución, hace que el bucle actual obligue a salir.

paquete principal

import "fmt"

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

La instrucción continue, en ejecución, mueve el control al inicio del bucle.

import "fmt"

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

Interruptor de interrupción / interrupción dentro del bucle

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