Go-Bedingte Steuerung

In Go gibt es drei bedingte Steuerungsanweisungen: if, switch, select. select ist im Vergleich zu den beiden anderen spezieller und wird in diesem Abschnitt nicht behandelt, sondern erst im Abschnitt über Nebenläufigkeit erläutert.

if else

if else hat höchstens zwei Verzweigungen. Das Anweisungsformat lautet wie folgt:

if expression {

}

oder

if expression {

}else {

}

expression muss ein boolescher Ausdruck sein, d. h. das Ergebnis ist entweder wahr oder falsch, muss ein boolescher Wert sein. Beispiel:

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

Der Ausdruck kann auch komplexer gestaltet werden. Bei Bedarf sollten zur Verbesserung der Lesbarkeit Klammern verwendet werden, um explizit anzugeben, was zuerst berechnet werden soll.

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

Die if-Anweisung kann auch einige einfache Anweisungen enthalten, zum Beispiel:

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

else if

Die else if-Anweisung kann auf Basis von if else mehr Verzweigungen erstellen. Das Anweisungsformat lautet wie folgt:

if expression1 {

}else if expression2 {

}else if expression3 {

}else {

}

Während der Ausführung wird jeder Ausdruck von links nach rechts bewertet, und die gesamte if-Anweisung wird von oben nach unten bewertet. Hier ein Beispiel für eine Notenzuweisung. Erste Schreibweise:

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

Die zweite Schreibweise nutzt die Voraussetzung, dass die if-Anweisung von oben nach unten bewertet wird, daher ist der Code prägnanter.

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

Die switch-Anweisung ist ebenfalls eine Mehrfachverzweigungs-Anweisung. Das Anweisungsformat lautet wie folgt:

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

Ein einfaches Beispiel:

func main() {
   str := "a"
   switch str {
   case "a":
      str += "a"
      str += "c"
   case "b":
      str += "bb"
      str += "aaaa"
   default: // Wenn alle case nicht übereinstimmen, wird der default-Zweig ausgeführt
      str += "CCCC"
   }
   fmt.Println(str)
}

Vor dem Ausdruck können auch einige einfache Anweisungen geschrieben werden, z. B. das Deklarieren neuer Variablen:

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

Die switch-Anweisung kann auch keinen Eingabeausdruck haben.

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

Mit dem fallthrough-Schlüsselwort kann der nächste Zweig weiter ausgeführt werden.

func main() {
   num := 2
   switch {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
      fallthrough // Nach Ausführung dieses Zweigs wird der nächste Zweig weiter ausgeführt
   case num < 0:
      num += num
   }
   fmt.Println(num)
}

label

Label-Anweisungen weisen einem Codeblock ein Label zu, das Ziel von goto, break oder continue sein kann. Beispiel:

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

Die alleinige Verwendung von Labels ist bedeutungslos und muss mit anderen Schlüsselwörtern kombiniert werden.

goto

goto übergibt die Kontrolle an die Anweisung mit dem entsprechenden Label in der gleichen Funktion. Beispiel:

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

In praktischen Anwendungen wird goto selten verwendet, da das Hin- und Herspringen die Lesbarkeit des Codes verringert und auch ein Problem des Leistungsverbrauchs darstellt.