[Go] 数据校验工具Validator

1

go get -u github.com/go-playground/validator/v10

1

import "github.com/go-playground/validator/v10"

1
2
3
4
5
6

type User struct {
    Name     string `validate:"required"`
    Age      int    `validate:"gte=0,lte=100"`
    Email    string `validate:"email"`
    Password string `validate:"required,min=6"`
}

1

validate := validator.New()

1
2
3
4
5
6
7
8
9

user := User{Name: "John", Age: 25, Email: "john@example.com", Password: "password"}
err := validate.Struct(user)
if err != nil {
    // 处理验证失败的情况
    fmt.Println(err)
} else {
    // 处理验证成功的情况
    fmt.Println("Validation passed")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package main

import (
 "fmt"
 "strings"

 "github.com/go-playground/locales/en"
 "github.com/go-playground/locales/zh"
 ut "github.com/go-playground/universal-translator"
 "github.com/go-playground/validator/v10"

 zhtrans "github.com/go-playground/validator/v10/translations/zh"
 // entrans "github.com/go-playground/validator/v10/translations/en"
)

/*
https://www.cnblogs.com/jiujuan/p/13823864.html

https://www.liwenzhou.com/posts/Go/validator-usages/

https://juejin.cn/post/7056823502640250893

https://juejin.cn/post/6847902214279659533
*/
type Student struct {
 Name  string `validate:required`
 Email string `validate:"email"`
 Age   int    `validate:"max=30,min=12"`
}

func main() {
 en := en.New() //英文翻译器
 zh := zh.New() //中文翻译器

 // 第一个参数是必填，如果没有其他的语言设置，就用这第一个
 // 后面的参数是支持多语言环境（
 // uni := ut.New(en, en) 也是可以的
 // uni := ut.New(en, zh, tw)
 uni := ut.New(en, zh)
 trans, _ := uni.GetTranslator("zh") //获取需要的语言

 student := Student{
  Name:  "tom",
  Email: "testemal",
  Age:   40,
 }
 validate := validator.New()

 zhtrans.RegisterDefaultTranslations(validate, trans)

 err := validate.Struct(student)
 if err != nil {
  // fmt.Println(err)

  errs := err.(validator.ValidationErrors)
  fmt.Println(removeStructName(errs.Translate(trans)))
 }
}

func removeStructName(fields map[string]string) map[string]string {
 result := map[string]string{}

 for field, err := range fields {
  result[field[strings.Index(field, ".")+1:]] = err
 }
 return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Signup struct {
    Email string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
    ConfirmPassword string `json:"confirm_password" binding:"required,eqfield=ConfirmPassword"`
}

func main() {
	r := gin.Default()
	r.POST("/signup", func(c *gin.Context) {
		var u Signup
		if err := c.ShouldBind(&u); err != nil {
            ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main
 
import (
    "fmt"
    "github.com/go-playground/validator/v10"
)
 
type User struct {
    Username string `json:"username" validate:"required"`
    Age      uint8  `json:"age" validate:"gte=0,lte=120"`
    Email    string `json:"email" validate:"required,email"`
}
 
func main() {
    validate := validator.New(validator.WithRequiredStructEnabled())
 
    user := User{
        Username: "john.doe",
        Age:      121, // 不合法的年龄
        Email:    "not-an-email", // 不合法的邮箱
    }
 
    err := validate.Struct(user)
    if err != nil {
        // 打印验证错误
        if _, ok := err.(*validator.InvalidValidationError); ok {
            fmt.Println(err)
            return
        }
 
        for _, err := range err.(validator.ValidationErrors) {
            fmt.Println(err.Namespace())
            fmt.Println(err.Field())
            fmt.Println(err.StructNamespace())
            fmt.Println(err.StructField())
            fmt.Println(err.Tag())
            fmt.Println(err.ActualTag())
            fmt.Println(err.Kind())
            fmt.Println(err.Type())
            fmt.Println(err.Value())
            fmt.Println(err.Param())
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package main

import (
	"database/sql"
	"database/sql/driver"
	"fmt"
	"reflect"

	"github.com/go-playground/validator/v10"
)

// DbBackedUser User struct
type DbBackedUser struct {
	Name sql.NullString `validate:"required"`
	Age  sql.NullInt64  `validate:"required"`
}

// use a single instance of Validate, it caches struct info
var validate *validator.Validate

func main() {

	validate = validator.New()

	// register all sql.Null* types to use the ValidateValuer CustomTypeFunc
	validate.RegisterCustomTypeFunc(ValidateValuer, sql.NullString{}, sql.NullInt64{}, sql.NullBool{}, sql.NullFloat64{})

	// build object for validation
	x := DbBackedUser{Name: sql.NullString{String: "", Valid: true}, Age: sql.NullInt64{Int64: 0, Valid: false}}

	err := validate.Struct(x)

	if err != nil {
		fmt.Printf("Err(s):\n%+v\n", err)
	}
}

// ValidateValuer implements validator.CustomTypeFunc
func ValidateValuer(field reflect.Value) interface{} {

	if valuer, ok := field.Interface().(driver.Valuer); ok {

		val, err := valuer.Value()
		if err == nil {
			return val
		}
		// handle the error how you want
	}

	return nil
}

1
2
3
4
5
6
7

// 注册自定义标签
_ = validate.RegisterValidation("custom-tag-name", ValidatePre)

// 自定义验证规则
func ValidatePre(fl validator.FieldLevel) bool {
	return fl.Field().String() == "custom-value"
}