Control condicional en Go

En Go, hay tres tipos de sentencias de control condicional: if, switch, select. select es relativamente especial comparado con los dos primeros, no se explicará en esta sección, se dejará para la sección de concurrencia.

if else

if else tiene como máximo dos ramas de decisión, el formato de la sentencia es el siguiente

if expression {

}

o

if expression {

}else {

}

expression debe ser una expresión booleana, es decir, el resultado debe ser verdadero o falso, debe ser un valor booleano, un ejemplo es el siguiente

func main() {
   a, b := 1, 2
   if a > b {
      b++
   } else {
      a++
   }
}

También se puede escribir la expresión de forma más compleja, cuando sea necesario para mejorar la legibilidad, se deben usar paréntesis para indicar explícitamente qué debe calcularse primero.

func main() {
   a, b := 1, 2
    if a<<1%100+3 > b*100/20+6 { // (a<<1%100)+3 > (b*100/20)+6
      b++
   } else {
      a++
   }
}

Al mismo tiempo, la sentencia if también puede incluir algunas sentencias simples, por ejemplo

func main() {
  if x := 1 + 1; x > 2 {
    fmt.Println(x)
  }
}

else if

La sentencia else if puede crear más ramas de decisión sobre la base de if else, el formato de la sentencia es el siguiente

if expression1 {

}else if expression2 {

}else if expression3 {

}else {

}

Durante la ejecución, cada expresión se evalúa de izquierda a derecha, y toda la sentencia if se evalúa de arriba a abajo. Un ejemplo de calificación según la puntuación es el siguiente, primera forma de escribir

func main() {
   score := 90
   var ans string
   if score == 100 {
      ans = "S"
   } else if score >= 90 && score < 100 {
      ans = "A"
   } else if score >= 80 && score < 90 {
      ans = "B"
   } else if score >= 70 && score < 80 {
      ans = "C"
   } else if score >= 60 && score < 70 {
      ans = "E"
   } else if score >= 0 && score < 60 {
      ans = "F"
   } else {
      ans = "nil"
   }
   fmt.Println(ans)
}

La segunda forma de escribir aprovecha la premisa de que la sentencia if se evalúa de arriba a abajo, por lo que el código es más conciso.

func main() {
  score := 90
  var ans string
  if score >= 0 && score < 60 {
    ans = "F"
  } else if score < 70 {
    ans = "D"
  } else if score < 80 {
    ans = "C"
  } else if score < 90 {
    ans = "B"
  } else if score < 100 {
    ans = "A"
  } else if score == 100 {
    ans = "S"
    }else {
        ans = "nil"
    }
  fmt.Println(ans)
}

switch

La sentencia switch también es una sentencia de múltiples ramas, el formato de la sentencia es el siguiente

switch expr {
  case case1:
    statement1
  case case2:
    statement2
  default:
    default statement
}

Un ejemplo simple es el siguiente

func main() {
   str := "a"
   switch str {
   case "a":
      str += "a"
      str += "c"
   case "b":
      str += "bb"
      str += "aaaa"
   default: // Cuando ningún case coincide, se ejecuta la rama default
      str += "CCCC"
   }
   fmt.Println(str)
}

También se pueden escribir algunas sentencias simples antes de la expresión, como declarar nuevas variables

func main() {
  switch num := f(); { // equivalente a switch num := f(); true {
  case num >= 0 && num <= 1:
    num++
  case num > 1:
    num--
    fallthrough
  case num < 0:
    num += num
  }
}

func f() int {
  return 1
}

La sentencia switch también puede no tener expresión de entrada.

func main() {
   num := 2
   switch { // equivalente a switch true {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
   case num < 0:
      num *= num
   }
   fmt.Println(num)
}

A través de la palabra clave fallthrough se puede continuar ejecutando la siguiente rama adyacente.

func main() {
   num := 2
   switch {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
      fallthrough // Después de ejecutar esta rama, continuará ejecutando la siguiente rama
   case num < 0:
      num += num
   }
   fmt.Println(num)
}

label

La sentencia de etiqueta, etiqueta un bloque de código, puede ser el objetivo de goto, break, continue. Un ejemplo es el siguiente

func main() {
  A:
    a := 1
  B:
    b := 2
}

Usar etiquetas por sí solo no tiene ningún sentido, necesita combinarse con otras palabras clave para su uso.

goto

goto transfiere el control a la sentencia con la etiqueta correspondiente en la misma función, un ejemplo es el siguiente

func main() {
   a := 1
   if a == 1 {
      goto A
   } else {
      fmt.Println("b")
   }
A:
   fmt.Println("a")
}

En aplicaciones prácticas, goto se usa muy poco, saltar de un lado a otro reduce la legibilidad del código, el consumo de rendimiento también es un problema.