从 json 合并两个 map[string]interface{}答案

【问题标题】：merge two map[string]interface{} from json从 json 合并两个 map[string]interface{}
【发布时间】：2019-01-05 20:02:42
【问题描述】：

我有两个以这种方式构建的 json 输入

"count: 1 result: fields"

我想在不使用定义结构的情况下连接我在结果中找到的字段。我尝试了很多方法，但大多数时候结果是关于类型 Interface {} 的错误或最后一张地图覆盖了数据

我希望将“结果”以及第一个和第二个地图字段合并到输出结果中。

oracle, err := http.Get("http://XXX:8080/XXXX/"+id)
    if err != nil {
            panic(err)
    }
defer oracle.Body.Close()

mysql, err := http.Get("http://XXX:3000/XXX/"+id)
if err != nil {
        panic(err)
}
defer mysql.Body.Close()

oracleJSON, err := ioutil.ReadAll(oracle.Body)
if err != nil {
        panic(err)
}
mysqlJSON, err := ioutil.ReadAll(mysql.Body)
if err != nil {
        panic(err)
}

var oracleOUT map[string]interface{}
var mysqlOUT map[string]interface{}

json.Unmarshal(oracleJSON, &oracleOUT)
json.Unmarshal(mysqlJSON, &mysqlOUT)

a := oracleOUT["result"]
b := mysqlOUT["result"]


c.JSON(http.StatusOK, gin.H{"result": ????})

这是一个json的例子

{"count":1,"result":{"COD_DIPENDENTE":"00060636","MATRICOLA":"60636","COGNOME":"PIPPO"}}

如果我有两个这样的 json 函数的结果应该是

`"result":{"COD_DIPENDENTE":"00060636","MATRICOLA":"60636","COGNOME":"PIPPO","COD_DIPENDENTE":"00060636","MATRICOLA":"60636","COGNOME":"PIPPO"}}`

【问题讨论】：

请给我们 JSON 示例
{"count":1,"result":{"COD_DIPENDENTE":"00060636","MATRICOLA":"60636","COGNOME":"PIPPO"}} 这是 JSON 示例.如果我有两个这样的 json，函数的结果应该是 "result":{"COD_DIPENDENTE":"00060636","MATRICOLA":"60636","COGNOME":"PIPPO","COD_DIPENDENTE":"00060636 ","MATRICOLA":"60636","COGNOME":"PIPPO"}}
您所描述的输出不是有效的 JSON。您将“结果”描述为使用括号引用对象，但对象是 SETS ，这意味着名称可能不会重复。您是否最好将输出重新格式化为有效的 JSON，或者尽管它不是 JSON，但仍保持结构？无论哪种方式我都可以提供答案，但需要知道您喜欢哪种方式。

标签： json dictionary go interface

【解决方案1】：

您要查找的输出不是有效的 JSON。但是，只需稍作更改，您就可以输出与您的示例非常相似的内容，即有效的 JSON。

您可能确实希望对具有已知结构的输入部分使用定义的结构，以便更轻松地提取更抽象的“结果”部分。

如果您从输入结构的顶部开始使用map[string]interface{}，那么您必须对“结果”键进行类型断言。例如：

var input map[string]interface{}

err = json.Unmarshal(data, &input)
if err != nil {
    return err
}
keys, ok := input["result"].(map[string]interface{})
if !ok {
    return errors.New("wasn't the type we expected")
}

但是，如果您为顶层使用定义的结构，您可以像下面这样感觉更干净。

type Input struct {
    Count  int                    `json:"count"`
    Result map[string]interface{} `json:"result"`
}

var input Input
err = json.Unmarshal(data, &input)
if err != nil {
    return err
}
// from here you can use input.Result directly without a type assertion

要生成具有重复键的输出，您可以使用一个对象数组，其中每个对象都有一个键/值对，然后最终得到一个不会覆盖键的有效 JSON 结构。以下是如何做到这一点 (playground link)：

package main

import (
    "encoding/json"
    "fmt"
)

type Input struct {
    Count  int                    `json:"count"`
    Result map[string]interface{} `json:"result"`
}

type Output struct {
    Count  int                      `json:"count"`
    Result []map[string]interface{} `json:"result"`
}

var inputdata = [][]byte{
    []byte(`{"count":1,"result":{"COD_DIPENDENTE":"00060636", "MATRICOLA":"60636", "COGNOME":"PIPPO"}}`),
    []byte(`{"count":1,"result":{"COD_DIPENDENTE":"00060636", "MATRICOLA":"60636", "COGNOME":"PIPPO"}}`),
}

func main() {
    inputs := make([]Input, len(inputdata))
    for i := range inputs {
        err := json.Unmarshal(inputdata[i], &inputs[i])
        if err != nil {
            panic(err)
        }
    }

    var out Output
    out.Count = len(inputs)
    for _, input := range inputs {
        for k, v := range input.Result {
            out.Result = append(out.Result, map[string]interface{}{k: v})
        }
    }

    outdata, _ := json.Marshal(out)
    fmt.Println(string(outdata))
}

格式化后会产生如下所示的输出：

{
  "count": 2,
  "result": [
    {"MATRICOLA": "60636"},
    {"COGNOME": "PIPPO"},
    {"COD_DIPENDENTE": "00060636"},
    {"COGNOME": "PIPPO"},
    {"COD_DIPENDENTE": "00060636"},
    {"MATRICOLA": "60636"}
  ]
}

【讨论】：