Saltar al contenido

Lección 6 de 20 · Lectura y práctica

Validación de datos de entrada con structs y tags

Concepto claveLa validación de datos de entrada es el proceso de verificar que la información recibida por una API cumple con reglas específicas antes de procesarla. Imagina un formulario de registro web: sin validación, usuarios.

Del concepto a la práctica

Taller de esta lección

Los tags describen reglas, pero no sustituyen el diseño del modelo. Para registrar una estación de carga, name es obligatorio, connector debe pertenecer a un conjunto y powerKw debe ser mayor que cero. La validación debe ejecutarse antes de guardar.

Ejemplo resuelto

go
type Station struct {
  Name string `json:"name" validate:"required"`
  Connector string `json:"connector" validate:"required,oneof=type2 ccs"`
  PowerKw float64 `json:"powerKw" validate:"gt=0"`
}

El registro {"name":"Norte","connector":"ccs","powerKw":22} cumple las tres reglas; powerKw:0 falla aunque el JSON sea válido.

Pruébalo

  1. Decodifica tres registros, uno correcto y dos incorrectos.

  2. Ejecuta el validador una vez reutilizable.

  3. Convierte cada fallo en un campo y una regla legibles.

  4. Guarda solo el caso válido.

Error frecuente: validar después de insertar. Corrígelo haciendo que el repositorio reciba únicamente estructuras ya validadas.

Comprueba tu resultado

Debe guardarse exactamente una estación. Los casos con conector schuko o potencia 0 deben devolver 400 y no alterar el almacenamiento.

Tags ejecutados y tres entradas completas

Los tags validate no se ejecutan por encoding/json: importa github.com/go-playground/validator/v10 y declara var validate=validator.New() antes de usar validate.Struct. Normaliza Station.Name con strings.TrimSpace para que espacios no pasen required. El tipo correcto se comprueba al decodificar; validate:"number" no convierte automáticamente una cadena JSON en float64.

Tres fixtures: Norte/ccs/22→válido; Sur/schuko/22→connector; Este/type2/0→powerKw. Inicia almacenamiento vacío y guarda solo el primero: longitud1. No supongas que validate.Struct devuelve siempre ValidationErrors: usa errors.As para distinguir InvalidValidationError u otro fallo de configuración antes de acceder a campos. Serializa mensajes públicos por campo/regla, sin devolver valores de contraseñas.

Para el stock histórico, required sobre un int rechaza0 y contradice permitir stock0. Usa gte=0 y, si necesitas distinguir ausente de cero, un *int con required; después valida su valor. Contrato de creación y actualización parcial pueden tener tipos diferentes. El servidor verifica unicidad con escritura atómica o restricción DB, no solo un tag en una consulta anterior. Validator.

Diagrama de decisión con ramas Sí y No y un bucle que procesa cada elemento de una lista.
CursaloMapa de práctica
Cómo avanza un programa

Una condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.

Ver la infografía en tamaño completo ↗

Concepto clave

La validación de datos de entrada es el proceso de verificar que la información recibida por una API cumple con reglas específicas antes de procesarla. Imagina un formulario de registro web: sin validación, usuarios podrían enviar emails inválidos o contraseñas demasiado cortas, causando errores en el sistema. En Go, podemos usar struct tags para definir estas reglas directamente en nuestras estructuras de datos, combinando la definición del modelo con sus restricciones de validación.

Los struct tags son metadatos que agregamos a los campos de una estructura usando backticks. Paquetes como go-playground/validator leen estos tags para aplicar validaciones automáticamente. Esto es más eficiente que validar manualmente cada campo, especialmente en APIs con múltiples endpoints. La validación temprana evita que datos incorrectos fluyan por el sistema, reduciendo bugs y mejorando la seguridad.

Cómo funciona en la práctica

Primero, definimos una estructura que represente los datos de entrada, como un JSON para crear un usuario. Agregamos tags de validación usando el formato validate:"regla". Por ejemplo, Email string `json:"email" validate:"required,email"` indica que el campo email es obligatorio y debe tener formato de email válido.

Luego, en el handler HTTP, usamos el validador para comprobar los datos. Si hay errores, respondemos con un código 400 Bad Request y detalles de los campos inválidos. Esto proporciona feedback claro al cliente. La validación ocurre después de decodificar el JSON pero antes de cualquier lógica de negocio, asegurando que solo procesamos datos correctos.

Codigo en accion

Antes: Validación manual en el handler, propensa a errores y repetitiva.

func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
    var user struct {
        Email    string
        Password string
        Age      int
    }
    json.NewDecoder(r.Body).Decode(&user)
    
    // Validación manual
    if user.Email == "" {
        http.Error(w, "Email es requerido", http.StatusBadRequest)
        return
    }
    if !strings.Contains(user.Email, "@") {
        http.Error(w, "Email inválido", http.StatusBadRequest)
        return
    }
    if len(user.Password) < 8 {
        http.Error(w, "Password debe tener al menos 8 caracteres", http.StatusBadRequest)
        return
    }
    // Más validaciones...
}

Después: Usando struct tags y validador, más limpio y mantenible.

import "github.com/go-playground/validator/v10"

type CreateUserRequest struct {
    Email    string `json:"email" validate:"required,email"`
    Password string `json:"password" validate:"required,min=8"`
    Age      int    `json:"age" validate:"gte=18"`
}

var validate = validator.New()

func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
    var req CreateUserRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "JSON inválido", http.StatusBadRequest)
        return
    }
    
    if err := validate.Struct(req); err != nil {
        errors := err.(validator.ValidationErrors)
        response := map[string]string{
            "error": "Validación fallida",
            "details": errors.Error(),
        }
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(response)
        return
    }
    
    // Procesar usuario válido
    fmt.Fprintf(w, "Usuario creado: %s", req.Email)
}

Errores comunes

  • No validar todos los campos: Olvidar tags en campos opcionales que aún necesitan reglas, como máximo longitud. Solución: Revisar cada campo del struct y asignar tags apropiados.
  • Tags mal escritos: Errores tipográficos en reglas, como min=8 escrito como min8. Solución: Usar constantes o revisar documentación del validador.
  • Validar solo en el handler: No reutilizar la validación en otros lugares, como tests o servicios. Solución: Crear una función separada para validar que pueda ser usada en múltiples capas.
  • Mensajes de error genéricos: Responder solo "Validación fallida" sin detalles. Solución: Incluir información específica sobre qué campo falló y por qué.
  • Ignorar validación de tipos: Asumir que el JSON siempre tendrá los tipos correctos. Solución: Usar tags como validate:"number" para campos numéricos.

Checklist de dominio

  1. Definir structs con tags json y validate para todos los campos de entrada.
  2. Instalar y configurar un validador como go-playground/validator en el proyecto.
  3. Validar datos inmediatamente después de decodificar JSON en los handlers.
  4. Proporcionar respuestas de error claras con detalles de validación fallida.
  5. Escribir tests unitarios que verifiquen casos válidos e inválidos.
  6. Usar reglas comunes: required, email, min, max, gte (greater than or equal), lte.
  7. Documentar las reglas de validación en la especificación de la API.

Implementar validación en un endpoint de producto

En este ejercicio, mejorarás un endpoint existente para crear productos en una API de e-commerce. Sigue estos pasos:

  1. Descarga el código base que incluye un handler básico sin validación.
  2. Define un struct CreateProductRequest con campos: Name (string), Price (float64), Stock (int), Category (string).
  3. Agrega tags json para mapear a claves JSON y tags validate con estas reglas:
    • Name: requerido, mínimo 3 caracteres, máximo 100.
    • Price: requerido, mayor que 0.
    • Stock: requerido, mínimo 0.
    • Category: requerido, debe ser uno de: "electronics", "clothing", "books".
  4. Integra el validador en el handler para validar el struct después de decodificar el JSON.
  5. Si la validación falla, responde con status 400 y un JSON que liste los errores por campo.
  6. Si es exitosa, responde con status 201 y un mensaje de confirmación.
  7. Prueba con datos válidos e inválidos usando curl o Postman.
Pistas
  • Usa la regla 'oneof' para validar que Category esté en la lista permitida.
  • Recuerda inicializar el validador una vez y reutilizarlo, no en cada request.
  • Para Price mayor que 0, la regla es 'gt=0' (greater than).

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Go con Gorilla/Mux: CRUD, Validación y Microservicios

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.