Contrôle de condition en Go

Il existe trois types d'instructions de contrôle de condition en Go : if, switch, select. select est relativement spécial par rapport aux deux autres et ne sera pas expliqué dans cette section, il sera présenté dans la section sur la concurrence.

if else

if else a au plus deux branches de jugement, le format de l'instruction est le suivant :

if expression {

}

if expression {

}else {

}

expression doit être une expression booléenne, c'est-à-dire que le résultat est soit vrai soit faux, doit être une valeur booléenne. Exemple :

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

Vous pouvez également rendre l'expression plus complexe. Si nécessaire, pour améliorer la lisibilité, vous devez utiliser des parenthèses pour indiquer explicitement ce qui doit être calculé en premier.

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

L'instruction if peut également contenir des instructions simples, par exemple :

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

else if

L'instruction else if permet de créer plus de branches de jugement sur la base de if else, le format de l'instruction est le suivant :

if expression1 {

}else if expression2 {

}else if expression3 {

}else {

}

Pendant l'exécution, le jugement de chaque expression se fait de gauche à droite, et le jugement de toute l'instruction if se fait de haut en bas. Voici un exemple de notation basé sur le score, première méthode :

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 deuxième méthode utilise l'hypothèse que l'instruction if est jugée de haut en bas, donc le code est plus concis.

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'instruction switch est également une instruction de jugement à plusieurs branches, le format de l'instruction est le suivant :

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

Un exemple simple est le suivant :

func main() {
   str := "a"
   switch str {
   case "a":
      str += "a"
      str += "c"
   case "b":
      str += "bb"
      str += "aaaa"
   default: // Lorsque aucun case ne correspond, la branche default est exécutée
      str += "CCCC"
   }
   fmt.Println(str)
}

Vous pouvez également écrire des instructions simples avant l'expression, comme déclarer de nouvelles variables :

func main() {
  switch num := f(); { // Équivalent à 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'instruction switch peut également ne pas avoir d'expression d'entrée.

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

Utilisez le mot-clé fallthrough pour continuer à exécuter la branche suivante adjacente.

func main() {
   num := 2
   switch {
   case num >= 0 && num <= 1:
      num++
   case num > 1:
      num--
      fallthrough // Après l'exécution de cette branche, la branche suivante sera exécutée
   case num < 0:
      num += num
   }
   fmt.Println(num)
}

label

Instruction d'étiquette, étiquette un bloc de code, peut être la cible de goto, break, continue. Exemple :

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

L'utilisation simple d'étiquettes n'a aucun sens, elle doit être utilisée avec d'autres mots-clés.

goto

goto transfère le contrôle à l'instruction de l'étiquette correspondante dans la même fonction, exemple :

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

Dans les applications pratiques, goto est rarement utilisé, car sauter d'un endroit à l'autre réduit considérablement la lisibilité du code, et la consommation de performances est également un problème.

Contrôle de condition en Go ​

if else ​

else if ​

switch ​

label ​