我想验证以下结构:

type CarModel struct {
  gorm.Model
  OwnerID    int    `json:"ownerid" validate:"nonzero"`
  Type       string `json:"type" validate:"regexp=(?)(A|B)"`
  A        string `json:"url" validate:"isurl"`
  B         string `json:"ip" validate:"isip"`
}

我想根据类型验证 A 和 B， 如果 type = A 那么 A 必须存在并且必须是一个 URL BUT 不能存在 如果 type = B 那么 A 一定不存在并且 B 必须是一个 IP

验证器可以吗？

我确实尝试过自定义验证，但我找不到查看类型值的方法:

func checkB(v interface{}, param string) error {
    theB := reflect.ValueOf(v)
    if theB.Kind() != reflect.String {
        return validator.ErrUnsupported
    }
    //check if B is an IP
    ipcool := net.ParseIP(theB.String())
    if ipcool == nil {
        return errors.New("B : ip incorrecte " + theB.String())
    }
    return nil
}

根据Alex Nichol的回答，首先感谢您的帮助。

如果我理解正确，我将不得不遍历所有“验证”字段，以跟踪 TYPE、A 和 B 的值，然后根据 TYPE 检查它们 ...

我这样做了:

func checkMonitor(v interface{}) error {
    var mytype string
    var myA string
    var myB string

    val := reflect.ValueOf(v)
    // Iterate through fields
    for i := 0; i < val.NumField(); i++ {
        // Lookup the validate tag
        field := val.Type().Field(i)
        tags := field.Tag
        _, ok := tags.Lookup("validate")
        if !ok {
            // No validate tag.
            continue
        }

        // Get the value of the field.
        fieldValue := val.Field(i)

        switch field.Name {
        case "Type":
            mytype = fieldValue.Interface()
        case "A":
            myA = fieldValue.Interface()
        case "B":
            myB = fieldValue.Interface()
        }
        // Validation logic here.
        //fmt.Println("field", field.Name, "has validate tag", validate, "and value", fieldValue.Interface())
    }
    if mytype == "A" {
        if myA == "" {
            return errors.New("A vide et type A")
        }
        ipcool := net.ParseIP(myA)
        if ipcool == nil {
            return errors.New("A incorrecte " + myA)
        }
    } else if mytype == "HTML" {
        if myB == "" {
            return errors.New("B vide et type B")
        }
        _, urlpascool := url.ParseRequestURI(myB)
        if urlpascool != nil {
            return errors.New("B incorrecte " + myB)
        }
    }
    return nil
}

但在 switch case 的 mytype、myA 和 myB 上出现错误:

不能在赋值中使用 fieldValue.Interface()(类型接口(interface) {})作为类型字符串:需要类型断言

编辑: 只需要使用我的大脑:

switch field.Name {
case "Type":
   mytype = fieldValue.String()
case "A":
   myA = fieldValue.String()
case "B":
   myB = fieldValue.Interface()
}

最佳答案

您可能希望使用反射来迭代结构的字段，获取每个字段的 validate 标记，并检查该字段。这意味着您必须在结构级别上进行验证。否则，如果您将类似 myInstance.OwnerID 的内容传递给函数，您将丢失与其关联的标签。

此代码循环遍历结构的字段并为每个字段获取 validate 标记:

func checkStruct(v interface{}) error {
    val := reflect.ValueOf(v)

    // Iterate through fields
    for i := 0; i < val.NumField(); i++ {
        // Lookup the validate tag
        field := val.Type().Field(i)
        tags := field.Tag
        validate, ok := tags.Lookup("validate")
        if !ok {
            // No validate tag.
            continue
        }

        // Get the value of the field.
        fieldValue := val.Field(i)

        // Validation logic here.
        fmt.Println("field", field.Name, "has validate tag", validate, "and value",
            fieldValue.Interface())
    }
    return nil
}

例如，我们可以将以下 CarModel 传递给它:

checkStruct(CarModel{
    OwnerID: 2,
    Type:    "B",
    A:       "http://google.com",
    B:       "192.168.1.1",
})

它会打印出以下内容:

field OwnerID has validate tag nonzero and value 2
field Type has validate tag regexp=(?)(A|B) and value B
field A has validate tag isurl and value http://google.com
field B has validate tag isip and value 192.168.1.1

关于validation - Golang 验证器多字段依赖，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42390574/