Controllo condizionale Go

In Go ci sono tre tipi di istruzioni di controllo condizionale: if, switch, select. select è relativamente speciale rispetto agli altri due, non verrà spiegato in questa sezione, ma verrà introdotto nella sezione sulla concorrenza.

if else

if else ha al massimo due rami di valutazione, il formato dell'istruzione è il seguente

if expression {

}

Oppure

if expression {

}else {

}

expression deve essere un'espressione booleana, ovvero il risultato deve essere vero o falso, deve essere un valore booleano. Ecco un esempio:

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

Puoi anche rendere l'espressione più complessa. Se necessario, per migliorare la leggibilità, dovresti utilizzare le parentesi per indicare esplicitamente quale parte deve essere calcolata per prima.

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

Allo stesso tempo, l'istruzione if può anche contenere alcune istruzioni semplici, ad esempio:

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

else if

L'istruzione else if può creare più rami di valutazione sulla base di if else, il formato dell'istruzione è il seguente:

if expression1 {

}else if expression2 {

}else if expression3 {

}else {

}

Durante l'esecuzione, la valutazione di ogni espressione avviene da sinistra a destra, mentre la valutazione dell'intera istruzione if avviene dall'alto verso il basso. Ecco un esempio di valutazione in base al punteggio. Prima modalità di scrittura

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 seconda modalità di scrittura sfrutta la premessa che l'istruzione if viene valutata dall'alto verso il basso, quindi il codice è più 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

L'istruzione switch è anche un'istruzione di valutazione a più rami, il formato dell'istruzione è il seguente:

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

Un esempio semplice è il seguente

func main() {
   str := "a"
   switch str {
   case "a":
      str += "a"
      str += "c"
   case "b":
      str += "bb"
      str += "aaaa"
   default: // Quando nessun case corrisponde, viene eseguito il ramo default
      str += "CCCC"
   }
   fmt.Println(str)
}

Puoi anche scrivere alcune istruzioni semplici prima dell'espressione, ad esempio dichiarare nuove variabili

func main() {
  switch num := f(); { // Equivale 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
}

L'istruzione switch può anche non avere un'espressione di ingresso.

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

Utilizzando la parola chiave fallthrough per continuare a eseguire il ramo successivo adiacente.

func main() {
   num := 2
   switch {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
      fallthrough // Dopo aver eseguito questo ramo, continua a eseguire il ramo successivo
   case num < 0:
      num += num
   }
   fmt.Println(num)
}

label

Istruzione di etichetta, assegna un'etichetta a un blocco di codice, che può essere l'obiettivo di goto, break, continue. Ecco un esempio:

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

L'uso semplice delle etichette non ha alcun significato, deve essere combinato con altre parole chiave per essere utilizzato.

goto

goto trasferisce il controllo all'istruzione con l'etichetta corrispondente nella stessa funzione, ecco un esempio:

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

Nelle applicazioni pratiche, goto viene utilizzato raramente, saltare da una parte all'altra riduce notevolmente la leggibilità del codice e il consumo di prestazioni è anche un problema.