golang validator基于map规则验证集合和结构体

validator基于map规则验证集合和结构体

validator可以基于map规则进行集合的校验以及结构体的校验，同时支持嵌套校验

主要函数

validate.ValidateMap(map, rules)

验证集合
validate.RegisterStructValidationMapRules(structType, Data{})

验证结构体

集合验证

go 复制代码

package validate

import (
    "fmt"
    "log"
)

// 集合验证
func ValidateMap() {
    user := map[string]interface{} {
        "name": "hdddccccc",
        "emain": "[email protected]",
    }

    rules := map[string]interface{} {
        "name": "required,min=8,max=15",
        "email": "omitempty,email",
    }

    err := validate.ValidateMap(user, rules)
    if err != nil {
        fmt.Println(err)
    }

}

// 集合嵌套验证
func ValidateNestedMap() {
    data := map[string]interface{} {
        "name": "ddkalsj",
        "email": "[email protected]",
        "details": map[string]interface{}{
            "contact_address": map[string]interface{}{
                "province": "湖南",
                "city":     "长沙",
            },
            "age": 18,
            "phones": []map[string]interface{}{
                {
                    "number": "11-111-1111",
                    "remark": "home",
                },
                {
                    "number": "22-222-2222",
                    "remark": "work",
                },
            },
        },
    }

    rules := map[string]interface{}{
        "name":  "min=4,max=15",
        "email": "required,email",
        "details": map[string]interface{}{
            "contact_address": map[string]interface{}{
                "province": "required",
                "city":     "required",
            },
            "age": "numeric,min=18",
            "phones": map[string]interface{}{
                "number": "required,min=4,max=32",
                "remark": "required,min=1,max=32",
            },
        },
    }

    err := validate.ValidateMap(data, rules)
    if err != nil {
        log.Fatal(err)
    }
}

结构体验证

go 复制代码

package validate

import "fmt"

// map规则于结构体中的应用
type Data struct {
    Name    string
    Email   string
    Details *Details
}
type Details struct {
    ContactAddress *ContactAddress
    Age            uint8
    Phones         []*Phone
}
type ContactAddress struct {
    Province string
    City     string
}
type Phone struct {
    Number string
    Remark string
}

func ValidateStructNested() {
    data := Data{
        Name:  "kangkang",
        Email: "[email protected]",
        Details: &Details{
            ContactAddress: &ContactAddress{
                Province: "四川",
                City:     "成都",
            },
            Age: 18,
            Phones: []*Phone{
                {
                    Number: "11-111-1111",
                    Remark: "home",
                },
                {
                    Number: "22-2111-1111",
                    Remark: "work",
                },
            },
        },
    }
    // map 字段验证规则
    dataRules := map[string]string{
        "Name":    "min=4,max=15",
        "Email":   "required,email",
        "Details": "required",
    }

    detailRules := map[string]string{
        "Age":            "number,min=18,max=130",
        "ContactAddress": "required",
        "Phones":         "required,min=1,dive",
    }
    contactAddressRules := map[string]string{
        "Province": "required",
        "City":     "required",
    }
    phoneRules := map[string]string{
        "Number": "required,min=4,max=32",
        "Remark": "required,min=1,max=32",
    }
	// 注册对应结构体验证
    validate.RegisterStructValidationMapRules(dataRules, Data{})
    validate.RegisterStructValidationMapRules(detailRules, Details{})
    validate.RegisterStructValidationMapRules(contactAddressRules, ContactAddress{})
    validate.RegisterStructValidationMapRules(phoneRules, Phone{})
    err := validate.Struct(data)
    if err != nil {
        fmt.Println(err)
    }
}