• 多数据校验 - CheckStruct
    • 示例1，使用map指定规则及提示信息
    • 示例2，使用gvalid tag绑定规则及提示信息
    • 示例3，属性递归校验

    多数据校验 - CheckStruct

    CheckStruct的使用方式同CheckMap，除了第一个参数为struct类型的结构体对象（也可以是对象指针）。但是需要注意的一个细节是，struct的属性会有默认值，因此某些情况下会引起required规则的失效，因此根据实际情况配合多种规则一起校验会是一个比较严谨的做法。

    接口文档：https://godoc.org/github.com/gogf/gf/g/util/gvalid

    1. func CheckStruct(object interface{}, rules interface{}, msgs ...CustomMsg) *Error

    示例1，使用map指定规则及提示信息

    1. package main
    3. import (
    4.     "github.com/gogf/gf/g"
    5.     "github.com/gogf/gf/g/util/gvalid"
    6. )
    8. func main() {
    9.     type Object struct {
    10.         Name string
    11.         Age  int
    12.     }
    13.     rules := map[string]string {
    14.         "Name" : "required|length:6,16",
    15.         "Age"  : "between:18,30",
    16.     }
    17.     msgs  := map[string]interface{} {
    18.         "Name" : map[string]string {
    19.             "required" : "名称不能为空",
    20.             "length"   : "名称长度为:min到:max个字符",
    21.         },
    22.         "Age"  : "年龄为18到30周岁",
    23.     }
    24.     obj := Object{Name : "john"}
    25.     // 也可以是指针
    26.     // obj := &Object{Name : "john"}
    27.     if e := gvalid.CheckStruct(obj, rules,msgs); e != nil {
    28.         g.Dump(e.Maps())
    29.     }
    30. }
    32. /*
    33. 输出：
    34. {
    35.     "Age": {
    36.         "between": "年龄为18到30周岁"
    37.     },
    38.     "Name": {
    39.         "length": "名称长度为6到16个字符"
    40.     }
    41. }
    43. */

    在以上示例中，Age属性由于默认值0的存在，因此会引起required规则的失效，因此这里没有使用required规则而是使用between规则来进行校验。

    示例2，使用gvalid tag绑定规则及提示信息

    使用gvalid tag设置的规则，其校验结果是顺序性的。

    从v1.8.0版本开始，也可以使用valid/v标签别名。

    1. package main
    3. import (
    4.     "github.com/gogf/gf/g"
    5.     "github.com/gogf/gf/g/util/gvalid"
    6. )
    8. type User struct {
    9.     Uid   int    `valid:"uid      @integer|min:1"`
    10.     Name  string `valid:"name     @required|length:6,30#请输入用户名称|用户名称长度非法"`
    11.     Pass1 string `valid:"password1@required|password3"`
    12.     Pass2 string `valid:"password2@required|password3|same:password1#||两次密码不一致，请重新输入"`
    13. }
    15. func main() {
    16.     user := &User{
    17.         Name : "john",
    18.         Pass1: "Abc123!@#",
    19.         Pass2: "123",
    20.     }
    22.     // 使用结构体定义的校验规则和错误提示进行校验
    23.     if e := gvalid.CheckStruct(user, nil); e != nil {
    24.         g.Dump(e.Maps())
    25.     }
    27.     // 自定义校验规则和错误提示，对定义的特定校验规则和错误提示进行覆盖
    28.     rules := map[string]string {
    29.         "uid" : "min:6",
    30.     }
    31.     msgs  := map[string]interface{} {
    32.         "password2" : map[string]string {
    33.             "password3" : "名称不能为空",
    34.         },
    35.     }
    36.     if e := gvalid.CheckStruct(user, rules, msgs); e != nil {
    37.         g.Dump(e.Maps())
    38.     }
    39. }

    可以看到，我们可以对在struct定义时使用了gvalid的标签属性(gvalid tag)来绑定校验的规则及错误提示信息，规则如下：

    1. [属性别名@]校验规则[#错误提示]

    可以看到，CheckStruct和CheckMap的gvalid tag规则是一样的，不过在字段的含义上有一点点小区别：

    • 属性别名 和 错误提示 为非必需字段，校验规则 是必需字段；
    • 属性别名 非必需字段，指定在校验中使用的对应struct属性的别名，同时校验成功后的map中的也将使用该别名返回，例如在处理请求表单时比较有用，因为表单的字段名称往往和struct的属性名称不一致；
    • 错误提示 非必需字段，表示自定义的错误提示信息，当规则校验时对默认的错误提示信息进行覆盖；

    在此示例代码中，same:password1规则同使用same:Pass2规则是一样的效果。也就是说，在数据校验中，可以同时使用原有的struct属性名称，也可以使用别名。但是，返回的结果中只会使用别名返回，这也是别名最大的用途。

    此外，在使用CheckStruct方法对struct对象进行校验时，也可以传递校验或者和错误提示参数，这个时候会覆盖struct在定义时绑定的对应参数。

    以上示例执行后，输出结果为：

    1. {
    2.     "name": {
    3.         "length": "用户名称长度非法"
    4.     },
    5.     "password2": {
    6.         "password3": "密码格式不合法，密码格式为任意6-18位的可见字符，必须包含大小写字母、数字和特殊字符",
    7.         "same": "两次密码不一致，请重新输入"
    8.     },
    9.     "uid": {
    10.         "min": "字段最小值为1"
    11.     }
    12. }
    13. {
    14.     "name": {
    15.         "length": "用户名称长度非法"
    16.     },
    17.     "password2": {
    18.         "password3": "名称不能为空",
    19.         "same": "字段值不合法"
    20.     },
    21.     "uid": {
    22.         "min": "字段最小值为6"
    23.     }
    24. }

    示例3，属性递归校验

    gvalid.CheckStruct支持递归校验，即如果属性也是结构体，并且结构体的属性带有gvalid标签，无论多深的递归层级，这些属性都将被根据设定的规则进行校验。

    使用示例：

    1. package main
    3. import (
    4.     "github.com/gogf/gf/g"
    5.     "github.com/gogf/gf/g/util/gvalid"
    6. )
    8. func main() {
    9.     type Pass struct {
    10.         Pass1 string `valid:"password1@required|same:password2#请输入您的密码|您两次输入的密码不一致"`
    11.         Pass2 string `valid:"password2@required|same:password1#请再次输入您的密码|您两次输入的密码不一致"`
    12.     }
    13.     type User struct {
    14.         Id   int
    15.         Name string `valid:"name@required#请输入您的姓名"`
    16.         Pass Pass
    17.     }
    18.     user := &User{
    19.         Name: "john",
    20.         Pass: Pass{
    21.             Pass1: "1",
    22.             Pass2: "2",
    23.         },
    24.     }
    25.     err := gvalid.CheckStruct(user, nil)
    26.     g.Dump(err.Maps())
    27. }

    执行后，终端输出：

    1. {
    2.     "password1": {
    3.         "same": "您两次输入的密码不一致"
    4.     },
    5.     "password2": {
    6.         "same": "您两次输入的密码不一致"
    7.     }
    8. }