Arrays 用一个公共密钥golang合并两个JSON数组

这几天，我试图合并两个乔恩基于一个共同的关键。我在一个公共字段中输入了两个不同的json，我想基于公共键合并这两个json的数据。两个JSON之间的一种sql连接

JSON源于此代码

func Dati_plus(c *gin.Context) {

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

mysql, err := http.Get("http://XXXX/XXX")
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([]byte(oracleJSON), &oracleOUT)
json.Unmarshal([]byte(mysqlJSON), &mysqlOUT)

a := map[string]interface{}{"result":mysqlOUT["result"]}
b := map[string]interface{}{"result":oracleOUT["result"]}

输入中的JSON具有以下形式

{"count":2,"result":[{"DESC":"2","NOMEmy":"PIPPO","COGNOMEmy":"PIPPO"},{"DESC":"7","NOMEmy":"PIPPO","COGNOMEmy":"PIPPO"}]

{"count":2,"result":[{"DESC":"2","COS":"PIPPO","ROS":"PIPPO"},{"DESC":"7","COS":"PIPPO","ROS":"PIPPO"},{"DESC":"60","COS":"PIPPO","ROS":"PIPPO"}]

如果我有两个类似这样的json，那么函数的结果应该是

{"count":2,"result":[{"DESC":"2","COS":"PIPPO","ROS":"PIPPO","NOMEmy":"PIPPO","COGNOMEmy":"PIPPO"},{"DESC":"7","COS":"PIPPO","ROS":"PIPPO","NOMEmy":"PIPPO","COGNOMEmy":"PIPPO"},{"DESC":"60","COS":"PIPPO","ROS":"PIPPO"}]

如果有帮助的话，这是一个我用来在两个单值JSON之间合并的函数，但是我不能以正确的方式修改它

    func merge(dst, src map[string]interface{}, depth int) map[string]interface{} {
    if depth > MaxDepth {
        panic("Troppo Lungo")
    }
    for key, srcVal := range src {
        if dstVal, ok := dst[key]; ok {
            srcMap, srcMapOk := mapify(srcVal)
            dstMap, dstMapOk := mapify(dstVal)
            if srcMapOk && dstMapOk {
                srcVal = merge(dstMap, srcMap, depth+1)
            }
        }
        dst[key] = srcVal
    }
    return dst
}

    func mapify(i interface{}) (map[string]interface{}, bool) {
        value := reflect.ValueOf(i)
        if value.Kind() == reflect.Map {
            m := map[string]interface{}{}
            for _, k := range value.MapKeys() {
                m[k.String()] = value.MapIndex(k).Interface()
            }
            return m, true
        }
        return map[string]interface{}{}, false
    }

---

请帮帮我。THX

这里的一个观察是，您可以定义一个简单的类型，对两个数据集进行建模，并使用golang类型系统来发挥您的优势（而不是使用如此多的反射来对抗它），例如：

type Data struct {
  Count   int                 `json:"count"`
  Results []map[string]string `json:"result"`
}

// ...
oracleData, mysqlData := Data{}, Data{}
err := json.Unmarshal([]byte(oracleJson), &oracleData)
check(err)
err := json.Unmarshal([]byte(mysqlJson), &mysqlData)
check(err)

现在，您的“merge”函数可以简单地返回一个新的“Data”结构，其中包含从两个输入填充的值，而不必担心类型断言或强制转换。此实现的一个关键特性是，它通过数据结果对象的“DESC”键创建数据结果对象的查找表，该键稍后用于关联：

func merge(d1, d2 Data) Data {
  // Create the lookup table by each result object "DESC".
  d1ResultsByDesc := map[string]map[string]string{}
  for _, obj1 := range d1.Results {
    d1ResultsByDesc[obj1["DESC"]] = obj1
  }

  newData := Data{}
  for _, obj2 := range d2.Results {
    newObj := map[string]string{}
    // Include all result data objects from d2
    for k2, v2 := range obj2 {
      newObj[k2] = v2
    }
    // Also include the matching result data from d1
    obj1 := d1ResultsByDesc[obj2["DESC"]]
    for k1, v1 := range obj1 {
      newObj[k1] = v1
    }
    newData.Results = append(newData.Results, newObj)
  }

  return newData
}

---

这里的一个观察结果是，您可以定义一个简单的类型，该类型将对两个数据集进行建模，并使用golang类型系统为您带来好处（而不是使用这么多反射来对抗它），例如：

type Data struct {
  Count   int                 `json:"count"`
  Results []map[string]string `json:"result"`
}

// ...
oracleData, mysqlData := Data{}, Data{}
err := json.Unmarshal([]byte(oracleJson), &oracleData)
check(err)
err := json.Unmarshal([]byte(mysqlJson), &mysqlData)
check(err)

现在，您的“merge”函数可以简单地返回一个新的“Data”结构，其中包含从两个输入填充的值，而不必担心类型断言或强制转换。此实现的一个关键特性是，它通过数据结果对象的“DESC”键创建数据结果对象的查找表，该键稍后用于关联：

func merge(d1, d2 Data) Data {
  // Create the lookup table by each result object "DESC".
  d1ResultsByDesc := map[string]map[string]string{}
  for _, obj1 := range d1.Results {
    d1ResultsByDesc[obj1["DESC"]] = obj1
  }

  newData := Data{}
  for _, obj2 := range d2.Results {
    newObj := map[string]string{}
    // Include all result data objects from d2
    for k2, v2 := range obj2 {
      newObj[k2] = v2
    }
    // Also include the matching result data from d1
    obj1 := d1ResultsByDesc[obj2["DESC"]]
    for k1, v1 := range obj1 {
      newObj[k1] = v1
    }
    newData.Results = append(newData.Results, newObj)
  }

  return newData
}

---

为什么在这里投票？这个问题似乎措辞得当，包括代码和示例数据，而且似乎适合这个社区……我不知道。Thx支持男士为什么在这里投反对票？这个问题似乎措辞得当，包括代码和示例数据，而且似乎适合这个社区……我不知道。Thx为支持人员我只需一点零钱就得到了我想要的。。谢谢你，只要一点零钱我就得到了我想要的。。谢谢