package main

import "fmt"

func main() {
     var a[10] int

     for i:= 0; i < 10; i++ {
         a[i] = i + 10
     }  
     for i:=0; i < 10; i++ {
         fmt.Println (i, " -> ", a[i])
     }
     fmt.Println ("---------------------------------")
     i := 10
     for i > 0 {
         i--
         fmt.Print (i, " -> ", a[i])
         if (i > 4) {
             fmt.Println ();
             continue;
         }
     fmt.Println (" **");
     if (i == 1) {break}
     }

     fmt.Println ("---------------------------------")
     for i,e := range a {
         fmt.Println (i, " -> ", e)
     }

     fmt.Println ("---------------------------------")
     for _,e := range a {
         fmt.Print (e, " ")
     }
     fmt.Println ();
}

El lenguaje Go ofrece únicamente bucles for, pero con una sintaxis muy flexible. En su forma normal, los bucles for de Go están compuestos por las tres secciones a las que estamos acostumbrados, separadas por comas: inicialización, condición del bucle, operación antes de la iteración.

La segunda forma de los bucles for en Go nos permiten utilizarlos como bucles while. En esta forma tras la palabra clave for, añadimos nuestra condición de bucle.

Finalmente, for puede utilizarse de forma similar a la palabra clave foreach que encontramos en otros lenguajes. Esta forma nos permite iterar fácilmente matrices, cadenas y otras estructuras como maps o slices.

Esto se consigue añadiendo la palabra clave range antes de la estructura sobre la que queremos iterar. range devolverá uno a uno los índices y los valores de la estructura que sigue, normalmente un array/slice o un map (tabla hash). En este último caso, en lugar de el índice de cada elemento, nos devolverá la clave asociada al elemento. El valor del elemento retornado por range es opcional y podemos ignorarlo si así lo deseamos. Los dos bucles del siguiente ejemplo producen la misma salida:

    tabla := map[string]int{"primero": 1, "segundo": 2}
    for k,v := range tabla {
            fmt.Println (k,v)
    }
    for k := range tabla {
            fmt.Println (k,tabla[k])
    }

Esta forma nos devolverá, en cada iteración varios valores que dependerán del tipo de estructura que estemos recorriendo. Por ejemplo, para una matriz, obtendremos el índice y el valor. En caso de no necesitemos alguno de esos elementos, podemos utilizar el caracter _ para indicar esta situación

Podemos escribir bucles infinitos en go simplemente usando for a secas:

for {
  // Esto se repite para siempre
} 

Go también ofrece las palabras clave continue y break con la función habitual.

Resumen

• Go nos ofrece bucles for pero con una sintaxis flexible que los permite utilizar como bucles while y foreach.
• Go ofrece las palabras clave continue y break para controlar el flujo de ejecución del bucle.