使用Ramda将两个具有两个不同键的数组组合在一起

Question

我是Ramda和currying的新手，但想结合两个不同的数组。 鉴于：

var array1 = [
 {_id: 0, x: 10},
 {_id: 1, x: 30}
];

var array2 = [
  {UUID: 0, y: 20},
  {UUID: 1, y: 60}
];

我想在_id === UUID地方加入他们，得到这样的东西：

var result = [
  {_id: 0, UUID: 0, x: 10, y: 20},
  {_id: 1, UUID: 1, x: 30, y: 60}
];

我看了看文档， where ， intersection和merge似乎是要使用的文档。 但是intersection和merge期望使用相同的键。 似乎在where ，但是我仍然不确定如何告诉我我想要两个不同的键具有相同的值。

因此，我认为可以使用forEach ， find和equals一个或多个来镜像POJS方式。 下面是我在想什么（无intersection或where使用至今）：

import r from 'ramda';
var result = 
  r.forEach(
    r.find(
      r.equals(
        r.prop('UUID', r._),
        r.prop('_id', r._)
      ), data, metadata);

我只停留在如何从两个数组中检查单独的键（ UUID和_id ），同时又保留功能符号的情况下。 我相信我会做错所有的事情，但是我的想法很沮丧，我将首先尝试简单的Javascript方法。

Answer 1

可以使用R.indexBy ， R.mergeWith和R.merge ：

//  propMerge :: String -> String -> Array Object -> Array Object -> Array Object
var propMerge = R.curry(function(k1, k2, xs1, xs2) {
  return R.values(R.mergeWith(R.merge,
                              R.indexBy(R.prop(k1), xs1),
                              R.indexBy(R.prop(k2), xs2)));
});

Answer 2

您想要的可能是使用生成器 。 像这样：

arr1.sort((a, b) => a._id - b._id);
arr2.sort((a, b) => a.UUID - b.UUID);

let step1 = arr1[Symbol.iterator]();
let step2 = arr2[Symbol.iterator]();

let zipSeq = (first, second) => {
  let done = false, result = [];
  while (!done) {
    let obj = first.next();
    let check = second.next();
    while (check.value.UUID !== obj.value._id && !check.done) {
      check = second.next(); // make sure we account for non-sequential
    }
    result.push(Object.assign({}, obj.value, check.value));
    done = obj.done || check.done;
  }
  return result;
};

let mixed = zipSeq(step1, step2);

通用化zipSeq函数以采用任意生成器，并且将合并回调作为zipSeq留给读者。

解决此问题的方法肯定比惰性序列更紧凑，但是比重复搜索第二个数组的匹配项要短得多，而且几乎可以肯定是性能更高的，而且比维护和递增两个单独的索引变量来一次完成这两个过程要简单得多。

由于根据您的评论始终存在匹配项，因此您可以按上述进行排序，然后执行以下操作：

let results = R.zip(arr1, arr2, (a, b) => Object.assign({}, a, b));

Answer 3

既然你想到了

“首先尝试使用简单的Javascript方法。”

这是使用Array.concat ， Array.find ， Array.indexOf ， Array.map ， Object.keys和Object.assign函数的原生 JavaScript替代解决方案：

var keys = ['_id', 'UUID'], result = {};

array1.concat(array2).forEach(function(obj){
    var value = obj[Object.keys(obj).find((v) => keys.indexOf(v) !== -1 )],
        props = Object.keys(obj);  // array of property names of the current object

    result[value] = result[value] || obj;
    if (Object.keys(result[value]).indexOf(props[0]) === -1) {
        Object.assign(result[value], obj);  // "merging" two objects
    }
}, result);
result = Object.keys(result).map((k) => result[k]);

console.log(JSON.stringify(result, 0, 4));

输出：

[
    {
        "_id": 0,
        "x": 10,
        "UUID": 0,
        "y": 20
    },
    {
        "_id": 1,
        "x": 30,
        "UUID": 1,
        "y": 60
    }
]