Paquetes slices, maps, slog y funciones built-in

Funciones built-in: min, max y clear

Go incluye tres funciones built-in que simplifican operaciones frecuentes sobre valores y colecciones:

min y max aceptan dos o más argumentos de cualquier tipo comparable (enteros, flotantes, strings) y devuelven el menor o mayor respectivamente:

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

// Con múltiples argumentos
fmt.Println(min(5, 2, 8, 1, 9))  // 1
fmt.Println(max(5, 2, 8, 1, 9))  // 9

// Funciona con strings (comparación lexicográfica)
fmt.Println(min("banana", "apple", "cherry"))  // apple

clear reinicia el contenido de un slice o mapa. En slices, establece todos los elementos a su valor cero manteniendo la longitud y capacidad. En mapas, elimina todos los pares clave-valor:

nums := []int{1, 2, 3, 4, 5}
clear(nums)  // [0 0 0 0 0], len y cap se mantienen

m := map[string]int{"a": 1, "b": 2}
clear(m)     // map[], len = 0

Estas funciones están disponibles sin necesidad de importar ningún paquete. Sustituyen patrones manuales que antes requerían bucles o funciones auxiliares.

El paquete slices

El paquete slices de la biblioteca estándar proporciona funciones genéricas para las operaciones más comunes sobre slices. Utilizar este paquete evita reimplementar lógica de búsqueda, ordenación y transformación.

Ordenación

import "slices"

numeros := []int{5, 3, 1, 4, 2}

// Ordenar in-place
slices.Sort(numeros)  // [1 2 3 4 5]

// Ordenar con función personalizada
slices.SortFunc(numeros, func(a, b int) int {
    return b - a  // orden descendente
})

Búsqueda

// Búsqueda lineal
fmt.Println(slices.Contains(numeros, 3))  // true
fmt.Println(slices.Index(numeros, 3))     // índice o -1

// Búsqueda binaria (requiere slice ordenado)
idx, encontrado := slices.BinarySearch(numeros, 3)

// Máximo y mínimo
fmt.Println(slices.Max(numeros))  // 5
fmt.Println(slices.Min(numeros))  // 1

Manipulación y transformación

// Clonar
copia := slices.Clone(numeros)

// Invertir
slices.Reverse(copia)

// Eliminar duplicados consecutivos (requiere slice ordenado)
datos := []int{1, 1, 2, 3, 3, 3, 4}
slices.Sort(datos)
datos = slices.Compact(datos)  // [1 2 3 4]

// Eliminar elementos que cumplan una condición
impares := slices.DeleteFunc(slices.Clone(numeros), func(n int) bool {
    return n%2 == 0  // eliminar pares
})

// Comparación
fmt.Println(slices.Equal([]int{1, 2, 3}, []int{1, 2, 3}))  // true

El paquete maps

El paquete maps complementa a slices con operaciones genéricas sobre mapas:

import "maps"

catalogo := map[string]float64{
    "teclado": 59.99,
    "ratón":   25.50,
    "monitor": 320.00,
}

// Clonar un mapa
copia := maps.Clone(catalogo)

// Eliminar entradas que cumplen una condición
maps.DeleteFunc(copia, func(k string, v float64) bool {
    return v > 100  // eliminar productos caros
})
fmt.Println(copia)  // map[teclado:59.99 ratón:25.5]

// Copiar todas las entradas de un mapa a otro
destino := map[string]float64{"auriculares": 45.00}
maps.Copy(destino, catalogo)

// Comprobar igualdad
fmt.Println(maps.Equal(catalogo, maps.Clone(catalogo)))  // true

Iterar con maps.Keys y maps.Values

// Obtener todas las claves
for clave := range maps.Keys(catalogo) {
    fmt.Println(clave)
}

// Obtener todos los valores
for valor := range maps.Values(catalogo) {
    fmt.Println(valor)
}

Logging estructurado: log/slog

El paquete log/slog es el estándar de logging en Go, con salida estructurada en pares clave-valor que se integra con sistemas de observabilidad como Grafana, Datadog o ELK.

Uso básico

import "log/slog"

slog.Info("servidor iniciado", "host", "localhost", "puerto", 8080)
slog.Debug("petición recibida", "método", "GET", "ruta", "/api/usuarios")
slog.Warn("alta latencia detectada", "ms", 350, "umbral", 200)
slog.Error("error de base de datos", "err", err, "tabla", "usuarios")

Salida en formato texto:

2026/03/30 10:00:00 INFO servidor iniciado host=localhost puerto=8080
2026/03/30 10:00:01 WARN alta latencia detectada ms=350 umbral=200

Logger con formato JSON

Para entornos de producción, el formato JSON facilita el procesamiento automatizado de logs:

logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level:     slog.LevelDebug,
    AddSource: true,
}))

logger.Info("petición procesada",
    slog.String("método", "POST"),
    slog.String("ruta", "/api/productos"),
    slog.Int("status", 201),
    slog.Duration("duración", 45*time.Millisecond),
)

Logger con contexto compartido

El método With crea un logger derivado que incluye atributos fijos en todos los mensajes:

loggerServicio := logger.With(
    slog.String("servicio", "tienda"),
    slog.String("version", "1.2.3"),
)

loggerServicio.Info("pedido creado",
    slog.Int("pedido_id", 42),
    slog.Float64("total", 129.99),
)

Configurar el logger global

slog.SetDefault(logger)

// Ahora slog.Info(...) usa el logger personalizado
slog.Info("usando el logger configurado")

El paquete log/slog reemplaza al paquete log clásico para aplicaciones que necesitan logging estructurado. Utiliza slog en proyectos nuevos para obtener logs procesables por herramientas de observabilidad.