Question

在this stackoverflow帖子中，它解释了如何将任意字段添加到golang结构中，方法是将其用作匿名。如果您使用已知的结构类型，这可以正常工作，但我想知道在处理未知的结构或接口时如何做同样的事情。

package main

import (
    "os"
    "encoding/json"
    "fmt"
)

type example interface{}
type Data struct {
    Name string
}

func printInterface(val interface{})    {
    example1 := struct {
        example
        Extra string
    }{
        example: val,
        Extra: "text",
    }
    json.NewEncoder(os.Stdout).Encode(example1)
}

func printStructPointer(val *Data)  {
    example2 := struct {
        *Data
        Extra string
    }{
        Data: val,
        Extra: "text",
    }
    json.NewEncoder(os.Stdout).Encode(example2)
}


func main() {
    d := Data{Name:"name"}
    fmt.Println("Example 1:")
    printInterface(&d)
    fmt.Println("Example 2:")
    printStructPointer(&d)
}

这将打印以下内容：

Example 1:
{"example":{"Name":"name"},"Extra":"text"}
Example 2:
{"Name":"name","Extra":"text"}

我假设我在printInterface内工作，如何让JSON输出看起来像printStructPointer的JSON输出？

Answer 1

printInterface()和printStructPointer()之间存在重要差异。第一个嵌入了一个接口类型，而第二个嵌入了一个struct类型（更具体地说是一个指向struct类型的指针）。

当你嵌入一个struct（或指向struct的指针）类型时，嵌入类型的字段会被提升，所以在第二个例子中，写example2.Name是有效的。嵌入接口类型时，接口没有字段，因此不会提升任何字段。因此，如果接口值包装结构（或指向struct的指针）并不重要，那个结构的字段就不会被提升（它们不可能）。

因此，在printInterface()中，包裹一个结构的界面不会被“展平”＆＃34;在JSON结果中。

使用反射

生成动态类型来解决它

解决此问题的一种方法是使用反射（reflect包）在运行时生成动态类型。这个新类型将是一个结构，它将包含一个匿名结构字段，该字段是包含在传递接口中的类型，并且还将包含我们的额外字段（类型为string）。

这就是它的样子：

func printInterface(val interface{}) {
    t2 := reflect.StructOf([]reflect.StructField{
        reflect.StructField{
            Name: "",
            Type: reflect.TypeOf(val),
        },
        reflect.StructField{
            Name: "Extra",
            Type: reflect.TypeOf(""),
        },
    })

    v2 := reflect.New(t2).Elem()
    v2.Field(0).Set(reflect.ValueOf(val))
    v2.FieldByName("Extra").SetString("text")

    json.NewEncoder(os.Stdout).Encode(v2.Interface())
}

输出符合预期（在Go Playground上尝试）：

Example 1:
{"Name":"name","Extra":"text"}
Example 2:
{"Name":"name","Extra":"text"}

用编组两次解决它

另一种方法是编组值，将其解组到地图中，添加额外的字段并再次编组：

func printInterface(val interface{}) error {
    data, err := json.Marshal(val)
    if err != nil {
        return err
    }

    v2 := map[string]interface{}{}
    if err := json.Unmarshal(data, &v2); err != nil {
        return err
    }

    v2["Extra"] = "text"
    return json.NewEncoder(os.Stdout).Encode(v2)
}

输出是一样的。在Go Playground上尝试。

这种解决方案更简单，更容易理解，但由于它编组两次，因此速度较慢。另请注意，在此示例中，结果中的字段可能顺序不同，因为Go中未指定地图上的迭代顺序（有关详细信息，请参阅Why can't Go iterate maps in insertion order?）。

Answer 2

这是一种方式：

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type example interface{}
type Data struct {
    Name string
}

func printInterface(val interface{}) {
    if d, ok := val.(*Data); ok {
        fmt.Println("Asserting type *Data for val is OK")
        printStructPointer(d)
    } else {
        fmt.Println("Asserting type *Data for val is NOT OK")
    }

}

func printStructPointer(val *Data) {

    example2 := struct {
        *Data
        Extra string
    }{
        Data:  val,
        Extra: "text",
    }
    json.NewEncoder(os.Stdout).Encode(example2)
}

func main() {
    d := Data{Name: "Testing"}
    fmt.Println("Example 1:")
    printInterface(&d)
    fmt.Println("Example 2:")
    printStructPointer(&d)
}

游乐场：https://play.golang.org/p/OPotpTyUEz

您也可以使用类型开关进行断言，尤其是如果您有多种类型。希望这有帮助！

将任意字段添加到未知结构的json输出

2 个答案:

使用反射

用编组两次解决它