Contrôle de boucle en Go

En Go, il n'y a qu'un seul type d'instruction de boucle : for. Go a abandonné l'instruction while, l'instruction for peut être utilisée comme while.

for

Le format de l'instruction est le suivant :

for init statement; expression; post statement {
  execute statement
}

Lorsque seule la condition de boucle est conservée, elle devient while.

for expression {
  execute statement
}

Ceci est une boucle infinie qui ne se terminera jamais :

for {
  execute statement
}

Exemple

Voici un code qui affiche les nombres de l'intervalle [0,20] :

for i := 0; i <= 20; i++ {
    fmt.Println(i)
}

Vous pouvez initialiser plusieurs variables simultanément, puis les incrémenter :

for i, j := 1, 2; i < 100 && j < 1000; i, j = i+1, j+1 {
  fmt.Println(i, j)
}

Utilisé comme while :

num := 1
for num < 100 {
    num *= 2
}

Double boucle pour afficher la table de multiplication, un cas classique de boucle :

func main() {
  for i := 1; i <= 9; i++ {
    for j := 1; j <= 9; j++ {
      if i <= j {
        fmt.Printf("%d*%d = %2d  ", i, j, i*j)
      }
    }
    fmt.Println()
  }
}

Sortie :

1*1 =  1  1*2 =  2  1*3 =  3  1*4 =  4  1*5 =  5  1*6 =  6  1*7 =  7  1*8 =  8  1*9 =  9
2*2 =  4  2*3 =  6  2*4 =  8  2*5 = 10  2*6 = 12  2*7 = 14  2*8 = 16  2*9 = 18
3*3 =  9  3*4 = 12  3*5 = 15  3*6 = 18  3*7 = 21  3*8 = 24  3*9 = 27
4*4 = 16  4*5 = 20  4*6 = 24  4*7 = 28  4*8 = 32  4*9 = 36
5*5 = 25  5*6 = 30  5*7 = 35  5*8 = 40  5*9 = 45
6*6 = 36  6*7 = 42  6*8 = 48  6*9 = 54
7*7 = 49  7*8 = 56  7*9 = 63
8*8 = 64  8*9 = 72
9*9 = 81

for range

for range permet de parcourir plus facilement certaines structures de données itérables, telles que les tableaux, les tranches, les chaînes, les maps et les canaux. Le format de l'instruction est le suivant :

for index, value := range iterable {
  // body
}

index est l'index de la structure de données itérable, value est la valeur correspondant à cet index. Par exemple, utiliser for range pour parcourir une chaîne :

func main() {
   sequence := "hello world"
   for index, value := range sequence {
      fmt.Println(index, value)
   }
}

for range peut également itérer sur une valeur entière. Les littéraux, constantes et variables sont tous valides.

for i := range 10 {
    fmt.Println(i)
}

n := 10
for i := range n {
    fmt.Println(i)
}

const n = 10
for i := range n {
  fmt.Println(i)
}

Pour chaque type de structure de données, l'implémentation de for range est différente. Cela sera abordé ultérieurement. Vous pouvez consulter Go - for statement pour plus de détails.

break

Le mot-clé break terminera la boucle for la plus interne. Utilisé avec des étiquettes, il permet de terminer une boucle externe. Voici un exemple : il s'agit d'une double boucle :

func main() {
  for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
      if i <= j {
        break
      }
      fmt.Println(i, j)
    }
  }
}

Sortie :

Utiliser une étiquette pour interrompre la boucle externe :

func main() {
Outer:
  for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
      if i <= j {
        break Outer
      }
      fmt.Println(i, j)
    }
  }
}

Sortie :

continue

Le mot-clé continue saute l'itération actuelle de la boucle la plus interne et passe directement à l'itération suivante. Utilisé avec des étiquettes, il permet de sauter la boucle externe. Voici un exemple :

func main() {
  for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
      if i > j {
        continue
      }
      fmt.Println(i, j)
    }
  }
}

Sortie :

Utiliser une étiquette :

func main() {
Out:
  for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
      if i > j {
        continue Out
      }
            fmt.Println(i, j)
    }
  }
}

Sortie :

Contrôle de boucle en Go ​

for ​

for range ​

break ​

continue ​

Contrôle de boucle en Go

for

for range

break

continue