log, regexp & text/template

El procesamiento de texto en producción Go abarca logs, coincidencia de patrones y salida renderizada.

log/slog estructura eventos para pipelines de observabilidad.

regexp extrae y valida texto con un rendimiento predecible.

text/template y html/template generan correos electrónicos, CLIs y HTML sin errores de concatenación de cadenas.

Resumen

Migra nuevos servicios a slog con manejadores JSON y filtros de nivel.

Mantén el paquete log solo donde el costo de migración supere el beneficio.

Precompila expresiones regulares al inicializar el paquete o al inicio, no por solicitud.

Elige html/template siempre que la salida llegue a los navegadores para obtener auto-escapado contextual.

Receta

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

import (
    "log/slog"
    "os"
    "regexp"
    "text/template"
)
 
// Establece el logger por defecto de slog para usar JSON y escribir en stdout.
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
 
// Compila una expresión regular para UUIDs una vez al inicio del paquete.
var reUUID = regexp.MustCompile(`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`)
 
// Parsea una plantilla de correo electrónico una vez al inicio del paquete.
tmpl := template.Must(template.New("mail").Parse("Hello {{.Name}}\n"))

Cuándo usar esto:

• Emitir logs estructurados con niveles y atributos para Loki, Elasticsearch o CloudWatch.
• Analizar líneas de log, validar identificadores o reescribir texto de configuración.
• Generar informes, manifiestos estilo Helm o cuerpos de correo electrónico a partir de estructuras de datos.
• Escapar contenido de usuario en respuestas HTML con html/template.

Ejemplo de Trabajo

package main
 
import (
    "bytes"
    "errors"
    "html/template"
    "log/slog"
    "os"
    "regexp"
    "text/template"
)
 
// User representa un usuario con nombre y correo electrónico.
type User struct {
    Name  string
    Email string
}
 
// Compila una expresión regular para validar correos electrónicos.
var emailRe = regexp.MustCompile(`^[^@\s]+@[^@\s]+\.[^@\s]+$`)
 
// validateAndRender valida el correo electrónico de un usuario y renderiza un saludo.
func validateAndRender(u User) (string, error) {
    // Valida el formato del correo electrónico.
    if !emailRe.MatchString(u.Email) {
        return "", ErrInvalidEmail
    }
 
    // Registra un evento informativo con atributos del usuario.
    slog.Info("render welcome",
        slog.String("user", u.Name),
        slog.String("email", u.Email),
    )
 
    // Crea y ejecuta una plantilla de texto.
    textT := template.Must(template.New("text").Parse("Welcome {{.Name}} <{{.Email}}>"))
    var textBuf bytes.Buffer
    if err := textT.Execute(&textBuf, u); err != nil {
        return "", err
    }
 
    // Crea y ejecuta una plantilla HTML.
    htmlT := template.Must(template.New("html").Parse(`<p>Welcome <b>{{.Name}}</b></p>`))
    var htmlBuf bytes.Buffer
    if err := htmlT.Execute(&htmlBuf, u); err != nil {
        return "", err
    }
 
    // Devuelve el resultado de la plantilla HTML.
    return htmlBuf.String(), nil
}
 
// ErrInvalidEmail es un error para correos electrónicos no válidos.
var ErrInvalidEmail = errors.New("invalid email")
 
func main() {
    // Configura el manejador de texto de slog para registrar solo mensajes de nivel INFO o superior.
    slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})))
 
    // Valida y renderiza un usuario.
    out, err := validateAndRender(User{Name: "Ada", Email: "ada@example.com"})
    if err != nil {
        panic(err)
    }
    // Imprime la salida renderizada.
    println(out)
}

Lo que esto demuestra:

• Expresión regular compilada reutilizada en varias llamadas.
• slog.Info con atributos tipados.
• Pipelines paralelos de text/template y html/template a partir de una misma estructura.
• template.Must para fallos en tiempo de análisis al inicio, cuando se mueve a init.

Inmersión Profunda

Cómo Funciona

• slog enruta los registros a través de un Handler (JSONHandler, TextHandler o personalizado) con filtrado por nivel.
• regexp compila patrones en autómatas con sintaxis RE2 (sin retroreferencias).
• Las plantillas se ejecutan contra valores de Go usando {{.Field}} y acciones como range y if.
• html/template aplica reglas de escapado contextual por cada contexto HTML, JS, URL y CSS.

Comparación de Logging

Notas de Go

// Adjunta el ID de solicitud a través de los manejadores:
logger := slog.With(slog.String("request_id", id))
logger.Info("handled", slog.Int("status", 200))
 
// Subcoincidencias de Regex:
parts := re.FindStringSubmatch(line)
 
// Mapa de funciones de plantilla:
tmpl.Funcs(template.FuncMap{"upper": strings.ToUpper})

Trampas Comunes

• Compilar regex por solicitud - Picos de CPU bajo tráfico. Solución: regexp.MustCompile al inicio o usar sync.Once.
• Usar text/template para páginas HTML - XSS cuando los nombres de usuario contienen <script>. Solución: html/template para salida en el navegador.
• Registrar campos sensibles - PII y tokens en logs JSON violan el cumplimiento. Solución: redactar atributos; usar listas de permitidos.
• Default de slog global no establecido - Las bibliotecas registran en un manejador descartado. Solución: slog.SetDefault temprano en main; aceptar *slog.Logger en paquetes.
• Regex complejo para análisis HTML - Frágil y lento comparado con analizadores. Solución: usar encoding/json, el tokenizador html o analizadores adecuados.
• Desreferencia de puntero nulo en plantilla - Execute entra en pánico en campos faltantes. Solución: usar {{if .Optional}} o comprobaciones de punteros en estructuras de datos.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de la Biblioteca Estándar - fmt y conceptos básicos de cadenas antes de las plantillas
• os, io, bufio & path/filepath - Lectura de archivos de plantilla desde disco
• La Biblioteca Estándar de Go: Baterías Incluidas - slog como ruta moderna de la biblioteca estándar
• Paquetes runtime, debug & pprof - Correlación de logs con perfiles
• Mejores Prácticas de la Biblioteca Estándar - Disciplina de logging y regex

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