golang 组件 validator介绍以及使用案例——单字段验证和结构体验证

最新推荐文章于 2023-10-19 14:58:59 发布

咚伢

最新推荐文章于 2023-10-19 14:58:59 发布

阅读量1.7k

点赞数 1

文章标签： golang 开发语言后端数据库

本文链接：https://blog.csdn.net/qq_43058348/article/details/133822830

版权

golang validator验证器

validator源码

validator是一个字段验证框架，可以用于各种字段的验证。包括结构体验证

validator框架

多个验证标签之间符号说明

逗号（,）：多个验证标签分隔符。例如：validate:"required,email
横线（-）：跳过该字段不验证
竖线（|）：使用多个验证标记，但只需满足其中一个即可
omitempty：如果字段未设置，则忽略该符号后面的校验
dive：表示深入一层验证，用于切片与集合（slice、map）

预定义Tag

常见网络相关tag

1. fqdn：完全限定域名，例如：www.baddu.com
2. hostname：主机名称
3. hostname_port：主机端口
4. ip：ip地址，包括ipv4和ipv6
5. ipv4
6. ipv6
7. mac：mac地址
8. uri：统一资源标识符
9. url：统一资源定位符
10. url_encode

常见字符串tag

1. alpha：字母字符串
2. alphanum ：字母与数字字符串
3. alphaunicode：字母和Unicode字符
4. alphanumunicode：字母、数字和Unicode字符
5. ascii：ascii字符串
6. boolean：布尔类型字符
7. contains：字符串包含指定内容，例如：contains=www，表示被校验字符串应包含“www”
8. endsnotwith：字符串不以指定内容结尾，例如：endsnotwith=www
9. startsnotwith：字符串不以指定内容开头
10. endswith：字符串以指定内容结尾，例如：endswith=com
11. startswith：字符串以指定内容开头
12. excludes：字符串不包含指定内容，与contains相反
13. lowercase：字符串全小写
14. uppercase：字符串全大写
15. multibyte：多字节字符串
16. number：数字类型，数字如："12345678"
17. numeric：数值类型，数字如："123.345"

常见格式相关tag

1. base64：base64字符串
2. base64url：base64URL字符串
3. credit_card：信用卡号
4. datetime：根据给定时间格式验证，例如：datetime=2006-01-02 15:04:05
5. e164：手机号码验证，手机号码格式如：+8613800138000
6. email：电子邮箱地址
7. hexadecimal：16进制字符串
8. json：json字符串
9. jwt：jwt字符串
10. latitude：纬度
11. longitude：经度
12. timezone：时区，时区如：Asia/Shanghai
13. iscolor：是否为颜色
14. country_code：国家代码

比较相关tag

1. eq：等于，eg=10
2. gt：大于，gt=10
3. gte：大于等于，gte=10
4. lt：小于，lt=10
5. lte：小于等于，lte=10
6. ne：不等于，ne=10

其他tag

1. dir：目录
2. file：文件路径
3. isdefault：验证值是否为默认值（零值），相当于 eq=零值
4. len：长度，可用于字符串、切片、集合
5. max：最大值、长度，可用于数字、字符串、切片、集合
6. min：最小值、长度，可用于数字、字符串、切片、集合
7. oneof：指定内容中的某一个值，例如：oneof=red green，那么只有取值为 red或green才能验证
通过
8. required：必填
9. required_if：满足条件必填，例如：required_if=Field1 test，当Field1=test，则必填
10. required_unless：除指定条件外，其他情况必填，例如：required_unless=Field1 test，当
Field1!=test，则必填
11. required_with：如果指定的字段有值，则必填，例如：required_with=Field1，当Field1不为零
值，则必填
12. required_with_all：如果指定的字段都有值，则必填，例如：required_with_all=Field1 Field2，
当Field1 Field2 两个字段都不为零值，则必填
13. required_without：如果指定的字段没有值，则必填，例如：required_without=Field1，当Field1
为零值，则必填
14. required_without_all：如果指定的字段都没有值，则必填，例如：required_without_all=Field1
Field2，当Field1 Field2 两个字段都为零值，则必填
15. excluded_with、excluded_with_all、excluded_without、excluded_without_all 与required相
反，表示满足某些条件，必须不填（即必须为零值）

字段相关tag

1. eqcsfield：字段与其他字段相等
2. eqfield：字段与其他字段相等
3. fieldcontains：字段包含其他字段值
4. fieldexcludes：字段不包含其他字段值
5. gtcsfield：字段大于其他字段值
6. gtecsfield：字段大于等于其他字段值
7. gtefield：字段大于等于其他字段值
8. gtfield：字段大于其他字段值
9. ltcsfield：字段小于其他字段值
10. ltecsfield：字段小于等于其他字段值
11. ltefield：字段小于等于其他字段值
12. ltfield：字段小于其他字段值
13. necsfield：字段不等于其他字段
14. nefield：字段不等于其他字段
注：字段相关tag，包括两种情况，
1. tag包含cs：表示与对象内部其他对象字段的字段比较。
2. tag不包含cs：表示与对象内部其他基础类型字段比较

单字field段验证

bool

var b = "true"
err = v.Var(b, "boolean")

数字

var i = "100"

err = v.Var(i, "number,gt=1,lt=101")
outRes("number", &err)

var f = "100.132"

err = v.Var(f, "numeric")
outRes("numeric", &err)

字符串

var str = "abcdef"
err = v.Var(str, "alpha")
outRes("alpha", &err)

切片

var slice = []int{1,2,3,4,5,6,7,8}
err = v.Var(slice, "max=15,min=4")
outRes("slice", &err)

集合

var mp = make(map[int]int)
mp[2] = 3
mp[1] = 1
mp[3] = 3
err = v.Var(mp, "max=15,min=4")

时间

var timeStr = time.Now().Format("2006-01-02  15:04:05")
fmt.Println("timestra:" )
fmt.Println("timestr:" + timeStr)
err = v.Var(timeStr, "datetime=2006-01-02 15:04:05")
outRes("time", &err)

比较

s1 := "abc"
s2 := "cda"

err = v.VarWithValue(s1, s2, "eqfield")
outRes("eqfield", &err)

案例代码

package validate

import (
	"fmt"
	"time"
)

// bool
// 数字
// 字符串
// 切片
// 集合
// 时间


func SingleFieldValidate() {
	v := validate
	var err error
	var b = "true"
	err = v.Var(b, "boolean")
	printValidateResult("boolean", &err)

	var i = "100"

	err = v.Var(i, "number,gt=1,lt=101")
	printValidateResult("number", &err)

	var f = "100.132"

	err = v.Var(f, "numeric")
	printValidateResult("numeric", &err)

	var str = "abcdef"
	err = v.Var(str, "alpha")
	printValidateResult("alpha", &err)

	var slice = []int{1,2,3,4,5,6,7,8}
	err = v.Var(slice, "max=15,min=4")
	printValidateResult("slice", &err)

	var mp = make(map[int]int)
	mp[2] = 3
	mp[1] = 1
	mp[3] = 3
	err = v.Var(mp, "max=15,min=4")

	var timeStr = time.Now().Format("2006-01-02  15:04:05")
	fmt.Println("timestra:" )
	fmt.Println("timestr:" + timeStr)
	err = v.Var(timeStr, "datetime=2006-01-02 15:04:05")
	printValidateResult("time", &err)

	s1 := "abc"
	s2 := "cda"

	err = v.VarWithValue(s1, s2, "eqfield")
	printValidateResult("eqfield", &err)

}

结构struct绑定验证

结构体字段深入验证

使用dive标签，然后在子结构体定义的字段中进行标签填写。

切片字段深入验证

type User struct {
    	Hobby       []string             `v:"required,gte=2,dive,required,gte=1,alphaunicode"`  // 深入下一层验证，后续接长度大于等于2，并且是字母+unicode
}

切片验证 dive 后是切片元素的验证

Map字段深入验证

type User struct {
    // 深入下一层验证，keys,alpha,gte=2,lte=10,endkeys 这一段是验证map的key， endkeys后面是跟对应value的校验
	Data        map[string]string    `v:"required,gte=2,dive,keys,alpha,gte=2,lte=10,endkeys,required,gte=2,alphaunicode"`
}

````v:"required,gte=2,dive,keys,alpha,gte=2,lte=10,endkeys,required,gte=2,alphaunicode"表面，data字段必填，长度大于等于2。dive深入一层验证。keys … endkeys```中间是keys的字段验证。 endkeys后是values的字段验证。

案例：

package validate

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

/*
	字段都必填
	contactUser字段 phone email address 三选一
*/
type User struct {
	Name        string               `v:"required,alphaunicode"`       // v是因为 validate.SetTagName("v")
	Age         uint8	             `v:"required,gte=10,lte=130"`
	Phone       string               `v:"required,e164"`               // e164电话的一种格式
	Email       string               `v:"required,email"`
	FavouriteColor1 string            `v:"iscolor"`
	FavouriteColor2 string            `v:"hexcolor|rgb|rgba|hsl|hsla"`  // 颜色格式 16进制
	Address     *Address             `v:"required"`
	ContactUser []*ContactUser        `v:"required,gte=1,dive"`          // dive 深入到下一层验证
	Hobby       []string             `v:"required,gte=2,dive,required,gte=1,alphaunicode"`  // 深入下一层验证，后续接长度大于等于2，并且是字母+unicode
	// 深入下一层验证，keys,alpha,gte=2,lte=10,endkeys 这一段是验证map的key， endkeys后面是跟对应value的校验
	Data        map[string]string    `v:"required,gte=2,dive,keys,alpha,gte=2,lte=10,endkeys,required,gte=2,alphaunicode"`
}

type ContactUser struct {
	Name    string   `v:"required,alphaunicode"`
	Age     uint8    `v:"gte=10,lte=130"`
	Phone   string   `v:"required_without_all=Email Address,omitempty,e164"`   //required_without_all 如果指定字段没有值，则必填  可以为空
	Email   string   `v:"required_without_all=Phone Address,omitempty,email"`  // 可以为空
	Address *Address `v:"required_without_all=Phone Email"`
}

type Address struct {
	Province string   `v:"required"`
	City     string   `v:"required"`

}

func StructValidate() {
	addr := &Address{
		Province: "湖南",
		City:     "长沙",
	}
	contactUser1 := &ContactUser{
		Name:  "yy",
		Age:   18,
		Phone: "+8613800138111",
	}
	contactUser2 := &ContactUser{
		Name:  "张三",
		Age:   18,
		Email: "zhangsan@0kuangtu.com",
	}
	user := &User{
		Name:            "yuan",
		Age:             18,
		Phone:           "+8613800138111",
		Email:           "yuan@0google.com",
		FavouriteColor1: "#ffff",
		FavouriteColor2: "rgb(255,255,255)",
		Address:         addr,
		ContactUser:     []*ContactUser{contactUser1, contactUser2},
		Hobby:           []string{"篮球", "唱", "rap"},
		Data:            map[string]string{"AB": "篮球", "CD": "rap"},
	}
	err := validate.Struct(user)
	if err != nil {
		// validator.ValidationError是每个字段错误组合的切片
		if errors, ok := err.(validator.ValidationErrors); ok {
			for _, err := range errors {
				fmt.Println(err)
			}
		}
	}
}