JavaScript组合了三个2D数组，保持第一个值唯一

JavaScript combining three 2D arrays, keeping first values unique

本文关键字：数组 第一个 唯一 2D 三个 组合 JavaScript      更新时间：2023-09-26

我有三个这样的2D数组，其中每个2D数组中的每个子数组中的第一个值对于该数组是唯一的。但是，其中一些数组可能缺少值。

例子: 

var a = [[1, 10], [2, 20], [3, 20]];
var b = [[1, 20], [2, 10]];
var c = [[2, 30]];

阵列a的值为1、2、3，阵列b的值为1、2，阵列c的值为2。

我想把这三个数组组合成一个新的最终数组，假设是d。数组d应该只包含每个第一个值中的一个，因此，例如，上面的三个数组将组合成。

d = [[1, 10, 20], [2, 20, 10, 30], [3, 20]];
我第一次<<p> em> half-arsed 尝试:

我可以用concat将三个数组组合成一个:

a = a.concat(b, c);
// a = [[1, 10], [2, 20], [3, 20], [1, 20], [2, 10], [2, 30]];

但是我不确定如何组合非唯一元素。我研究了一些underscore的函数，但我找不到一个有用的(尽管我对非常不熟悉下划线)。

第二次尝试:

// First combine just a and b
for(var ai = 0; ai < a.length; ai++) {
  var inserted = false;
  for(var bi = 0; bi < b.length; bi++) {
    if(a[ai][0] == b[bi][0]) {
      d.push([(a[ai][0]), (a[ai][1]), (b[bi][1])]);
      inserted = true;
    }
  }
  if(!inserted) {
    d.push([(a[ai][0]), (a[ai][1])]);
  }
}
// Then repeat the above with d and c

这个解决方案的问题是，如果a的元素比b少，结果将不包括b中a没有的元素。我可以编写一系列荒谬的循环，但这只会非常低效，并且进行如此多的JSON调用已经对网站速度造成了影响。

你可以试试下面的代码:

var a = [[1, 10], [2, 20], [3, 20]];
var b = [[1, 20], [2, 10]];
var c = [[2, 30]];
var d = a.concat(b,c);
var e = [];
//loop through all the inner arrays
//the first item in each array is considered as key
//the second is considered as value and should be pushed into some array 
//which can be accessed via the key.
for(var i = 0; i < d.length; i++){    
  if(!e[d[i][0]]) e[d[i][0]] = [d[i][0]];    
  e[d[i][0]].push(d[i][1]);
}
d = [];
for(var i = 0; i < e.length; i++){
  if(e[i]) d.push(e[i]);
}
console.log(d);

演示。

试试这个:

function concat(first, second) {
    var result = [],
        i = 0,
        j = 0,
        k = 1;
    if (second.length > first.length) {
        result = second.slice();
        first = first.slice();
    } else {
        result = first.slice();
    }
    for (i = 0; i < result.length; i++) {
        for (j = 0; j < second.length; j++) {
            if (result[i][0] === second[j][0]) {
                for (k = 1; k < second[j].length; k++) {
                    result[i].push(second[j][k]);
                }
            }
        }
    }
    return result;
}

既然每个子数组的第一个元素都是唯一的，那么为什么不这样写呢:

var a = { 1: [10], 2: [20], 3: [20] };
var b = { 1: [20], 2: [10] };
var c = { 2: [30] };

让我们写一个函数来做这个:

var a = mapFrom2DArray([[1, 10], [2, 20], [3, 20]]);
var b = mapFrom2DArray([[1, 20], [2, 10]]);
var c = mapFrom2DArray([[2, 30]]);
function mapFrom2DArray(array) {
    var map = {}, length = array.length, index = 0;
    while (index < length) {
        var subarray = array[index++];
        map[subarray[0]] = subarray.slice(1);
    }
    return map;
}

现在让我们写一个组合子，它接受两个映射并将它们组合:

function combine(a, b) {
    var c = {};
    for (var k in a) c[k] = a[k];
    for (var k in b) {
        if (c.hasOwnProperty(k))
            c[k] = c[k].concat(b[k]);
        else c[k] = b[k];
    }
    return c;
}

现在我们简单地将这些地图reduce:

var d = mapToArray([a, b, c].reduce(combine));

哦，还有mapToArray的定义:

function mapToArray(map) {
    var array = [];
    for (var k in map) array.push([parseInt(k)].concat(map[k]));
    return array;
}

。参见演示:http://jsfiddle.net/56B6T/1

相关文章：