Golang请求验证技巧 数据清洗与过滤

go-playground/validator

validate

type RegisterRequest struct {
    Username string `json:"username" validate:"required,min=3,max=32"`
    Email    string `json:"email" validate:"required,email"`
    Password string `json:"password" validate:"required,min=8"`
    Age      int    `json:"age" validate:"omitempty,gte=18,lte=100"` // omitempty表示可选，如果存在则验证
}

import (
    "github.com/go-playground/validator/v10"
    "github.com/gin-gonic/gin" // 假设你用Gin
)

var validate *validator.Validate

func init() {
    validate = validator.New()
    // 也可以注册自定义验证器
    // validate.RegisterValidation("is-awesome", validateIsAwesome)
}

func RegisterUser(c *gin.Context) {
    var req RegisterRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": "Invalid request payload"})
        return
    }

    if err := validate.Struct(req); err != nil {
        validationErrors := err.(validator.ValidationErrors)
        // 这里可以对错误进行更细致的处理，比如返回每个字段的具体错误信息
        errorMessages := make(map[string]string)
        for _, fieldErr := range validationErrors {
            errorMessages[fieldErr.Field()] = fieldErr.Tag() // 简单示例，实际可以更友好
        }
        c.JSON(400, gin.H{"validation_errors": errorMessages})
        return
    }

    // 验证通过，处理业务逻辑
    c.JSON(200, gin.H{"message": "User registered successfully"})
}

[]struct

[]map[string]interface{}

type Product struct {
    ID    string
    Name  string
    Price float64
    Stock int
    Tags  []string
}

// 定义一个过滤器类型
type ProductFilter func([]Product) []Product

// 示例过滤函数：过滤价格低于某个值的商品
func FilterByMinPrice(minPrice float64) ProductFilter {
    return func(products []Product) []Product {
        var filtered []Product
        for _, p := range products {
            if p.Price >= minPrice {
                filtered = append(filtered, p)
            }
        }
        return filtered
    }
}

// 示例过滤函数：过滤库存为0的商品
func FilterOutOfStock() ProductFilter {
    return func(products []Product) []Product {
        var filtered []Product
        for _, p := range products {
            if p.Stock > 0 {
                filtered = append(filtered, p)
            }
        }
        return filtered
    }
}

// 应用多个过滤器
func ApplyFilters(products []Product, filters ...ProductFilter) []Product {
    currentProducts := products
    for _, filter := range filters {
        currentProducts = filter(currentProducts)
    }
    return currentProducts
}

// 使用示例
func main() {
    allProducts := []Product{
        {"1", "Laptop", 1200.0, 10, []string{"electronics"}},
        {"2", "Mouse", 25.0, 0, []string{"electronics"}},
        {"3", "Keyboard", 75.0, 5, []string{"electronics"}},
        {"4", "Monitor", 300.0, 0, []string{"electronics"}},
    }

    // 过滤出价格大于50且有库存的商品
    filtered := ApplyFilters(allProducts, FilterByMinPrice(50.0), FilterOutOfStock())
    // fmt.Println(filtered)
    // 预期输出：Laptop, Keyboard
}

// 这是一个概念性的示例，实际使用需要更多错误处理和类型转换
func FilterByField(products []Product, fieldName string, fieldValue interface{}) []Product {
    var filtered []Product
    for _, p := range products {
        v := reflect.ValueOf(p)
        field := v.FieldByName(fieldName)
        if field.IsValid() && field.Interface() == fieldValue {
            filtered = append(filtered, p)
        }
    }
    return filtered
}

Filter

Map

Reduce

// 假设有一个泛型Filter函数 (很多社区库都有类似实现)
// func Filter[T any](items []T, predicate func(T) bool) []T { ... }

// 使用示例
// Filter(allProducts, func(p Product) bool {
//     return p.Price >= 50.0 && p.Stock > 0
// })