DevShelf

Appearance

go-validator 验证规则 ​

引言 ​

go-validator 提供了丰富的验证规则，允许开发者在 Go 语言项目中轻松实现数据的验证和校验。本文档将详细解释各种可用的验证规则以及它们的用法。

验证规则概述 ​

以下是一些常用的验证规则，你可以根据需要选择适合你的应用的规则：

  • required：字段必填
  • min：字段长度或数值最小值
  • max：字段长度或数值最大值
  • email：字段必须是有效的电子邮件地址
  • url：字段必须是有效的 URL
  • regexp：字段必须匹配指定的正则表达式
  • length：字段长度必须在指定范围内
  • eq：字段值必须等于指定值
  • ne：字段值不得等于指定值
  • lt：字段值必须小于指定值
  • lte：字段值必须小于或等于指定值
  • gt：字段值必须大于指定值
  • gte：字段值必须大于或等于指定值
  • uuid：字段值必须是有效的 UUID
  • ip：字段值必须是有效的 IP 地址
  • ipv4：字段值必须是有效的 IPv4 地址
  • ipv6：字段值必须是有效的 IPv6 地址

验证规则详解 ​

字段必填 ​


required ​

  • 描述：字段必填

  • 用法：validate:"required"

  • 示例：

    go
    type User struct {
    Name string `validate:"required"`
}

required_if ​

  • 描述：字段必填（如果 Field1==1，则 Field2 必填）

  • 用法：validate:"required_if=FieldName value"

  • 示例：

    go
    type Inner struct {
		Field *string
}
test := struct {
		Inner   *Inner
		FieldE  string            `validate:"omitempty" json:"field_e"`
		FieldER string            `validate:"required_if=FieldE test" json:"field_er"`
		Field1  string            `validate:"omitempty" json:"field_1"`
		Field2  *string           `validate:"required_if=Field1 test" json:"field_2"`
		Field3  map[string]string `validate:"required_if=Field2 test" json:"field_3"`
		Field4  interface{}       `validate:"required_if=Field3 1" json:"field_4"`
		Field5  []int             `validate:"required_if=Inner.Field test" json:"field_5"`
		Field6  uint              `validate:"required_if=Field5 1" json:"field_6"`
		Field7  float32           `validate:"required_if=Field6 1" json:"field_7"`
		Field8  float64           `validate:"required_if=Field7 1.0" json:"field_8"`
		Field9  Inner             `validate:"required_if=Field1 test" json:"field_9"`
		Field10 *Inner            `validate:"required_if=Field1 test" json:"field_10"`
	}{
		Inner:  &Inner{Field: &fieldVal},
		Field2: "test",
		Field3: map[string]string{"key": "val"},
		Field4: "test",
  	Field5: []int{2},
	}

    注意

    当字段类型为 map 或切片时，判断的是长度。


required_unless ​

  • 描述：字段必填（除非 Field1==1，否则 Field 必填）

  • 用法：validate:"required_unless=FieldName value"

  • 示例：

    go
    type Inner struct {
		Field *string
	}

	fieldVal := "test"
	test := struct {
		Inner   *Inner
		FieldE  string            `validate:"omitempty" json:"field_e"`
		FieldER string            `validate:"required_unless=FieldE test" json:"field_er"`
		Field1  string            `validate:"omitempty" json:"field_1"`
		Field2  *string           `validate:"required_unless=Field1 test" json:"field_2"`
		Field3  map[string]string `validate:"required_unless=Field2 test" json:"field_3"`
		Field4  interface{}       `validate:"required_unless=Field3 1" json:"field_4"`
		Field5  int               `validate:"required_unless=Inner.Field test" json:"field_5"`
		Field6  uint              `validate:"required_unless=Field5 2" json:"field_6"`
		Field7  float32           `validate:"required_unless=Field6 0" json:"field_7"`
		Field8  float64           `validate:"required_unless=Field7 0.0" json:"field_8"`
		Field9  bool              `validate:"omitempty" json:"field_9"`
		Field10 string            `validate:"required_unless=Field9 true" json:"field_10"`
		Field11 Inner             `validate:"required_unless=Field9 true" json:"field_11"`
		Field12 *Inner            `validate:"required_unless=Field9 true" json:"field_12"`
	}{
		FieldE: "test",
		Field2: &fieldVal,
		Field3: map[string]string{"key": "val"},
		Field4: "test",
		Field5: 2,
		Field9: true,
	}

    注意

    当字段类型为 map 或切片时，判断的是长度。


skip_unless ​

  • 描述：字段必填（除非指定的字段等于特定值，否则跳过必填校验）

  • 用法：validate:"skip_unless=FieldName value"

  • 示例：

    go
    type Inner struct {
		Field *string
	}

	fieldVal := "test1"
	test := struct {
		Inner   *Inner
		FieldE  string            `validate:"omitempty" json:"field_e"`
		FieldER string            `validate:"skip_unless=FieldE test" json:"field_er"`
		Field1  string            `validate:"omitempty" json:"field_1"`
		Field2  *string           `validate:"skip_unless=Field1 test" json:"field_2"`
		Field3  map[string]string `validate:"skip_unless=Field2 test" json:"field_3"`
		Field4  interface{}       `validate:"skip_unless=Field3 1" json:"field_4"`
		Field5  int               `validate:"skip_unless=Inner.Field test" json:"field_5"`
		Field6  uint              `validate:"skip_unless=Field5 2" json:"field_6"`
		Field7  float32           `validate:"skip_unless=Field6 1" json:"field_7"`
		Field8  float64           `validate:"skip_unless=Field7 1.0" json:"field_8"`
		Field9  bool              `validate:"omitempty" json:"field_9"`
		Field10 string            `validate:"skip_unless=Field9 false" json:"field_10"`
		Field11 Inner             `validate:"skip_unless=Field9 false" json:"field_11"`
		Field12 *Inner            `validate:"skip_unless=Field9 false" json:"field_12"`
	}{
		FieldE: "test1",
		Field2: &fieldVal,
		Field3: map[string]string{"key": "val"},
		Field4: "test",
		Field5: 3,
		Field9: true,
	}

    注意

    当字段类型为 map 或切片时，判断的是长度。


required_with ​

  • 描述：字段必填（当指定的其他字段存在时，该字段也必须存在且不为空）

  • 用法：validate:"required_with=FieldName1 FieldName2"

  • 示例：

    go
    type Inner struct {
    Field *string
}

fieldVal := "test1"
test := struct {
    Inner   *Inner
    FieldA  string            `validate:"omitempty" json:"field_a"`
    FieldB  string            `validate:"required_with=FieldA" json:"field_b"`
    Field1  string            `validate:"omitempty" json:"field_1"`
    Field2  *string           `validate:"required_with=Field1" json:"field_2"`
    Field3  map[string]string `validate:"required_with=Field2" json:"field_3"`
    Field4  interface{}       `validate:"required_with=Field3" json:"field_4"`
    Field5  int               `validate:"required_with=Inner.Field" json:"field_5"`
    Field6  uint              `validate:"required_with=Field5" json:"field_6"`
    Field7  float32           `validate:"required_with=Field6" json:"field_7"`
    Field8  float64           `validate:"required_with=Field7" json:"field_8"`
    Field9  bool              `validate:"omitempty" json:"field_9"`
    Field10 string            `validate:"required_with=Field9" json:"field_10"`
    Field11 Inner             `validate:"required_with=Field9" json:"field_11"`
    Field12 *Inner            `validate:"required_with=Field9" json:"field_12"`
}{
    FieldA: "test1",
    Field2: &fieldVal,
    Field3: map[string]string{"key": "val"},
    Field4: "test",
    Field5: 3,
    Field9: true,
}

    注意

    当字段类型为 map 或切片时，判断的是长度。


required_with_all ​

  • 描述：字段必填（当指定的所有其他字段都存在时，该字段也必须存在且不为空）

  • 用法：validate:"required_with_all=FieldName1 FieldName2"

  • 示例：

    go
    type Inner struct {
    Field *string
}

fieldVal := "test1"
test := struct {
    Inner   *Inner
    FieldA  string            `validate:"omitempty" json:"field_a"`
    FieldB  string            `validate:"required_with_all=FieldA FieldC" json:"field_b"`
    FieldC  string            `validate:"omitempty" json:"field_c"`
    Field1  string            `validate:"omitempty" json:"field_1"`
    Field2  *string           `validate:"required_with_all=Field1 Field3" json:"field_2"`
    Field3  *string           `validate:"omitempty" json:"field_3"`
    Field4  map[string]string `validate:"required_with_all=Field2 Field3" json:"field_4"`
    Field5  interface{}       `validate:"required_with_all=Field4 Field6" json:"field_5"`
    Field6  int               `validate:"omitempty" json:"field_6"`
    Field7  uint              `validate:"required_with_all=Field5 Field6" json:"field_7"`
    Field8  float32           `validate:"required_with_all=Field7 Field8" json:"field_8"`
    Field9  bool              `validate:"omitempty" json:"field_9"`
    Field10 string            `validate:"required_with_all=Field9 Field11" json:"field_10"`
    Field11 Inner             `validate:"omitempty" json:"field_11"`
    Field12 *Inner            `validate:"required_with_all=Field9 Field11" json:"field_12"`
}{
    FieldA: "test1",
    FieldC: "test2",
    Field2: &fieldVal,
    Field3: &fieldVal,
    Field4: map[string]string{"key": "val"},
    Field5: "test",
    Field6: 3,
    Field9: true,
}

    注意

    当字段类型为 map 或切片时，判断的是长度。


required_without ​

  • 描述：字段必填（当指定的其他字段中至少有一个不存在时，该字段必须存在且不为空）

  • 用法：validate:"required_without=FieldName1 FieldName2"

  • 示例：

    go
    type Inner struct {
    Field *string
}

fieldVal := "test1"
test := struct {
    Inner   *Inner
    FieldA  string            `validate:"omitempty" json:"field_a"`
    FieldB  string            `validate:"required_without=FieldA FieldC" json:"field_b"`
    FieldC  string            `validate:"omitempty" json:"field_c"`
    Field1  string            `validate:"omitempty" json:"field_1"`
    Field2  *string           `validate:"required_without=Field1 Field3" json:"field_2"`
    Field3  *string           `validate:"omitempty" json:"field_3"`
    Field4  map[string]string `validate:"required_without=Field2 Field3" json:"field_4"`
    Field5  interface{}       `validate:"required_without=Field4 Field6" json:"field_5"`
    Field6  int               `validate:"omitempty" json:"field_6"`
    Field7  uint              `validate:"required_without=Field5 Field6" json:"field_7"`
    Field8  float32           `validate:"required_without=Field7 Field8" json:"field_8"`
    Field9  bool              `validate:"omitempty" json:"field_9"`
    Field10 string            `validate:"required_without=Field9 Field11" json:"field_10"`
    Field11 Inner             `validate:"omitempty" json:"field_11"`
    Field12 *Inner            `validate:"required_without=Field9 Field11" json:"field_12"`
}{
    FieldA: "",
    FieldC: "",
    Field2: nil,
    Field3: nil,
    Field4: nil,
    Field5: nil,
    Field6: 0,
    Field9: false,
}

    注意

    当字段类型为 map 或切片时，判断的是长度。


required_without_all ​

  • 描述：字段必填（当指定的所有其他字段都不存在时，该字段必须存在且不为空）

  • 用法：validate:"required_without_all=FieldName1 FieldName2"

  • 示例：

    go
    type Inner struct {
    Field *string
}

fieldVal := "test1"
test := struct {
    Inner   *Inner
    FieldA  string            `validate:"omitempty" json:"field_a"`
    FieldB  string            `validate:"required_without_all=FieldA FieldC" json:"field_b"`
    FieldC  string            `validate:"omitempty" json:"field_c"`
    Field1  string            `validate:"omitempty" json:"field_1"`
    Field2  *string           `validate:"required_without_all=Field1 Field3" json:"field_2"`
    Field3  *string           `validate:"omitempty" json:"field_3"`
    Field4  map[string]string `validate:"required_without_all=Field2 Field3" json:"field_4"`
    Field5  interface{}       `validate:"required_without_all=Field4 Field6" json:"field_5"`
    Field6  int               `validate:"omitempty" json:"field_6"`
    Field7  uint              `validate:"required_without_all=Field5 Field6" json:"field_7"`
    Field8  float32           `validate:"required_without_all=Field7 Field8" json:"field_8"`
    Field9  bool              `validate:"omitempty" json:"field_9"`
    Field10 string            `validate:"required_without_all=Field9 Field11" json:"field_10"`
    Field11 Inner             `validate:"omitempty" json:"field_11"`
    Field12 *Inner            `validate:"required_without_all=Field9 Field11" json:"field_12"`
}{
    FieldA: "",
    FieldC: "",
    Field2: nil,
    Field3: nil,
    Field4: nil,
    Field5: nil,
    Field6: 0,
    Field9: false,
}

    注意

    当字段类型为 map 或切片时，判断的是长度。


excluded_if ​

  • 描述：字段排除（当指定的字段等于特定值时，该字段必须不存在或为空）

  • 用法：validate:"excluded_if=FieldName value"

  • 示例：

    go
    type Inner struct {
    Field *string
}

fieldVal := "test1"
test := struct {
    Inner   *Inner
    FieldA  string            `validate:"omitempty" json:"field_a"`
    FieldB  string            `validate:"excluded_if=FieldA test" json:"field_b"`
    Field1  string            `validate:"omitempty" json:"field_1"`
    Field2  *string           `validate:"excluded_if=Field1 test" json:"field_2"`
    Field3  map[string]string `validate:"excluded_if=Field2 test" json:"field_3"`
    Field4  interface{}       `validate:"excluded_if=Field3 1" json:"field_4"`
    Field5  int               `validate:"excluded_if=Inner.Field test" json:"field_5"`
    Field6  uint              `validate:"excluded_if=Field5 2" json:"field_6"`
    Field7  float32           `validate:"excluded_if=Field6 1" json:"field_7"`
    Field8  float64           `validate:"excluded_if=Field7 1.0" json:"field_8"`
    Field9  bool              `validate:"omitempty" json:"field_9"`
    Field10 string            `validate:"excluded_if=Field9 false" json:"field_10"`
    Field11 Inner             `validate:"excluded_if=Field9 false" json:"field_11"`
    Field12 *Inner            `validate:"excluded_if=Field9 false" json:"field_12"`
}{
    FieldA: "test",
    Field2: &fieldVal,
    Field3: map[string]string{"key": "val"},
    Field4: "test",
    Field5: 3,
    Field9: true,
}

    注意

    当字段类型为 map 或切片时，判断的是长度。


excluded_with ​

  • 描述：字段排除（当指定的其他字段中至少有一个存在时，该字段必须不存在或为空）

  • 用法：validate:"excluded_with=FieldName1 FieldName2"

  • 示例：

    假设我们有一个用户注册表单，其中包含字段 email 和 phone。我们希望用户在提供电子邮件地址时，不能同时提供电话号码，反之亦然。我们可以使用 excluded_with 来实现这一要求。

    go
    type UserRegistration struct {
    Email string `validate:"omitempty,email"`
    Phone string `validate:"omitempty,excluded_with=Email"`
}

    在这个示例中，如果 Email 字段不为空，那么 Phone 字段必须为空，反之亦然。

    注意

    当字段类型为 map 或切片时，判断的是长度。


excluded_with_all ​

  • 描述：字段排除（当指定的所有其他字段都存在时，该字段必须不存在或为空）

  • 用法：validate:"excluded_with_all=FieldName1 FieldName2"

  • 示例：

    假设我们有一个用户注册表单，其中包含字段 email、phone 和 username。我们希望用户在提供电子邮件地址和电话号码时，不能同时提供用户名。我们可以使用 excluded_with_all 来实现这一要求。

    go
    type UserRegistration struct {
    Email    string `validate:"omitempty,email"`
    Phone    string `validate:"omitempty"`
    Username string `validate:"omitempty,excluded_with_all=Email Phone"`
}

    在这个示例中，如果 Email 和 Phone 字段都不为空，那么 Username 字段必须为空。

    注意

    当字段类型为 map 或切片时，判断的是长度。


excluded_without ​

  • 描述：字段排除（当指定的其他字段中至少有一个不存在时，该字段必须不存在或为空）

  • 用法：validate:"excluded_without=FieldName1 FieldName2"

  • 示例：

    假设我们有一个用户注册表单，其中包含字段 email、phone 和 username。我们希望用户在未提供电子邮件地址或电话号码时，不能提供用户名。我们可以使用 excluded_without 来实现这一要求。

    go
    type UserRegistration struct {
    Email    string `validate:"omitempty,email"`
    Phone    string `validate:"omitempty"`
    Username string `validate:"omitempty,excluded_without=Email Phone"`
}

    在这个示例中，如果 Email 或 Phone 字段为空，那么 Username 字段必须为空。

    注意

    当字段类型为 map 或切片时，判断的是长度。


excluded_without_all ​

  • 描述：字段排除（当指定的所有其他字段都不存在时，该字段必须不存在或为空）

  • 用法：validate:"excluded_without_all=FieldName1 FieldName2"

  • 示例：

    假设我们有一个用户注册表单，其中包含字段 email、phone 和 username。我们希望用户在未提供电子邮件地址和电话号码时，不能提供用户名。我们可以使用 excluded_without_all 来实现这一要求。

    go
    type UserRegistration struct {
    Email    string `validate:"omitempty,email"`
    Phone    string `validate:"omitempty"`
    Username string `validate:"omitempty,excluded_without_all=Email Phone"`
}

    在这个示例中，如果 Email 和 Phone 字段都为空，那么 Username 字段必须为空。

    注意

    当字段类型为 map 或切片时，判断的是长度。

比较 ​


eq ​

  • 描述：字段值必须等于指定的值。

  • 用法：validate:"eq=Value"

  • 示例：

    假设我们有一个配置结构体，其中包含一个字段 LogLevel，我们希望该字段的值必须等于 "info"。我们可以使用 eq 来实现这一要求。

    go
    type Config struct {
    LogLevel string `validate:"eq=info"`
}

    在这个示例中，LogLevel 字段的值必须等于 "info"。

    注意

    当字段类型为数字时，Value 应该是一个数字；当字段类型为字符串时，Value 应该是一个字符串。


eq_ignore_case ​

  • 描述：字段值必须等于指定的值，忽略大小写。

  • 用法：validate:"eq_ignore_case=Value"

  • 示例：

    假设我们有一个用户配置结构体，其中包含一个字段 Role，我们希望该字段的值必须等于 "admin"，忽略大小写。我们可以使用 eq_ignore_case 来实现这一要求。

    go
    type UserConfig struct {
    Role string `validate:"eq_ignore_case=admin"`
}

    在这个示例中，Role 字段的值必须等于 "admin"，忽略大小写。例如，"Admin"、"ADMIN" 和 "admin" 都是有效的。

    注意

    该验证器仅适用于字符串类型。

gt ​

  • 描述：字段值必须大于指定的值。

  • 用法：validate:"gt=Value"

  • 示例：

    假设我们有一个产品结构体，其中包含一个字段 Price，我们希望该字段的值必须大于 100。我们可以使用 gt 来实现这一要求。

    go
    type Product struct {
    Price float64 `validate:"gt=100"`
}

    在这个示例中，Price 字段的值必须大于 100。

    注意

    该验证器适用于数字类型和字符串类型（字符串长度比较）。


gte ​

  • 描述：字段值必须大于或等于指定的值。

  • 用法：validate:"gte=Value"

  • 示例：

    假设我们有一个订单结构体，其中包含一个字段 TotalAmount，我们希望该字段的值必须大于或等于 50。我们可以使用 gte 来实现这一要求。

    go
    type Order struct {
    TotalAmount float64 `validate:"gte=50"`
}

    在这个示例中，TotalAmount 字段的值必须大于或等于 50。

    注意

    该验证器适用于数字类型和字符串类型（字符串长度比较）。


lt ​

  • 描述：字段值必须小于指定的值。

  • 用法：validate:"lt=Value"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Age，我们希望该字段的值必须小于 18。我们可以使用 lt 来实现这一要求。

    go
    type User struct {
    Age int `validate:"lt=18"`
}

    在这个示例中，Age 字段的值必须小于 18。

    注意

    该验证器适用于数字类型和字符串类型（字符串长度比较）。


lte ​

  • 描述：字段值必须小于或等于指定的值。

  • 用法：validate:"lte=Value"

  • 示例：

    假设我们有一个产品结构体，其中包含一个字段 Stock，我们希望该字段的值必须小于或等于 100。我们可以使用 lte 来实现这一要求。

    go
    type Product struct {
    Stock int `validate:"lte=100"`
}

    在这个示例中，Stock 字段的值必须小于或等于 100。

    注意

    该验证器适用于数字类型和字符串类型（字符串长度比较）。


ne ​

  • 描述：字段值必须不等于指定的值。

  • 用法：validate:"ne=Value"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Status，我们希望该字段的值不能等于 "inactive"。我们可以使用 ne 来实现这一要求。

    go
    type User struct {
    Status string `validate:"ne=inactive"`
}

    在这个示例中，Status 字段的值不能等于 "inactive"。

    注意

    该验证器适用于数字类型和字符串类型。


ne_ignore_case ​

  • 描述：字段值必须不等于指定的值，忽略大小写。

  • 用法：validate:"ne_ignore_case=Value"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Role，我们希望该字段的值不能等于 "guest"，忽略大小写。我们可以使用 ne_ignore_case 来实现这一要求。

    go
    type User struct {
    Role string `validate:"ne_ignore_case=guest"`
}

    在这个示例中，Role 字段的值不能等于 "guest"，忽略大小写。例如，"Guest"、"GUEST" 和 "guest" 都是无效的。

    注意

    该验证器仅适用于字符串类型。

最大值/最小值/长度 ​


max ​

  • 描述：字段值必须小于或等于指定的最大值。

  • 用法：validate:"max=Value"

  • 示例：

    假设我们有一个产品结构体，其中包含一个字段 Quantity，我们希望该字段的值必须小于或等于 100。我们可以使用 max 来实现这一要求。

    go
    type Product struct {
    Quantity int `validate:"max=100"`
}

    在这个示例中，Quantity 字段的值必须小于或等于 100。

    注意

    该验证器适用于数字类型、字符串类型、map、切片（字符串、map、切片是长度比较）。


min ​

  • 描述：字段值必须大于或等于指定的最小值。

  • 用法：validate:"min=Value"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Age，我们希望该字段的值必须大于或等于 18。我们可以使用 min 来实现这一要求。

    go
    type User struct {
    Age int `validate:"min=18"`
}

    在这个示例中，Age 字段的值必须大于或等于 18。

    注意

    该验证器适用于数字类型、字符串类型、map、切片（字符串、map、切片是长度比较）。


len ​

  • 描述：字段值的长度必须等于指定的长度。

  • 用法：validate:"len=Value"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Username，我们希望该字段的长度必须等于 8。我们可以使用 len 来实现这一要求。

    go
    type User struct {
    Username string `validate:"len=8"`
}

    在这个示例中，Username 字段的长度必须等于 8。

    注意

    该验证器适用于字符串类型、map、切片。

在.....之中 ​


oneof ​

  • 描述：字段值必须是给定值之一。

  • 用法：validate:"oneof=Value1 Value2 Value3"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Status，我们希望该字段的值必须是 "active" 或 "inactive"。我们可以使用 oneof 来实现这一要求。

    go
    type User struct {
    Status string `validate:"oneof=active inactive"`
}

    在这个示例中，Status 字段的值必须是 "active" 或 "inactive"。

    注意

    该验证器适用于字符串类型和数字类型。


唯一校验 ​


unique 唯一 ​

  • 描述：字段值必须是唯一的。

  • 用法：validate:"unique"

  • 示例：

    假设我们有一个用户结构体，其中包含一个字段 Field1，我们希望该字段的值必须是唯一的。我们可以使用 unique 来实现这一要求。

    go
    type User struct {
    Field1 []string `validate:"unique"`
  	Field2 []*string `validate:"unique"`
  	Field3 []map[string]interface{} `validate:"unique"`
}

    在这个示例中，Field1 字段的值必须是唯一的。

    注意

    1. 数组：该验证器适用于数组类型，确保数组中的每个元素都是唯一的。
    2. 切片：该验证器适用于切片类型，确保切片中的每个元素都是唯一的。
    3. 映射：该验证器适用于映射类型，确保映射中的每个值都是唯一的。
    4. 结构体：该验证器适用于结构体类型，确保结构体中的指定字段是唯一的。
    5. 结构体切片：该验证器适用于结构体切片类型，确保结构体切片中的指定字段在切片范围内是唯一的。
    6. 结构体指针切片：该验证器适用于结构体指针切片类型，确保结构体指针切片中的指定字段在切片范围内是唯一的。

  • 详细示例

    以下是 unique 验证器的详细示例，涵盖了数组、切片、映射以及结构体等多种数据类型。

go
// 数组 切片 Map
tests := []struct {
		param    interface{}
		expected bool
	}{
		// Arrays
		{[2]string{"a", "b"}, true},
		{[2]int{1, 2}, true},
		{[2]float64{1, 2}, true},
		{[2]interface{}{"a", "b"}, true},
		{[2]interface{}{"a", 1}, true},
		{[2]float64{1, 1}, false},
		{[2]int{1, 1}, false},
		{[2]string{"a", "a"}, false},
		{[2]interface{}{"a", "a"}, false},
		{[4]interface{}{"a", 1, "b", 1}, false},
		{[2]*string{stringPtr("a"), stringPtr("b")}, true},
		{[2]*int{intPtr(1), intPtr(2)}, true},
		{[2]*float64{float64Ptr(1), float64Ptr(2)}, true},
		{[2]*string{stringPtr("a"), stringPtr("a")}, false},
		{[2]*float64{float64Ptr(1), float64Ptr(1)}, false},
		{[2]*int{intPtr(1), intPtr(1)}, false},
		// Slices
		{[]string{"a", "b"}, true},
		{[]int{1, 2}, true},
		{[]float64{1, 2}, true},
		{[]interface{}{"a", "b"}, true},
		{[]interface{}{"a", 1}, true},
		{[]float64{1, 1}, false},
		{[]int{1, 1}, false},
		{[]string{"a", "a"}, false},
		{[]interface{}{"a", "a"}, false},
		{[]interface{}{"a", 1, "b", 1}, false},
		{[]*string{stringPtr("a"), stringPtr("b")}, true},
		{[]*int{intPtr(1), intPtr(2)}, true},
		{[]*float64{float64Ptr(1), float64Ptr(2)}, true},
		{[]*string{stringPtr("a"), stringPtr("a")}, false},
		{[]*float64{float64Ptr(1), float64Ptr(1)}, false},
		{[]*int{intPtr(1), intPtr(1)}, false},
		// Maps
		{map[string]string{"one": "a", "two": "b"}, true},
		{map[string]int{"one": 1, "two": 2}, true},
		{map[string]float64{"one": 1, "two": 2}, true},
		{map[string]interface{}{"one": "a", "two": "b"}, true},
		{map[string]interface{}{"one": "a", "two": 1}, true},
		{map[string]float64{"one": 1, "two": 1}, false},
		{map[string]int{"one": 1, "two": 1}, false},
		{map[string]string{"one": "a", "two": "a"}, false},
		{map[string]interface{}{"one": "a", "two": "a"}, false},
		{map[string]interface{}{"one": "a", "two": 1, "three": "b", "four": 1}, false},
		{map[string]*string{"one": stringPtr("a"), "two": stringPtr("a")}, false},
		{map[string]*string{"one": stringPtr("a"), "two": stringPtr("b")}, true},
		{map[string]*int{"one": intPtr(1), "two": intPtr(1)}, false},
		{map[string]*int{"one": intPtr(1), "two": intPtr(2)}, true},
		{map[string]*float64{"one": float64Ptr(1.1), "two": float64Ptr(1.1)}, false},
		{map[string]*float64{"one": float64Ptr(1.1), "two": float64Ptr(1.2)}, true},
	}

// 结构体字段唯一
tests := []struct {
			param    interface{}
			expected bool
		}{
			{struct {
				A string `validate:"unique=B"`
				B string
			}{A: "abc", B: "bcd"}, true},
			{struct {
				A string `validate:"unique=B"`
				B string
			}{A: "abc", B: "abc"}, false},
		}
		
// 结构体切片唯一
testStructs := []struct {
		A string
		B string
	}{
		{A: "one", B: "two"},
		{A: "one", B: "three"},
	}

tests := []struct {
		target   interface{}
		param    string
		expected bool
	}{
		{testStructs, "unique", true},
		{testStructs, "unique=A", false},
		{testStructs, "unique=B", true},
	}

// 指针结构体切片唯一
testStructs := []*struct {
		A *string
		B *string
	}{
		{A: stringPtr("one"), B: stringPtr("two")},
		{A: stringPtr("one"), B: stringPtr("three")},
		{},
	}

tests := []struct {
		target   interface{}
		param    string
		expected bool
	}{
		{testStructs, "unique", true},
		{testStructs, "unique=A", false},
		{testStructs, "unique=B", true},
	}

字段比较 ​


eqcsfield ​

  • 描述：字段值必须等于另一个字段（跨结构体）的值。

  • 用法：validate:"eqcsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Age 字段值必须等于 Profile 结构体中的 UserAge 字段值。我们可以使用 eqcsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Age int `validate:"eqcsfield=Profile.UserAge"`
}

type Profile struct {
    UserAge int
}

    在这个示例中，User 结构体中的 Age 字段值必须等于 Profile 结构体中的 UserAge 字段值。

    注意

    该验证器适用于相同类型的字段。


eqfield ​

  • 描述：字段值必须等于同一结构体中的另一个字段的值。

  • 用法：validate:"eqfield=OtherField"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Password 字段值必须等于 ConfirmPassword 字段值。我们可以使用 eqfield 来实现这一要求。

    go
    type User struct {
    Password        string `validate:"eqfield=ConfirmPassword"`
    ConfirmPassword string
}

    在这个示例中，Password 字段值必须等于 ConfirmPassword 字段值。

    注意

    该验证器适用于相同类型的字段。


fieldcontains ​

  • 描述：字段值必须包含指定的子字符串。

  • 用法：validate:"fieldcontains=Substring"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Email 字段值必须包含 "@example.com"。我们可以使用 fieldcontains 来实现这一要求。

    go
    type User struct {
    Email string `validate:"fieldcontains=@example.com"`
}

    在这个示例中，Email 字段值必须包含 "@example.com"。

    注意

    该验证器适用于字符串类型的字段。


fieldexcludes

  • 描述：字段值必须不包含指定的子字符串。

  • 用法：validate:"fieldexcludes=Substring"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Username 字段值必须不包含 "admin"。我们可以使用 fieldexcludes 来实现这一要求。

    go
    type User struct {
    Username string `validate:"fieldexcludes=admin"`
}

    在这个示例中，Username 字段值必须不包含 "admin"。

    注意

    该验证器适用于字符串类型的字段。


gtcsfield ​

  • 描述：字段值必须大于另一个字段（跨结构体）的值。

  • 用法：validate:"gtcsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Age 字段值必须大于 Profile 结构体中的 UserAge 字段值。我们可以使用 gtcsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Age int `validate:"gtcsfield=Profile.UserAge"`
}

type Profile struct {
    UserAge int
}

    在这个示例中，User 结构体中的 Age 字段值必须大于 Profile 结构体中的 UserAge 字段值。

    注意

    该验证器适用于相同类型的字段。


gtecsfield ​

  • 描述：字段值必须大于或等于另一个字段（跨结构体）的值。

  • 用法：validate:"gtecsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Age 字段值必须大于或等于 Profile 结构体中的 UserAge 字段值。我们可以使用 gtecsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Age int `validate:"gtecsfield=Profile.UserAge"`
}

type Profile struct {
    UserAge int
}

    在这个示例中，User 结构体中的 Age 字段值必须大于或等于 Profile 结构体中的 UserAge 字段值。

    注意

    该验证器适用于相同类型的字段。


gtefield ​

  • 描述：字段值必须大于或等于同一结构体中的另一个字段的值。

  • 用法：validate:"gtefield=OtherField"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Age 字段值必须大于或等于 MinAge 字段值。我们可以使用 gtefield 来实现这一要求。

    go
    type User struct {
    Age    int `validate:"gtefield=MinAge"`
    MinAge int
}

    在这个示例中，Age 字段值必须大于或等于 MinAge 字段值。

    注意

    该验证器适用于相同类型的字段。


gtfield ​

  • 描述：字段值必须大于同一结构体中的另一个字段的值。

  • 用法：validate:"gtfield=OtherField"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Age 字段值必须大于 MinAge 字段值。我们可以使用 gtfield 来实现这一要求。

    go
    type User struct {
    Age    int `validate:"gtfield=MinAge"`
    MinAge int
}

    在这个示例中，Age 字段值必须大于 MinAge 字段值。

    注意

    该验证器适用于相同类型的字段。


ltcsfield ​

  • 描述：字段值必须小于另一个字段（跨结构体）的值。

  • 用法：validate:"ltcsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Age 字段值必须小于 Profile 结构体中的 UserAge 字段值。我们可以使用 ltcsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Age int `validate:"ltcsfield=Profile.UserAge"`
}

type Profile struct {
    UserAge int
}

    在这个示例中，User 结构体中的 Age 字段值必须小于 Profile 结构体中的 UserAge 字段值。

    注意

    该验证器适用于相同类型的字段。


ltecsfield ​

  • 描述：字段值必须小于或等于另一个字段（跨结构体）的值。

  • 用法：validate:"ltecsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Age 字段值必须小于或等于 Profile 结构体中的 UserAge 字段值。我们可以使用 ltecsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Age int `validate:"ltecsfield=Profile.UserAge"`
}

type Profile struct {
    UserAge int
}

    在这个示例中，User 结构体中的 Age 字段值必须小于或等于 Profile 结构体中的 UserAge 字段值。

    注意

    该验证器适用于相同类型的字段。


ltefield ​

  • 描述：字段值必须小于或等于同一结构体中的另一个字段的值。

  • 用法：validate:"ltefield=OtherField"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Age 字段值必须小于或等于 MaxAge 字段值。我们可以使用 ltefield 来实现这一要求。

    go
    type User struct {
    Age    int `validate:"ltefield=MaxAge"`
    MaxAge int
}

    在这个示例中，Age 字段值必须小于或等于 MaxAge 字段值。

    注意

    该验证器适用于相同类型的字段。


necsfield ​

  • 描述：字段值必须不等于另一个字段（跨结构体）的值。

  • 用法：validate:"necsfield=OtherStruct.OtherField"

  • 示例：

    假设我们有两个结构体 User 和 Profile，我们希望 User 结构体中的 Username 字段值必须不等于 Profile 结构体中的 UserUsername 字段值，并且在比较时忽略大小写。我们可以使用 necsfield 来实现这一要求。

    go
    type User struct {
  	Profile Profile
    Username string `validate:"necsfield=Profile.UserUsername"`
}

type Profile struct {
    UserUsername string
}

    在这个示例中，User 结构体中的 Username 字段值必须不等于 Profile 结构体中的 UserUsername 字段值。

    注意

    该验证器适用于字符串类型的字段。


nefield ​

  • 描述：字段值必须不等于同一结构体中的另一个字段的值。

  • 用法：validate:"nefield=OtherField"

  • 示例：

    假设我们有一个结构体 User，我们希望 User 结构体中的 Username 字段值必须不等于 OtherUsername 字段值。我们可以使用 nefield 来实现这一要求。

    go
    type User struct {
    Username     string `validate:"nefield=OtherUsername"`
    OtherUsername string
}

    在这个示例中，Username 字段值必须不等于 OtherUsername 字段值。

    注意

    该验证器适用于相同类型的字段。