Aprender Go Novedades Go 1.21–1.24

Go sigue un ciclo de lanzamiento semestral con dos versiones mayores al año. Las versiones 1.21 a 1.24 han introducido capacidades significativas que modernizan el lenguaje sin romper la compatibilidad.

Go 1.21 (agosto 2023)

Nuevas funciones built-in: min, max y clear

a, b := 3, 7
fmt.Println(min(a, b))   // 3
fmt.Println(max(a, b))   // 7

m := map[string]int{"a": 1, "b": 2}
clear(m) // limpia el mapa o pone a cero los elementos de un slice

Paquete slices (golang.org/x/exp → stdlib)

import "slices"

nums := []int{5, 1, 3, 2, 4}
slices.Sort(nums)                          // ordena in-place
idx, _ := slices.BinarySearch(nums, 3)    // búsqueda binaria
fmt.Println(slices.Contains(nums, 3))      // true
fmt.Println(slices.Max(nums))              // 5
nums2 := slices.Clone(nums)                // copia superficial
slices.Reverse(nums2)                      // invierte in-place

Paquete maps

import "maps"

m1 := map[string]int{"a": 1, "b": 2}
m2 := maps.Clone(m1)         // copia del mapa
maps.DeleteFunc(m2, func(k string, v int) bool {
    return v > 1             // elimina entradas donde v > 1
})

Paquete log/slog: logging estructurado

slog es el nuevo paquete de logging estructurado incorporado en la biblioteca estándar:

import "log/slog"

// Logger por defecto
slog.Info("servidor iniciado", "puerto", 8080)
slog.Warn("alta latencia", "ms", 350, "ruta", "/api/usuarios")
slog.Error("error de base de datos", "err", err)

// Logger JSON personalizado
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: slog.LevelDebug,
}))
logger.Info("petición recibida",
    slog.String("método", "GET"),
    slog.String("ruta", "/productos"),
    slog.Int("status", 200),
)

Salida JSON:

{"time":"2026-03-30T10:00:00Z","level":"INFO","msg":"petición recibida","método":"GET","ruta":"/productos","status":200}

Toolchain gestionado con go.toolchain

Go 1.21 introdujo toolchain en go.mod para especificar la versión exacta del compilador:

go 1.21.0
toolchain go1.21.3

Go 1.22 (febrero 2024)

Variables de bucle por iteración

Uno de los bugs históricos de Go quedó resuelto: cada iteración de un bucle for crea ahora una nueva variable, eliminando el problema de captura de clausuras:

// Antes de 1.22: todas las goroutines imprimían el mismo valor
// Desde 1.22: cada goroutine captura su propia copia de i
for i := range 5 {
    go func() {
        fmt.Println(i) // correcto: 0, 1, 2, 3, 4
    }()
}

for range sobre enteros

for i := range 10 {
    fmt.Print(i, " ") // 0 1 2 3 4 5 6 7 8 9
}

Paquete math/rand/v2

Nueva versión del generador de números aleatorios con mejor API y algoritmos más modernos (ChaCha8, PCG):

import "math/rand/v2"

n := rand.IntN(100)    // entero aleatorio en [0, 100)
f := rand.Float64()    // flotante en [0.0, 1.0)

Go 1.23 (agosto 2024)

Iteradores: range-over-func

Go 1.23 estabilizó los iteradores genéricos usando funciones como iter.Seq e iter.Seq2:

import "iter"

// Función que produce una secuencia
func fibonacci() iter.Seq[int] {
    return func(yield func(int) bool) {
        a, b := 0, 1
        for {
            if !yield(a) {
                return
            }
            a, b = b, a+b
        }
    }
}

// Consumir con for range
for n := range fibonacci() {
    if n > 100 {
        break
    }
    fmt.Print(n, " ")
}

Paquete iter

import "iter"

// iter.Seq[V] — secuencia de valores
// iter.Seq2[K, V] — secuencia de pares clave/valor

// Los paquetes slices y maps exponen iteradores:
for i, v := range slices.All(nums) {
    fmt.Println(i, v)
}
for k, v := range maps.All(m1) {
    fmt.Println(k, v)
}

Mejoras en time.Timer y time.Ticker

Los timers y tickers tienen ahora una semántica más predecible con respecto a la cancelación de canales, eliminando condiciones de carrera comunes.

Go 1.24 (febrero 2025)

go tool unificado

Go 1.24 introduce herramientas de desarrollo gestionadas directamente en go.mod:

go get -tool golang.org/x/tools/cmd/stringer
go tool stringer -type=Direccion

Weak pointers (weak package)

El nuevo paquete weak proporciona punteros débiles para implementar caches sin impedir la recolección de basura:

import "weak"

ptr := weak.Make(&objeto)
if valor := ptr.Value(); valor != nil {
    // El objeto sigue vivo
    fmt.Println(valor)
}

sync.Map mejorado

sync.Map recibió mejoras de rendimiento significativas para cargas de trabajo con muchas lecturas concurrentes.

Pruebas: testing/synctest

Nuevo paquete experimental para pruebas de código concurrente con control determinista del tiempo:

import "testing/synctest"

func TestOperacionAsincrona(t *testing.T) {
    synctest.Run(func() {
        // Control preciso del tiempo para probar timeouts, etc.
    })
}

Resumen de compatibilidad

| Versión | Fecha | Destacado | |---------|-------|-----------| | Go 1.21 | Ago 2023 | slices, maps, slog, min/max/clear | | Go 1.22 | Feb 2024 | Variables de bucle por iteración, for range N, math/rand/v2 | | Go 1.23 | Ago 2024 | Iteradores range-over-func, paquete iter | | Go 1.24 | Feb 2025 | go tool, weak pointers, mejoras sync.Map |

Go mantiene su promesa de compatibilidad hacia atrás: el código escrito para Go 1.0 sigue compilando con Go 1.24.