Rango (Range) en Go

En Go, la palabra clave `range` se usa en los bucles `for` para iterar sobre los elementos de arrays, slices, canales o mapas. En los arrays y slices devuelve el índice del elemento y el valor correspondiente al índice; en los mapas devuelve el par clave-valor.

El formato `range` en el bucle `for` puede iterar sobre slices, mapas, arrays, cadenas, etc. El formato es el siguiente:

for key, value := range oldMap {
    newMap[key] = value
}

En el código anterior, `key` y `value` se pueden omitir.

Si solo se desea leer `key`, el formato es el siguiente:

for key := range oldMap

O de esta manera:

for key, _ := range oldMap

Si solo se desea leer `value`, el formato es el siguiente:

for _, value := range oldMap

Ejemplo

Arrays y slices

Al iterar sobre un slice simple,2**%del resultado son las potencias de 2 correspondientes:

Ejemplo

package main

import "fmt"

// Declarar un slice que contiene potencias de 2
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
   // Iterar sobre el slice `pow`, i es el índice, v es el valor
   for i, v := range pow {
      // Imprimir 2 elevado a i es igual a v
      fmt.Printf("2**%d = %d\n", i, v)
   }
}

La salida de la ejecución del ejemplo anterior es:

2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32
2**6 = 64
2**7 = 128

Strings

Cuando `range` itera sobre una cadena, devuelve el índice de cada carácter y su punto de código Unicode (rune).

Ejemplo

package main

import "fmt"

func main() {
    for i, c := range "hello" {
        fmt.Printf("index: %d, char: %c\n", i, c)
    }
}

La salida de la ejecución del ejemplo anterior es:

index: 0, char: h
index: 1, char: e
index: 2, char: l
index: 3, char: l
index: 4, char: o

Mapas (Map)

El formato `range` del bucle `for` puede omitir `key` y `value`, como en el siguiente ejemplo:

Ejemplo

package main

import "fmt"

func main() {
    // Crear un map vacío, key es de tipo int, value es de tipo float32
    map1 := make(map[int]float32)
   
    // Agregar pares clave-valor a map1
    map1[1] = 1.0
    map1[2] = 2.0
    map1[3] = 3.0
    map1[4] = 4.0
   
    // Iterar sobre map1, leer key y value
    for key, value := range map1 {
        // Imprimir key y value
        fmt.Printf("key is: %d - value is: %f\n", key, value)
    }

    // Iterar sobre map1, solo leer key
    for key := range map1 {
        // Imprimir key
        fmt.Printf("key is: %d\n", key)
    }

    // Iterar sobre map1, solo leer value
    for _, value := range map1 {
        // Imprimir value
        fmt.Printf("value is: %f\n", value)
    }
}

La salida de la ejecución del ejemplo anterior es:

key is: 4 - value is: 4.000000
key is: 1 - value is: 1.000000
key is: 2 - value is: 2.000000
key is: 3 - value is: 3.000000
key is: 1
key is: 2
key is: 3
key is: 4
value is: 1.000000
value is: 2.000000
value is: 3.000000
value is: 4.000000

Canales (Channel)

`range` itera sobre los valores recibidos del canal, hasta que el canal se cierra.

Ejemplo

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    close(ch)
   
    for v := range ch {
        fmt.Println(v)
    }
}

La salida de la ejecución del ejemplo anterior es:

1
2

Ignorar valores

Al iterar, se puede usar_para ignorar el índice o el valor.

Ejemplo

package main

import "fmt"

func main() {
    nums := []int{2, 3, 4}
   
    // Ignorar el índice
    for _, num := range nums {
        fmt.Println("value:", num)
    }
   
    // Ignorar el valor
    for i := range nums {
        fmt.Println("index:", i)
    }
}

La salida de la ejecución del ejemplo anterior es:

value: 2
value: 3
value: 4
index: 0
index: 1
index: 2

Otros

`range` itera sobre otras estructuras de datos:

Ejemplo

package main
import "fmt"
func main() {
    // Así usamos range para calcular la suma de un slice. Con un array es muy similar
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    // Al usar range en un array, se pasan dos variables: índice y valor. En el ejemplo anterior no necesitábamos el número de orden del elemento, por lo que usamos el identificador en blanco "_" para omitirlo. A veces sí necesitamos conocer su índice.
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    // range también se puede usar en los pares clave-valor de un map.
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // range también se puede usar para enumerar cadenas Unicode. El primer parámetro es el índice del carácter, el segundo es el propio carácter (su valor Unicode).
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

La salida de la ejecución del ejemplo anterior es:

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
Otras extensiones