Validación de datos en Go (Golang)

Validación de datos en Go (Golang): herramientas, ejemplos y mejores prácticas

La validación de datos es una de las etapas clave en el desarrollo de cualquier aplicación web o API. En Go (Golang), esta tarea se resuelve de manera especialmente elegante gracias al tipado estricto, bibliotecas potentes y capacidades integradas. En este artículo, analizaremos los enfoques principales para la verificación de datos, las bibliotecas populares y proporcionaremos ejemplos prácticos de código.

¿Por qué es necesaria la validación en Go?

Go se compila a código nativo y no tiene un sistema de reflexión incorporado como Python o JavaScript. Sin embargo, los desarrolladores han creado varias bibliotecas excelentes que permiten:

Verificar los campos de las estructuras según formatos (email, URL, teléfono);
Establecer restricciones (min, max, required);
Crear validadores personalizados para la lógica de negocio;
Integrarse con frameworks web (Gin, Echo, Fiber).

1. Biblioteca go-playground/validator (la más popular)

go-playground/validator es el estándar de facto para la validación de estructuras en Go. Utiliza etiquetas (tags) en los campos de las estructuras y admite más de 100 reglas integradas.

package main

import (    "fmt"    "github.com/go-playground/validator/v10")

type User struct {    Name  string `validate:"required,min=2,max=50"`    Email string `validate:"required,email"`    Age   int    `validate:"gte=18,lte=120"`}

func main() {    validate := validator.New()    user := User{        Name:  "A",        Email: "invalid-email",        Age:   15,    }    err := validate.Struct(user)    if err != nil {        for _, e := range err.(validator.ValidationErrors) {            fmt.Printf("Campo: %s, Error: %s, Valor: %v", e.Field(), e.Tag(), e.Value())        }    }}

Salida:

Campo: Name, Error: min, Valor: ACampo: Email, Error: email, Valor: invalid-emailCampo: Age, Error: gte, Valor: 15

2. Biblioteca ozzo-validation (alternativa con encadenamiento de llamadas)

ozzo-validation ofrece un estilo más declarativo sin etiquetas. Es adecuado para casos donde la estructura no puede modificarse o se necesita validación dinámica.

package main

import (    "fmt"    "github.com/go-ozzo/ozzo-validation/v4"    "github.com/go-ozzo/ozzo-validation/v4/is")

type Product struct {    Name  string    Price float64}

func main() {    p := Product{Name: "", Price: -10}    err := validation.ValidateStruct(&p,        validation.Field(&p.Name, validation.Required, validation.Length(1, 100)),        validation.Field(&p.Price, validation.Required, validation.Min(0.01)),    )    if err != nil {        fmt.Println(err)    }}

3. Validadores personalizados

A menudo se requiere una verificación no contemplada por las reglas integradas. Por ejemplo, validación de contraseña o unicidad de nombre.

package main

import (    "fmt"    "github.com/go-playground/validator/v10"    "unicode")

func passwordValidator(fl validator.FieldLevel) bool {    pwd := fl.Field().String()    hasUpper := false    hasDigit := false    for _, ch := range pwd {        if unicode.IsUpper(ch) {            hasUpper = true        }        if unicode.IsDigit(ch) {            hasDigit = true        }    }    return len(pwd) >= 8 && hasUpper && hasDigit}

type Account struct {    Password string `validate:"password"`}

func main() {    validate := validator.New()    validate.RegisterValidation("password", passwordValidator)

    acc := Account{Password: "weak"}    err := validate.Struct(acc)    if err != nil {        fmt.Println("La contraseña no pasó la validación")    } else {        fmt.Println("La contraseña es correcta")    }}