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

// Structure
func customFunc(fl validator.FieldLevel) bool {

	if fl.Field().String() == "invalid" {
		return false
	}

	return true
}

validate.RegisterValidation("custom tag name", customFunc)
//注意：使用与现有功能相同的标记名称
//将覆盖现有功能

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

- eqfield
- nefield
- gtfield
- gtefield
- ltfield
- ltefield
- eqcsfield
- necsfield
- gtcsfield
- gtecsfield
- ltcsfield
- ltecsfield

 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

type Inner struct {
	StartDate time.Time
}

type Outer struct {
	InnerStructField *Inner
	CreatedAt time.Time      `validate:"ltecsfield=InnerStructField.StartDate"`
}

now := time.Now()

inner := &Inner{
	StartDate: now,
}

outer := &Outer{
	InnerStructField: inner,
	CreatedAt: now,
}

errs := validate.Struct(outer)

// NOTE: when calling validate.Struct(val) topStruct will be the top level struct passed
//       into the function
//       when calling validate.VarWithValue(val, field, tag) val will be
//       whatever you pass, struct, field...
//       when calling validate.Field(field, tag) val will be nil

1
2
3
4
5

type Test struct {
	Field `validate:"max=10,min=1"`
}

// max will be checked then min

1
2
3
4

type Test struct {
	Field `validate:"min=10,max=0"`
}
// this definition of min max will never succeed

1
2
3
4

type Test struct {
	Field `validate:"excludesall=,"`    // BAD! Do not include a comma.
	Field `validate:"excludesall=0x2C"` // GOOD! Use the UTF-8 hex representation.
}

1
2
3
4

type Test struct {
	Field `validate:"excludesall=|"`    // BAD! Do not include a a pipe!
	Field `validate:"excludesall=0x7C"` // GOOD! Use the UTF-8 hex representation.
}

1
2

"iscolor"
	alias is "hexcolor|rgb|rgba|hsl|hsla" (Usage: iscolor)

1
2
3
4
5
6
7
8
9

type Test struct {
	TestField string `validate:"nonexistantfunction=1"`
}

t := &Test{
	TestField: "Test"
}

validate.Struct(t) // this will panic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

type Test struct {
	TestField string `validate:"yourtag"`
}

t := &Test{
	TestField: "Test"
}

validate := validator.New()
validate.RegisterValidation("yourtag", validations.ValidatorName)

NotBlank
	This validates that the value is not blank or with length zero.
	For strings ensures they do not contain only spaces. For channels, maps, slices and arrays
	ensures they don't have zero length. For others, a non empty value is required.

    Usage: notblank

1

type CustomTypeFunc func(field reflect.Value) interface{}

 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
68
69
70
71
72
73
74
75
76

type FieldError interface {

    // returns the validation tag that failed. if the
    // validation was an alias, this will return the
    // alias name and not the underlying tag that failed.
    //
    // eg. alias "iscolor": "hexcolor|rgb|rgba|hsl|hsla"
    // will return "iscolor"
    Tag() string

    // returns the validation tag that failed, even if an
    // alias the actual tag within the alias will be returned.
    // If an 'or' validation fails the entire or will be returned.
    //
    // eg. alias "iscolor": "hexcolor|rgb|rgba|hsl|hsla"
    // will return "hexcolor|rgb|rgba|hsl|hsla"
    ActualTag() string

    // returns the namespace for the field error, with the tag
    // name taking precedence over the fields actual name.
    //
    // eg. JSON name "User.fname"
    //
    // See StructNamespace() for a version that returns actual names.
    //
    // NOTE: this field can be blank when validating a single primitive field
    // using validate.Field(...) as there is no way to extract it's name
    Namespace() string

    // returns the namespace for the field error, with the fields
    // actual name.
    //
    // eq. "User.FirstName" see Namespace for comparison
    //
    // NOTE: this field can be blank when validating a single primitive field
    // using validate.Field(...) as there is no way to extract it's name
    StructNamespace() string

    // returns the fields name with the tag name taking precedence over the
    // fields actual name.
    //
    // eq. JSON name "fname"
    // see StructField for comparison
    Field() string

    // returns the fields actual name from the struct, when able to determine.
    //
    // eq.  "FirstName"
    // see Field for comparison
    StructField() string

    // returns the actual fields value in case needed for creating the error
    // message
    Value() interface{}

    // returns the param value, in string form for comparison; this will also
    // help with generating an error message
    Param() string

    // Kind returns the Field's reflect Kind
    //
    // eg. time.Time's kind is a struct
    Kind() reflect.Kind

    // Type returns the Field's reflect Type
    //
    // // eg. time.Time's type is time.Time
    Type() reflect.Type

    // returns the FieldError's translated error
    // from the provided 'ut.Translator' and registered 'TranslationFunc'
    //
    // NOTE: if no registered translator can be found it returns the same as
    // calling fe.Error()
    Translate(ut ut.Translator) string
}

 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

type FieldLevel
type FieldLevel interface {

    // returns the top level struct, if any
    Top() reflect.Value

    // returns the current fields parent struct, if any or
    // the comparison value if called 'VarWithValue'
    Parent() reflect.Value

    // returns current field for validation
    Field() reflect.Value

    // returns the field's name with the tag
    // name taking precedence over the fields actual name.
    FieldName() string

    // returns the struct field's name
    StructFieldName() string

    // returns param for validation against current field
    Param() string

    // ExtractType gets the actual underlying type of field value.
    // It will dive into pointers, customTypes and return you the
    // underlying value and it's kind.
    ExtractType(field reflect.Value) (value reflect.Value, kind reflect.Kind, nullable bool)

    // traverses the parent struct to retrieve a specific field denoted by the provided namespace
    // in the param and returns the field, field kind and whether is was successful in retrieving
    // the field at all.
    //
    // NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
    // could not be retrieved because it didn't exist.
    //
    // Deprecated: Use GetStructFieldOK2() instead which also return if the value is nullable.
    GetStructFieldOK() (reflect.Value, reflect.Kind, bool)

    // GetStructFieldOKAdvanced is the same as GetStructFieldOK except that it accepts the parent struct to start looking for
    // the field and namespace allowing more extensibility for validators.
    //
    // Deprecated: Use GetStructFieldOKAdvanced2() instead which also return if the value is nullable.
    GetStructFieldOKAdvanced(val reflect.Value, namespace string) (reflect.Value, reflect.Kind, bool)

    // traverses the parent struct to retrieve a specific field denoted by the provided namespace
    // in the param and returns the field, field kind, if it's a nullable type and whether is was successful in retrieving
    // the field at all.
    //
    // NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
    // could not be retrieved because it didn't exist.
    GetStructFieldOK2() (reflect.Value, reflect.Kind, bool, bool)

    // GetStructFieldOKAdvanced is the same as GetStructFieldOK except that it accepts the parent struct to start looking for
    // the field and namespace allowing more extensibility for validators.
    GetStructFieldOKAdvanced2(val reflect.Value, namespace string) (reflect.Value, reflect.Kind, bool, bool)
}

1

type FilterFunc func(ns []byte) bool

1

type Func func(fl FieldLevel) bool

1

type FuncCtx func(ctx context.Context, fl FieldLevel) bool

1
2
3

type InvalidValidationError struct {
    Type reflect.Type
}

1

func (e *InvalidValidationError) Error() string

1

type RegisterTranslationsFunc func(ut ut.Translator) error

 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

type StructLevel interface {
    // returns the main validation object, in case one wants to call validations internally.
    // this is so you don't have to use anonymous functions to get access to the validate
    // instance.
    Validator() *Validate

    // returns the top level struct, if any
    Top() reflect.Value

    // returns the current fields parent struct, if any
    Parent() reflect.Value

    // returns the current struct.
    Current() reflect.Value

    // ExtractType gets the actual underlying type of field value.
    // It will dive into pointers, customTypes and return you the
    // underlying value and its kind.
    ExtractType(field reflect.Value) (value reflect.Value, kind reflect.Kind, nullable bool)

    // reports an error just by passing the field and tag information
    //
    // NOTES:
    //
    // fieldName and altName get appended to the existing namespace that
    // validator is on. e.g. pass 'FirstName' or 'Names[0]' depending
    // on the nesting
    //
    // tag can be an existing validation tag or just something you make up
    // and process on the flip side it's up to you.
    ReportError(field interface{}, fieldName, structFieldName string, tag, param string)

    // reports an error just by passing ValidationErrors
    //
    // NOTES:
    //
    // relativeNamespace and relativeActualNamespace get appended to the
    // existing namespace that validator is on.
    // e.g. pass 'User.FirstName' or 'Users[0].FirstName' depending
    // on the nesting. most of the time they will be blank, unless you validate
    // at a level lower the the current field depth
    ReportValidationErrors(relativeNamespace, relativeActualNamespace string, errs ValidationErrors)
}

1

type StructLevelFunc func(sl StructLevel)

1

type StructLevelFuncCtx func(ctx context.Context, sl StructLevel)

1

type TagNameFunc func(field reflect.StructField) string

1

type TranslationFunc func(ut ut.Translator, fe FieldError) string

1
2
3

type Validate struct {
// contains filtered or unexported fields
}

1

func New() *Validate

1

func (v *Validate) RegisterAlias(alias, tags string)

1

func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{})

1

func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interface{})

1

func (v *Validate) RegisterStructValidationCtx(fn StructLevelFuncCtx, types ...interface{})

1

func (v *Validate) RegisterTagNameFunc(fn TagNameFunc)

1
2
3
4
5
6
7

validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
    name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
    if name == "-" {
        return ""
    }
    return name
})

1

func (v *Validate) RegisterTranslation(tag string, trans ut.Translator, registerFn,RegisterTranslationsFunc, translationFn TranslationFunc) (err error)

1
2

func (v *Validate) RegisterValidation(tag string, fn Func, callValidationEvenIfNull ...bool)
 error

1
2

func (v *Validate) RegisterValidationCtx(tag string, fn FuncCtx, callValidationEvenIfNull
...bool) error

1

func (v *Validate) SetTagName(name string)

1

func (v *Validate) Struct(s interface{}) error

1

func (v *Validate) StructCtx(ctx context.Context, s interface{}) (err error)

1

func (v *Validate) StructExcept(s interface{}, fields ...string) error

1
2

func (v *Validate) StructExceptCtx(ctx context.Context, s interface{}, fields ...string)
(err error)

1

func (v *Validate) StructFiltered(s interface{}, fn FilterFunc) error

1
2

func (v *Validate) StructFilteredCtx(ctx context.Context, s interface{}, fn FilterFunc)
(err error)

1

func (v *Validate) StructPartial(s interface{}, fields ...string) error

1
2

func (v *Validate) StructPartialCtx(ctx context.Context, s interface{}, fields ...string)
(err error)

1

func (v *Validate) Var(field interface{}, tag string) error

1
2

var i int
validate.Var(i, "gt=1,lt=10")

1

func (v *Validate) VarCtx(ctx context.Context, field interface{}, tag string) (err error)

1
2

var i int
validate.Var(i, "gt=1,lt=10")

1

func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string) error

1
2
3

s1 := "abcd"
s2 := "abcd"
validate.VarWithValue(s1, s2, "eqcsfield") // returns true

1
2

func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other interface{}
, tag string) (err error)

1
2
3

s1 := "abcd"
s2 := "abcd"
validate.VarWithValue(s1, s2, "eqcsfield") // returns true

1

type ValidationErrors []FieldError

1

func (ve ValidationErrors) Error() string

1

func (ve ValidationErrors) Translate(ut ut.Translator) ValidationErrorsTranslations

1

type ValidationErrorsTranslations map[string]string

1

Usage: -

1

Usage: |

1

Usage: structonly

1

Usage: nostructlevel

1

Usage: omitempty

1

Usage: dive

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

Example #1

[][]string with validation tag "gt=0,dive,len=1,dive,required"
// gt=0 will be applied to []
// len=1 will be applied to []string
// required will be applied to string
Example #2

[][]string with validation tag "gt=0,dive,dive,required"
// gt=0 will be applied to []
// []string will be spared validation
// required will be applied to string

1

Usage: dive,keys,othertagvalidation(s),endkeys,valuevalidationtags

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

Example #1

map[string]string with validation tag "gt=0,dive,keys,eg=1|eq=2,endkeys,required"
// gt=0 will be applied to the map itself
// eg=1|eq=2 will be applied to the map keys
// required will be applied to map values
Example #2

map[[2]string]string with validation tag "gt=0,dive,keys,dive,eq=1|eq=2,endkeys,required"
// gt=0 will be applied to the map itself
// eg=1|eq=2 will be applied to each array element in the the map keys
// required will be applied to map values

1

Usage: required

1

Usage: required_with

1
2
3
4
5

// require the field if the Field1 is present:
Usage: required_with=Field1

// require the field if the Field1 or Field2 is present:
Usage: required_with=Field1 Field2

1

Usage: required_with_all

1
2

// require the field if the Field1 and Field2 is present:
Usage: required_with_all=Field1 Field2

1

Usage: required_without

1
2
3
4
5

// require the field if the Field1 is not present:
Usage: required_without=Field1

// require the field if the Field1 or Field2 is not present:
Usage: required_without=Field1 Field2

1

Usage: required_without_all

1
2

// require the field if the Field1 and Field2 is not present:
Usage: required_without_all=Field1 Field2

1

Usage: isdefault

1

Usage: len=10

1

Usage: max=10

1

Usage: min=10

1

Usage: eq=10

1

Usage: ne=10

1
2

Usage: oneof=red green
       oneof=5 7 9

1

Usage: gt

1
2
3
4
5
6
7

Example #1

Usage: gt=10

Example #2 (time.Time)

For time.Time ensures the time value is greater than time.Now.UTC().

1

Usage: gt

1
2
3
4
5
6
7

Example #1

Usage: gte=10

Example #2 (time.Time)

For time.Time ensures the time value is greater than or equal to time.Now.UTC().

1

Usage: lt

1
2
3
4

Example #1

Usage: lt=10
Example #2 (time.Time) For time.Time ensures the time value is less than time.Now.UTC().

1
2
3
4
5
6
7
8

Example #1

Usage: lte=10
Example #2 (time.Time)

For time.Time ensures the time value is less than or equal to time.Now.UTC().

Usage: lte

1
2

// Validation on Password field using:
Usage: eqfield=ConfirmPassword

1
2

// Validating by field:
validate.VarWithValue(password, confirmpassword, "eqfield")

1

Usage: eqcsfield=InnerStructField.Field)

1
2
3
4
5
6
7

// Confirm two colors are not the same:
//
// Validation on Color field:
Usage: nefield=Color2

// Validating by field:
validate.VarWithValue(color1, color2, "nefield")

1

Usage: necsfield=InnerStructField.Field

1
2
3
4
5
6
7
8

Example #1:

// Validation on End field using:
validate.Struct Usage(gtfield=Start)
Example #2:

// Validating by field:
validate.VarWithValue(start, end, "gtfield")

1

Usage: gtcsfield=InnerStructField.Field

1
2
3
4
5
6
7
8

Example #1:

// Validation on End field using:
validate.Struct Usage(gtefield=Start)
Example #2:

// Validating by field:
validate.VarWithValue(start, end, "gtefield")

1

Usage: gtecsfield=InnerStructField.Field

1
2
3
4
5
6
7
8

Example #1:

// Validation on End field using:
validate.Struct Usage(ltfield=Start)
Example #2:

// Validating by field:
validate.VarWithValue(start, end, "ltfield")

1

Usage: ltcsfield=InnerStructField.Field

1
2
3
4
5
6
7
8

Example #1:

// Validation on End field using:
validate.Struct Usage(ltefield=Start)
Example #2:

// Validating by field:
validate.VarWithValue(start, end, "ltefield")

1

Usage: ltecsfield=InnerStructField.Field

1

Usage: containsfield=InnerStructField.Field

1

Usage: excludesfield=InnerStructField.Field

1

Usage: unique

1

Usage: alpha

1

Usage: alphanum

1

Usage: alphaunicode

1

Usage: alphanumunicode

1

Usage: numeric

1

Usage: hexadecimal

1

Usage: hexcolor

1

Usage: rgb

1

Usage: rgba

1

Usage: hsl

1

Usage: hsla

1

Usage: email

1

Usage: file

1

Usage: url

1

Usage: uri

1

Usage: urn_rfc2141

1

Usage: base64

1

Usage: base64url

1

Usage: btc_addr

1

Usage: btc_addr_bech32

1

Usage: eth_addr

1

Usage: contains=@

1

Usage: containsany=!@#?

1

Usage: containsrune=@

1

Usage: excludes=@

1

Usage: excludesall=!@#?

1

Usage: excludesrune=@

1

Usage: startswith=hello

1

Usage: endswith=goodbye

1

Usage: isbn

1

Usage: isbn10

1

Usage: isbn13

1

Usage: uuid

1

Usage: uuid3

1

Usage: uuid4

1

Usage: uuid5

1

Usage: ascii

1

Usage: printascii

1

Usage: multibyte

1

Usage: datauri

1

Usage: latitude

1

Usage: longitude

1

Usage: ssn

1

Usage: ip

1

Usage: ipv4

1

Usage: ipv6

1

Usage: cidr

1

Usage: cidrv4

1

Usage: cidrv6

1

Usage: tcp_addr

1

Usage: tcp4_addr

1

Usage: tcp6_addr

1

Usage: udp_addr

1

Usage: udp4_addr

1

Usage: udp6_addr

1

Usage: ip_addr

1

Usage: ip4_addr

1

Usage: ip6_addr

1

Usage: unix_addr

1

Usage: mac

1

Usage: hostname

1

Usage: hostname_rfc1123 or if you want to continue to use 'hostname' in your tags, create an alias.

1

Usage: fqdn

1

Usage: html

1

Usage: html_encoded

1

Usage: url_encoded

1

Usage: dir