func mappingByPtr(ptr any, setter setter, tag string) error {
    _, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag)
    return err
}

/* mapping是一个递归函数，因为struct填充对象有可能嵌套了ptr成员
* value：填充对象
* field：struct填充对象的某个具体成员变量
* setter：内部包含了url.Values
* tag: 等于"form"
*/
func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
    if field.Tag.Get(tag) == "-" { // just ignoring this field
        return false, nil
    }

    vKind := value.Kind()

    // 如果填充对象是ptr，获取其指向的对象递归调用mapping
    if vKind == reflect.Ptr {
        var isNew bool
        vPtr := value
        if value.IsNil() {
            isNew = true
            vPtr = reflect.New(value.Type().Elem())
        }
        isSet, err := mapping(vPtr.Elem(), field, setter, tag) 
        if err != nil {
            return false, err
        }
        if isNew && isSet {
            value.Set(vPtr)
        }
        return isSet, nil
    }
    // 递归到最底层，每个value都是StructField类型，开始填充值
    if vKind != reflect.Struct || !field.Anonymous {
        ok, err := tryToSetValue(value, field, setter, tag)
        if err != nil {
            return false, err
        }
        if ok {
            return true, nil
        }
    }
    // 如果填充对象是struct，针对每一个struct field，递归调用mapping
    if vKind == reflect.Struct {
        tValue := value.Type()

        var isSet bool
        for i := 0; i < value.NumField(); i++ {
            sf := tValue.Field(i)
            if sf.PkgPath != "" && !sf.Anonymous { // unexported
                continue
            }
            ok, err := mapping(value.Field(i), sf, setter, tag)
            if err != nil {
                return false, err
            }
            isSet = isSet || ok
        }
        return isSet, nil
    }
    return false, nil
}