Variantes del bucle for y semántica de range

Go expresa cada bucle con for, pero la forma que elijas cambia lo que copias, lo que puedes mutar y cuándo se detiene el bucle.

Esta página mapea cada variante de for a las colecciones y canales que verás en el código de producción.

Resumen

La cabecera for de tres partes cubre los bucles contados.

La forma solo con condición actúa como while.

for range recorre slices, arrays, mapas, canales y cadenas con un significado de índice/valor específico del tipo.

Los canales se bloquean hasta que llega un valor o el canal se cierra.

Los mapas iteran en orden aleatorio.

Las cadenas devuelven desplazamientos de bytes y runes, no bytes directamente.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

package main
 
import "fmt"
 
func main() {
    // Estilo C
    for i := 0; i < 3; i++ {
        fmt.Println("count", i)
    }
 
    // Estilo while
    n := 3
    for n > 0 {
        n--
    }
 
    // range slice
    for i, v := range []int{10, 20} {
        fmt.Println(i, v)
    }
}

Cuándo usar esto:

• Usa for de tres partes cuando necesites un contador de índice con una condición final clara.
• Usa for solo con condición para bucles de eventos, reintentos y bombas de canal (for { select { ... } }).
• Usa for range para iteración idiomática sobre colecciones y canales abiertos.
• Usa for range en lugar de alternativas 1..n a través de slices o for i := 0; i < n; i++ - Go no tiene un operador de rango inclusivo.

Ejemplo de Trabajo

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    // Slice: mutar por índice
    nums := []int{1, 2, 3}
    for i := range nums {
        nums[i] *= 2
    }
    fmt.Println("slice", nums)
 
    // Map: claves y valores (el orden varía en cada ejecución)
    m := map[string]int{"a": 1, "b": 2}
    for k, v := range m {
        fmt.Println("map", k, v)
    }
 
    // Channel: recibir hasta que se cierre
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    close(ch)
    for v := range ch {
        fmt.Println("chan", v)
    }
 
    // String: índice de bytes y rune
    for i, r := range "Go🙂" {
        fmt.Printf("string i=%d r=%U\n", i, r)
    }
 
    // Bucle infinito con interrupción por tiempo límite
    deadline := time.Now().Add(50 * time.Millisecond)
    for {
        if time.Now().After(deadline) {
            break
        }
    }
    fmt.Println("done")
}

Lo que esto demuestra:

• La mutación de slices requiere acceso por índice, no la copia del valor de range.
• El orden de iteración de los mapas no es estable - nunca dependas de él.
• for range en un canal termina cuando el canal se cierra y se vacían los valores.
• range de cadenas decodifica runes UTF-8; el índice salta por el ancho de bytes para caracteres multibyte.
• Los bucles infinitos solo con condición se emparejan con break, return, o select.

Análisis Profundo

Cómo Funciona

• for crea un ámbito de bloque; la variable de inicialización en un bucle de tres partes tiene el ámbito de la sentencia for.
• range evalúa la colección una vez; para arrays/slices copia la cabecera, no los elementos del array subyacente.
• La recepción de canal en for range se bloquea hasta que un valor está listo; el patrón de valor cero más ok es implícito en la forma range.
• Los iteradores de mapas eligen cubos de inicio aleatorios - el orden difiere entre procesos y ejecuciones por diseño.
• range de cadenas convierte bytes a runes; len(s) es la longitud en bytes, que difiere del recuento de runes.

range por Tipo

Formas del bucle for

Notas de Go

// Omite el valor o el índice con el identificador en blanco
for _, v := range items { _ = v }
for i := range items { _ = i }
 
// range sobre array copia elementos para la forma de valor en arrays grandes - usa índice
var big [10000]byte
for i := range big {
    big[i] = 1
}

Trampas

• Mutar elementos de slice a través del valor de range - for _, v := range s { v = 1 } actualiza una copia. Solución: usa el índice: for i := range s { s[i] = 1 }.
• Depender del orden de iteración de los mapas - Las pruebas que asumen el orden de las claves fallan. Solución: ordena las claves primero o compara multiconjuntos.
• Iterar un canal abierto para siempre - Sin cerrar, for range ch se bloquea para siempre. Solución: cierra desde el lado del remitente o usa select con ctx.Done().
• Confundir la longitud de la cadena con el recuento de runes - len("é") son 2 bytes en UTF-8. Solución: usa range o utf8.RuneCountInString.
• Copias de range de arrays grandes - Iterar sobre el valor del array copia cada elemento. Solución: itera índices en arrays o usa slices.
• Desfase de uno en bucles de tres partes - Usar <= cuando se pretendía <. Solución: prefiere los modismos for i := 0; i < len(s); i++.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Flujo de Control - fragmentos introductorios para for y range
• break, continue y Flujo de Control Etiquetado - salir de bucles anidados
• Trampas de Reutilización de Variables de Range - captura de cierre en bucles
• Flujo de Control en Go: Diseño Orientado a Expresiones - descripción general conceptual
• Arrays, Slices y Mapas de un Vistazo - tipos de colecciones iterados aquí

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación), y golangci-lint (última - verificar conjunto de linters en la compilación).