go --- validator验证器实践

项目地址：https://github.com/go-playground/validator

其他中文说明文档：https://www.cnblogs.com/zj420255586/p/13542395.html
 

1、操作符说明

,	多操作符分割
|	或
-	跳过验证

 

2、常用标记说明

标记	说明	例如
required	必填	validate:“required”
omitempty	空时忽略	???
len	长度
eq	等于
gt	大于
gte	大于等于
lt	小于
lte	小于等于
min	最小值
max	最大值
isdefault	默认值	???
oneof	其中之一
email	字符串值包含一个有效的电子邮件
json	字符串值是否为有效的 JSON
url	符串值是否包含有效的 url
uri	符串值是否包含有效的 uri
base64	字符串值是否包含有效的 base64值
contains	字符串值包含子字符串值
ip	字符串值是否包含有效的 IP 地址
ipv4	字符串值是否包含有效的 ipv4地址
datetime	字符串值是否包含有效的 日期
gtfield	大于同一结构体字段

 

3、注意事项

1. 当搜索条件与特殊标记冲突时,如：逗号（,），或操作（|），中横线（-）等则需要使用 UTF-8十六进制表示形式

   例：

   Copytype Test struct {
      Field1 string  `validate:"excludesall=|"`    // 错误
      Field2 string `validate:"excludesall=0x7C"` // 正确.
   }
   

2. 可通过validationErrors := errs.(validator.ValidationErrors)获取错误对象自定义返回响应错误

3. 自定义校验结果翻译

   Copy// 初始化翻译器
   func validateInit() {
   	zh_ch := zh.New()
   	uni := ut.New(zh_ch)               // 万能翻译器，保存所有的语言环境和翻译数据
   	Trans, _ = uni.GetTranslator("zh") // 翻译器
   	Validate = validator.New()
   	_ = zh_translations.RegisterDefaultTranslations(Validate, Trans)
   	// 添加额外翻译
   	_ = Validate.RegisterTranslation("required_without", Trans, func(ut ut.Translator) error {
   		return ut.Add("required_without", "{0} 为必填字段!", true)
   	}, func(ut ut.Translator, fe validator.FieldError) string {
   		t, _ := ut.T("required_without", fe.Field())
   		return t
   	})
   }
   

 

4、代码实践

package main

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

var validate = validator.New()

func main() {
	type Inner struct {
		ContainsString string `validate:"contains=111"`
	}
	inner := &Inner{ContainsString: "11@"}
	err := validate.Struct(inner)
	if err != nil {
		fmt.Println(err.Error())
	}

	//required 必填验证
	type RequiredTest struct {
		Name string
		Age  int `validate:"required"`
	}
	//requiredTest := &RequiredTest{Name:"11111",Age:10}
	requiredTest := &RequiredTest{Name: "11111"}
	err = validate.Struct(requiredTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//len 长度限制
	type LenTest struct {
		Name string `validate:"len=3"`
		Age  int
	}
	//lenTest := &LenTest{Name:"111"}
	lenTest := &LenTest{Name: "1111"}
	err = validate.Struct(lenTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	// eq 等于
	type EqTest struct {
		Name string
		Age  int `validate:"eq=3"`
	}
	//eqTest := &EqTest{Age:3}
	eqTest := &EqTest{Age: 10}
	err = validate.Struct(eqTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	// gt 大于
	type GtTest struct {
		Name string
		Age  int `validate:"gt=3"`
	}
	//gtTest := &GtTest{Age:10}
	gtTest := &GtTest{Age: 3}
	err = validate.Struct(gtTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	// gte 等于
	type GteTest struct {
		Name string
		Age  int `validate:"gte=3"`
	}
	gteTest := &GteTest{Age: 2}
	//gteTest := &GteTest{Age:3}
	err = validate.Struct(gteTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//lt 小于
	type LtTest struct {
		Name string
		Age  int `validate:"lt=5"`
	}
	//ltTest := &LtTest{Age:2}
	ltTest := &LtTest{Age: 8}
	err = validate.Struct(ltTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//lte 小于等于
	type LteTest struct {
		Name string
		Age  int `validate:"lte=5"`
	}
	lteTest := &LteTest{Age: 2}
	//lteTest := &LteTest{Age:8}
	err = validate.Struct(lteTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//eqfield 同一结构体字段相等
	type EqfieldTest struct {
		Name  string
		Age   int `validate:"eqfield=Count"`
		Count int
	}
	//eqfieldTest := &EqfieldTest{Age:2,Count:2}
	eqfieldTest := &EqfieldTest{Age: 2, Count: 10}
	err = validate.Struct(eqfieldTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//min 最小值
	type MinTest struct {
		Name  string
		Age   int `validate:"min=18"`
		Count int
	}
	minTest := &MinTest{Age:12,Count:2}
	//minTest := &MinTest{Age: 18, Count: 10}
	err = validate.Struct(minTest)
	if err != nil {
		fmt.Println(err.Error())
	}

	//max 最大值
	type MaxTest struct {
		Name  string
		Age   int `validate:"max=18"`
	}
	//maxTest := &MaxTest{Age:12}
	maxTest := &MaxTest{Age: 20}
	err = validate.Struct(maxTest)
	if err != nil {
		fmt.Println(err.Error())
	}


	//oneof 其中之一
	type OneofTest struct {
		Name  string
		Age   int `validate:"oneof=10 15"`
	}
	oneofTest := &OneofTest{Age:12}
	//oneofTest := &OneofTest{Age:10}
	err = validate.Struct(oneofTest)
	if err != nil {
		fmt.Println(err.Error())
	}


	//email 是否包含电子邮件
	type EmailTest struct {
		Email  string `validate:"email"`
		Age   int
	}
	//emailTest := &EmailTest{Email:"123qq.com"}  //不通过
	//emailTest := &EmailTest{Email:"123@com"}  //不通过
	//emailTest := &EmailTest{Email:"123@q.com"}  //通过
	//emailTest := &EmailTest{Email:"123-@q.com"}  //通过
	emailTest := &EmailTest{Email:"@q.com"}  //不通过
	//emailTest := &EmailTest{Email:"帅@q.com"}  //通过
	err = validate.Struct(emailTest)
	if err != nil {
		fmt.Println(err.Error())
	}

}

 
如有不对，烦请指出，感谢~