go - 使用 Golang 将两个相似数据 slice 合并为 JSON

Question

我们有一个具有两个端点的服务，可以访问多个 API，处理数据并将其作为 json 发送回。它们在相同的对象上提供数据，但它们做的事情却截然不同。唯一的公共(public)属性是 uid。

他们共享一个模型，看起来像这样:

type Item struct {
  Uid     string      `json:"uid"`
  Val1    string      `json:"param1,omitempty"`
  Val2    []NestedVal `json:"param2,omitempty"`
  Val5    int         `json:"param5,omitempty"`
  Val6    string      `json:"param6,omitempty"`
  Val7    string      `json:"param7,omitempty"`
}

type NestedVal struct {
  Val3  int    `json:"val3,omitempty"`
  Val4  string `json:"val4,omitempty"`
}

来自端点 A 的示例响应是:

[
 {
   "uid": "123",
   "val1": "foobar"
   "val2": [
     {"val3": 666, "val4": "qux"},
     {"val3": 666, "val4": "qux"}
   ]
 },
 {
   "uid": "456",
   "val1": "foobar"
   "val2": [
     {"val3": 666, "val4": "qux"},
     {"val3": 666, "val4": "qux"}
   ]
 }
]

来自端点 B 的示例响应是:

[
 {
   "uid": "123",
   "val5": 999
   "val6": "bar"
   "val7": "baz"
 },
 {
   "uid": "456",
   "val5": 999
   "val6": "bar"
   "val7": "baz"
 }
]

现在这些作为独立服务存在，因为它们服务于略有不同的需求，但现在我们需要将它们作为组合数据集提供，例如:

[
 {
   "uid": "123",
   "val1": "foobar"
   "val2": [
     {"val3": 666, "val4": "qux"},
     {"val3": 666, "val4": "qux"}
   ],
   "val5": 999
   "val6": "bar"
   "val7": "baz"
 },
 {
   "id": "456",
   "val1": "foobar"
   "val2": [
     {"val3": 666, "val4": "qux"},
     {"val3": 666, "val4": "qux"}
   ],
   "val5": 999
   "val6": "bar"
   "val7": "baz"
 }
]

就其值(value)而言，这是返回它们的方式(两个端点基本上相同):

func FetchA(uids []string) []Item {
  var collection []Item

  *... fetching, parsing, and appending to collection ...*

  return collection
}

func HandlerA(response http.ResponseWriter, request *http.Request) {
  *... pull uids out of qs ...*
  collection := fetchA(uids)
  responseData, _ := json.Marshal(collection)
  *... write the response ...*
}

底线:我有两个数据集，都是 []Item 类型。我只想将它们组合到共享的 uid 键上。显然，我作为 Ruby 开发人员正在处理这个问题，将这个问题视为“我有两个哈希数组，我想将它们合并到一个共享 key 上”——我知道这是错误的心态，但我很漂亮卡住了，我知道答案就在我眼皮底下。

我环顾四周，没有看到任何答案特别有用。我检查了 mergeo 和 go-merge，但找不到覆盖 merge-ee 的方法。

我认为我真正的问题是对 Go 数据结构缺乏很好的理解。这就是我在 Ruby 中将两者结合起来的方式:

(responseA + responseB).group_by{|h| h[:uid]}.map{|k,v| v.reduce(:merge)}

编辑:这是围棋 Playground https://play.golang.org/p/J0bJMjiM8DR 上的粗略模拟

Answer 1

我认为您在“我有两个哈希数组，我想将它们合并到一个共享 key 上”的正确轨道上

但是，在 Go 中，您将负责自己进行合并，因为它们没有 group_by 类型函数/方法的概念。

func merge(As, Bs []Item) []Item {
    if len(As) == 0 {
        return Bs
    }
    bMap := make(map[string]Item)
    for _, b := range Bs {
        bMap[b.Uid] = b
    }
    merged := make([]Item, len(As))
    for i, a := range As {
        if b, ok := bMap[a.Uid]; ok {
            a.Val5 = b.Val5    // this and the next two lines could be done
            a.Val6 = b.Val6    // using reflection, but if you know the fields
            a.Val7 = b.Val7    // then this would be my preferred way.
        }
        merged[i] = a
    }
    return merged

}

这是一个playground结果的

注意:这不会考虑 As 的空 slice ，因为您在合并中什么也得不到。由于我不知道您的应用程序的具体细节，我不能说这是否会发生，但如果可以，您将需要考虑到这一点。

就其值(value)而言，我认为这大致就是 Verran 建议的方法:

https://play.golang.org/p/3EpWlFdB8c6

基本上，让结果在 channel 上返回，并在您获得两个结果时将它们合并。