尝试创建一个递归遍历结构的函数，并根据特定标记修改任何字符串字段。

使用反射非常乏味。第一次使用它，遇到了一些麻烦。

我的一行代码引起了 panic :

panic: reflect: Field of non-struct type

panic 来自这一行:

tf := vf.Type().Field(i)

我正在尝试获取类型字段，以便从中获取标签。

这里是完整的函数:

func Sanitize(s interface{}) error {
    v := reflect.ValueOf(s)

    // It's a pointer struct, convert to the value that it points to.
    if v.Kind() == reflect.Ptr && !v.IsNil() {
        v = v.Elem()
    }

    // Not a struct, return an error.
    if v.Kind() != reflect.Struct {
        return &InvalidSanitizerError{Type: reflect.TypeOf(s)}
    }

    for i := 0; i < v.NumField(); i++ {
        vf := v.Field(i)

        if vf.Kind() == reflect.Struct {
            // Recurse.
            err := Sanitize(v.Field(i).Interface())
            if err != nil {
                return err
            }

            // Move onto the next field.
            continue
        }


        if vf.Kind() == reflect.String {
            tf := vf.Type().Field(i) // <-- TROUBLE MAKER

            // Get the field tag value
            tag := tf.Tag.Get("sanitize")

            // Skip if tag is not defined or ignored
            if tag == "" || tag == "-" {
                continue
            }
            shouldSanitize, err := strconv.ParseBool(tag)
            if err != nil {
                return err
            }

            if shouldSanitize && vf.CanSet() {
                vf.SetString(policy.Sanitize(vf.String()))
            }
        }
    }

    return nil
}

这是应该如何使用函数的示例:

type User struct {
    Name string `sanitize:"true"`
    Bio *Bio
}

type Bio struct {
    Text string `sanitize:"true"`
}

func main() {
    user := &User{
        Name: "Lansana<script>alert('rekt');</script>",
        Bio: &Bio{
            Text: "Hello world</script>alert('rekt');</script>",
        },
    }
    if err := Sanitize(user); err != nil {
        panic(err)
    }

    fmt.Println(user.Name) // Lansana
    fmt.Println(user.Bio.Text) // Hello world
}

任何关于 panic 的见解都将不胜感激。

最佳答案

在为此工作了一整天之后，这就是我最终想出的解决方案，它可以递归地遍历结构并修改具有特定标记的所有字符串值的值。

Sanitize 函数只允许指向结构的指针，但嵌套结构可以是指针或值；没关系。

我问题中的示例将与下面的函数一起使用，并且它通过了我的所有测试。

func Sanitize(s interface{}) error {
    if s == nil {
        return nil
    }

    val := reflect.ValueOf(s)

    // If it's an interface or a pointer, unwrap it.
    if val.Kind() == reflect.Ptr && val.Elem().Kind() == reflect.Struct {
        val = val.Elem()
    } else {
        return &InvalidStructError{message: "s must be a struct"}
    }

    valNumFields := val.NumField()

    for i := 0; i < valNumFields; i++ {
        field := val.Field(i)
        fieldKind := field.Kind()

        // Check if it's a pointer to a struct.
        if fieldKind == reflect.Ptr && field.Elem().Kind() == reflect.Struct {
            if field.CanInterface() {
                // Recurse using an interface of the field.
                err := Sanitize(field.Interface())
                if err != nil {
                    return err
                }
            }

            // Move onto the next field.
            continue
        }

        // Check if it's a struct value.
        if fieldKind == reflect.Struct {
            if field.CanAddr() && field.Addr().CanInterface() {
                // Recurse using an interface of the pointer value of the field.
                err := Sanitize(field.Addr().Interface())
                if err != nil {
                    return err
                }
            }

            // Move onto the next field.
            continue
        }

        // Check if it's a string or a pointer to a string.
        if fieldKind == reflect.String || (fieldKind == reflect.Ptr && field.Elem().Kind() == reflect.String) {
            typeField := val.Type().Field(i)

            // Get the field tag value.
            tag := typeField.Tag.Get("sanitize")

            // Skip if tag is not defined or ignored.
            if tag == "" || tag == "-" {
                continue
            }

            // Check if the tag is allowed.
            if tag != "true" && tag != "false" {
                return &InvalidTagError{message: "tag must be either 'true' or 'false'."}
            }

            // Parse it to a bool.
            shouldSanitize, err := strconv.ParseBool(tag)
            if err != nil {
                return err
            } else if !shouldSanitize {
                continue
            }

            // Set the string value to the sanitized string if it's allowed.
            // It should always be allowed at this point.
            if field.CanSet() {
                field.SetString(policy.Sanitize(field.String()))
            }

            continue
        }
    }

    return nil
}

关于go - 递归结构反射错误 : panic: reflect: Field of non-struct type，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49460380/