迭代结构中的字符串字段

Question

我希望遍历结构的字符串字段，以便进行一些清理/验证（使用strings.TrimSpace、strings.Trim 等）。

现在我有一个杂乱无章的开关盒，它不是真正可扩展的，而且由于它不在我的应用程序（网络表单）的热点中，因此利用 reflect 似乎是一个不错的选择。

然而，我在如何实现这一点上遇到了一些障碍，并且反射文档让我有点困惑（我一直在研究其他一些验证包，但它们太重了 + 我'我已经在使用 gorilla/schema 作为解组部分）：

• 遍历结构
• 对于字符串类型的每个字段，从strings 包中应用我需要的任何内容，即field = strings.TrimSpace(field)
• 如果存在 field.Tag.Get("max")，我们将使用该值（strconv.Atoi，然后是 unicode.RuneCountInString）

• 提供一个也与错误接口类型兼容的错误切片

  type FormError []string         
  
  type Listing struct {
          Title string `max:"50"`
          Location string `max:"100"`
          Description string `max:"10000"`
          ExpiryDate time.Time
          RenderedDesc template.HTML
          Contact string `max:"255"`
      }
  
      // Iterate over our struct, fix whitespace/formatting where possible
      // and return errors encountered
      func (l *Listing) Validate() error {
  
         typ := l.Elem().Type()
  
         var invalid FormError
         for i = 0; i < typ.NumField(); i++ {
             // Iterate over fields
             // For StructFields of type string, field = strings.TrimSpace(field)
             // if field.Tag.Get("max") != "" {
             //     check max length/convert to int/utf8.RuneCountInString
                    if max length exceeded, invalid = append(invalid, "errormsg")
         }
  
         if len(invalid) > 0 {
             return invalid
         } 
  
         return nil
     }
  
  
     func (f FormError) Error() string {
         var fullError string
         for _, v := range f {
             fullError =+ v + "\n"
         }
         return "Errors were encountered during form processing: " + fullError
     }
  

提前致谢。

Answer 1

您想要的主要是 reflect.Value 上称为 NumFields() int 和 Field(int) 的方法。你唯一真正缺少的是字符串检查和SetString 方法。

package main

import "fmt"
import "reflect"
import "strings"

type MyStruct struct {
    A,B,C string
    I int
    D string
    J int
}

func main() {
    ms := MyStruct{"Green ", " Eggs", " and ", 2, " Ham      ", 15}
    // Print it out now so we can see the difference
    fmt.Printf("%s%s%s%d%s%d\n", ms.A, ms.B, ms.C, ms.I, ms.D, ms.J)

    // We need a pointer so that we can set the value via reflection
    msValuePtr := reflect.ValueOf(&ms)
    msValue := msValuePtr.Elem()

    for i := 0; i < msValue.NumField(); i++ {
        field := msValue.Field(i)

        // Ignore fields that don't have the same type as a string
        if field.Type() != reflect.TypeOf("") {
            continue
        }

        str := field.Interface().(string)
        str = strings.TrimSpace(str)
        field.SetString(str)
    }
    fmt.Printf("%s%s%s%d%s%d\n", ms.A, ms.B, ms.C, ms.I, ms.D, ms.J)
}

(Playground link)

这里有两个警告：

1. 您需要一个指向要更改的内容的指针。如果有值，则需要返回修改后的结果。

2. 尝试修改未导出的字段通常会导致反射恐慌。如果您打算修改未导出的字段，请确保在包内执行此技巧。

此代码相当灵活，如果您需要根据类型不同的行为，您可以使用 switch 语句或类型开关（在 field.Interface() 返回的值上）。

编辑：至于标签行为，您似乎已经弄清楚了。一旦你有了字段并检查了它是一个字符串，你就可以使用field.Tag.Get("max") 并从那里解析它。

Edit2：我在标签上犯了一个小错误。标签是结构的 reflect.Type 的一部分，因此您可以使用它们（这有点冗长）msValue.Type().Field(i).Tag.Get("max")

（Playground version 您在 cmets 中发布的带有工作标记的代码获取）。

Answer 2

不知道好不好用，我就是这样用的。

https://play.golang.org/p/aQ_hG2BYmMD

您可以将结构的地址发送到此函数。 对不起，我的英语不是很好。

trimStruct(&someStruct)

func trimStruct(v interface{}) {
    bytes, err := json.Marshal(v)
    if err != nil {
        fmt.Println("[trimStruct] Marshal Error :", err)
    }
    var mapSI map[string]interface{}
    if err := json.Unmarshal(bytes, &mapSI); err != nil {
        fmt.Println("[trimStruct] Unmarshal to byte Error :", err)
    }
    mapSI = trimMapStringInterface(mapSI).(map[string]interface{})
    bytes2, err := json.Marshal(mapSI)
    if err != nil {
        fmt.Println("[trimStruct] Marshal Error :", err)
    }
    if err := json.Unmarshal(bytes2, v); err != nil {
        fmt.Println("[trimStruct] Unmarshal to b Error :", err)
    }
}

func trimMapStringInterface(data interface{}) interface{} {
    if values, valid := data.([]interface{}); valid {
        for i := range values {
            data.([]interface{})[i] = trimMapStringInterface(values[i])
        }
    } else if values, valid := data.(map[string]interface{}); valid {
        for k, v := range values {
            data.(map[string]interface{})[k] = trimMapStringInterface(v)
        }
    } else if value, valid := data.(string); valid {
        data = strings.TrimSpace(value)
    }
    return data
}

Answer 3

我被打败了，但既然我去上班了，这里有一个解决办法：

type FormError []*string

type Listing struct {
    Title        string `max:"50"`
    Location     string `max:"100"`
    Description  string `max:"10000"`
    ExpiryDate   time.Time
    RenderedDesc template.HTML
    Contact      string `max:"255"`
}

// Iterate over our struct, fix whitespace/formatting where possible
// and return errors encountered
func (l *Listing) Validate() error {
    listingType := reflect.TypeOf(*l)
    listingValue := reflect.ValueOf(l)
    listingElem := listingValue.Elem()

    var invalid FormError = []*string{}
    // Iterate over fields
    for i := 0; i < listingElem.NumField(); i++ {
        fieldValue := listingElem.Field(i)
        // For StructFields of type string, field = strings.TrimSpace(field)
        if fieldValue.Type().Name() == "string" {
            newFieldValue := strings.TrimSpace(fieldValue.Interface().(string))
            fieldValue.SetString(newFieldValue)

            fieldType := listingType.Field(i)
            maxLengthStr := fieldType.Tag.Get("max")
            if maxLengthStr != "" {
                maxLength, err := strconv.Atoi(maxLengthStr)
                if err != nil {
                    panic("Field 'max' must be an integer")
                }
                //     check max length/convert to int/utf8.RuneCountInString
                if utf8.RuneCountInString(newFieldValue) > maxLength {
                    //     if max length exceeded, invalid = append(invalid, "errormsg")
                    invalidMessage := `"`+fieldType.Name+`" is too long (max allowed: `+maxLengthStr+`)`
                    invalid = append(invalid, &invalidMessage)
                }
            }
        }
    }

    if len(invalid) > 0 {
        return invalid
    }

    return nil
}

func (f FormError) Error() string {
    var fullError string
    for _, v := range f {
        fullError = *v + "\n"
    }
    return "Errors were encountered during form processing: " + fullError
}

我看到你问过如何做标签。反射有两个组成部分：类型和值。标签与类型相关联，因此您必须与字段分开获取它：listingType := reflect.TypeOf(*l)。然后你可以从中获取索引字段和标签。