Golang获取特定结构字段名称的字符串表示形式

问题描述：

I really want a way to print the string representation of a field name in go. It has several use cases, but here is an example:

lets say I have a struct

type Test struct {
    Field      string `bson:"Field" json:"field"`
    OtherField int    `bson:"OtherField" json:"otherField"`
}

and, for example, I want to do a mongo find:

collection.Find(bson.M{"OtherField": someValue})

I don't like that I have to put the string "OtherField" in there. It seems brittle and easy to either misstype or have the struct change and then my query fails without me knowing it.

Is there any way to get the string "OtherField" without having to either declare a const or something like that? I know I can use reflection to a get a list of field names from a struct, but I'd really like to do something along the lines of

fieldName := nameOf(Test{}.OtherField) 
collection.Find(bson.M{fieldName: someValue})

is there any way to do this in Go?? C# 6 has the built in nameof, but digging through reflection I can't find any way to do this in Go.

我真的想要一种在go中打印字段名称的字符串表示形式的方法。它有几种用例，但这是一个示例： p>

让我说我有一个结构 p>

  type测试结构{
字段 字符串`bson：“ Field” json：“ field”`
 OtherField int`bson：“ OtherField” json：“ otherField”`
} 
  code>  pre> 
 
 和 ，例如，我想进行mongo查找： p> 
 
 
  collection.Find（bson.M {“ OtherField”：someValue}）
  code>  pre  > 
 
 我不喜欢这样，我必须在其中放置字符串“ OtherField”。 丢失类型或更改结构似乎很脆弱且容易，然后我的查询失败，而我却不知道。   p> 
 
 
有什么方法可以获取字符串“ OtherField”而不必声明const或类似的东西吗？ 我知道我可以使用反射从结构中获取字段名称列表，但是我真的很想按照 p> 
 
 
  fieldName：= nameOf（  Test {}。OtherField）
collection.Find（bson.M {fieldName：someValue}）
  code>  pre> 
 
 有没有办法在Go中做到这一点？  C＃6具有内置的nameof，但是通过反射进行挖掘，我找不到在Go中执行此操作的任何方法。 p> 
  div>

答

I don't really think there is. You may be able to load a set of types via reflection and generate a set of constants for the field names. So:

type Test struct {
    Field      string `bson:"Field" json:"field"`
    OtherField int    `bson:"OtherField" json:"otherField"`
}

Could generate something like:

var TestFields = struct{
      Field string
      OtherField string
}{"Field","OtherField"}

and you could use TestFields.Field as a constant.

Unfortunately, I don't know of any existing tool that does anything like that. Would be fairly simple to do, and wire up to go generate though.

EDIT:

How I'd generate it:

Make a package that accepts an array of reflect.Type or interface{} and spits out a code file.

Make a generate.go somewhere in my repo with main function:

func main(){
   var text = mygenerator.Gen(Test{}, OtherStruct{}, ...)
   // write text to constants.go or something
}

Add //go:generate go run scripts/generate.go to my main app and run go generate

答

Here is a function that will return a []string with the struct field names. I think it comes in the order they are defined.

WARNING: Reordering the fields in the struct definition will change the order in which they appear

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

package main

import (
    "fmt"
    "strings"
    "regexp"
    )

type Test struct {
    Field      string `bson:"Field" json:"field"`
    OtherField int    `bson:"OtherField" json:"otherField"`
}

func main() {
    fields, err := GetFieldNames(Test{})
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(fields)
}


func GetFieldNames(i interface{}) ([]string, error) {
    // regular expression to find the unquoted json
    reg := regexp.MustCompile(`(\s*?{\s*?|\s*?,\s*?)(['"])?(?P<Field>[a-zA-Z0-9]+)(['"])?:`)

    // print struct in almost json form (fields unquoted)
    raw := fmt.Sprintf("%#v", i)

    // remove the struct name so string begins with "{"
    fjs := raw[strings.Index(raw,"{"):]

    // find and grab submatch 3
    matches := reg.FindAllStringSubmatch(fjs,-1)

    // collect
    fields := []string{}
    for _, v := range matches {
        if len(v) >= 3 && v[3] != "" {
            fields = append(fields, v[3])
        }

    }


return fields, nil

}

Golang获取特定结构字段名称的字符串表示形式

相关推荐