Controle Condicional do Go

Em Go, existem três tipos de instruções de controle condicional if, switch, select. select é relativamente especial comparado aos outros dois, não será abordado nesta seção, será deixado para a seção de concorrência.

if else

if else tem no máximo duas ramificações de julgamento, o formato da instrução é o seguinte

if expression {

}

Ou

if expression {

}else {

}

expression deve ser uma expressão booleana, ou seja, o resultado deve ser verdadeiro ou falso, deve ser um valor booleano, exemplo abaixo

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

Você também pode escrever a expressão de forma mais complexa, quando necessário, para melhorar a legibilidade, deve-se usar parênteses para indicar explicitamente quem deve ser calculado primeiro.

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

Ao mesmo tempo, a instrução if também pode conter algumas instruções simples, por exemplo

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

else if

A instrução else if pode criar mais ramificações de julgamento com base no if else, o formato da instrução é o seguinte

if expression1 {

}else if expression2 {

}else if expression3 {

}else {

}

Durante a execução, o julgamento de cada expressão é da esquerda para a direita, e o julgamento de toda a instrução if é de cima para baixo. Um exemplo de atribuição de notas baseado em pontuação é mostrado abaixo, primeira forma de escrever

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

A segunda forma de escrever aproveita a premissa de que a instrução if julga de cima para baixo, então o código é mais 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

A instrução switch também é uma instrução de julgamento de múltiplas ramificações, o formato da instrução é o seguinte

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

Um exemplo simples é mostrado abaixo

func main() {
   str := "a"
   switch str {
   case "a":
      str += "a"
      str += "c"
   case "b":
      str += "bb"
      str += "aaaa"
   default: // Quando todos os cases não correspondem, executa o ramo default
      str += "CCCC"
   }
   fmt.Println(str)
}

Você também pode escrever algumas instruções simples antes da expressão, como declarar novas variáveis

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
}

A instrução switch também pode não ter expressão na 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)
}

Através da palavra-chave fallthrough você pode continuar executando o próximo ramo adjacente.

func main() {
   num := 2
   switch {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
      fallthrough // Após executar este ramo, continuará executando o próximo ramo
   case num < 0:
      num += num
   }
   fmt.Println(num)
}

label

Instrução de rótulo, marca um bloco de código, pode ser o alvo de goto, break, continue. Exemplo abaixo

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

Usar rótulos puramente não tem nenhum significado, precisa ser combinado com outras palavras-chave para ser usado.

goto

goto transfere o controle para a instrução do rótulo correspondente na mesma função, exemplo abaixo

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

Na prática, goto é usado raramente, pular para lá e para cá reduz muito a legibilidade do código, o consumo de desempenho também é um problema.