Question

我有一个函数，它通过行从二维数组中选取所有元素并返回一维数组。该数组具有可变数量的列和行。

示例：

let arr = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
];

返回：

[1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12]

我提出的功能：

convertList = (list) => {
    let result = [];
    let listTotalEntries = R.sum(R.map(R.length)(list));
    let mod = R.modulo(R.__, list.length);

        let counterRow = -1;

        for (let i = 0; i < listTotalEntries; i++) {
            if (mod(i) === 0) {
                counterRow++;
            }
            if (list[mod(i)][counterRow]) {
                result.push(list[mod(i)][counterRow]);
                console.log(list[mod(i)][counterRow]);
            }
        }
        console.log(result);
        return result;
};

问题：此函数仅适用于方形矩阵 - 如何使其与所包含数组的可变长度一起使用？

示例：

let arr = [
    [1, 2],
    [],
    [9, 10, 11, 12]
];

应该返回：

[1, 9, 2, 10, 11, 12]

感谢您的帮助！

莫夫

Answer 1

你试过这个简单的吗？

var singleDimensionArr = arr.reduce(function(prev,current){return prev.concat(current)});

例如

[
    [1, 2],
    [],
    [9, 10, 11, 12]
].reduce(function(prev,current){return prev.concat(current)});

输出[1, 2, 9, 10, 11, 12]

修改

基于以下OP的输入，因为连接需要按列发生

var max = Math.max.apply(null, arr.map(function (a) { return a.length; })); var finalArr = []; for( var i = 0; i < max; i++) { for( var j = 0; j < arr.length; j++) { arr[j][i] ? finalArr.push(arr[j][i]) : ""; } } console.log(arr);

Answer 2

我建议逐步完成数组

＆＃13;

var arr1 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
    arr2 = [[1, 2], [], [9, 10, 11, 12]];

function single(array) {
    var r = [],
        max = Math.max.apply(null, array.map(function (a) { return a.length; })),
        i = 0, j,
        l = array.length;

    while (i < max) {
        for (j = 0; j < l ; j++) {
            i in array[j] && r.push(array[j][i]);
        }
        i++;
    }
    return r;
}

document.write('<pre>' + JSON.stringify(single(arr1), 0, 4) + '</pre>');
document.write('<pre>' + JSON.stringify(single(arr2), 0, 4) + '</pre>');

＆＃13;

Answer 3

这里有ramda.js个标签。使用Ramda，它非常简单，因为有两个功能可以提供帮助：

const convertList = compose(flatten, transpose);
convertList(arr); //=> [1, 9, 2, 10, 11, 12]

transpose在主对角线上翻转矩阵，即将行更改为列，反之亦然。 flatten将列表列表转换为普通列表。所以compose就像这样创造了相当于list => flatten(transpose(list))。

您可以在 Ramda REPL 上看到这一点。

Answer 4

这个例子创建了一个大的稀疏数组，如果数组是正方形的话，将每个项放在它所属的位置。然后它过滤掉在没有输入项的情况下出现的空值。

＆＃13;

let arr = [
    [1, 2],
    [],
    [9, 10, 11, 12]
];

var out = arr.reduce(function(o,n,i,a) {
  for (var j=0;j<n.length;j++){
    o[a.length * j + i] = n[j];
  }
  return o;
},[]).filter(function(n) {
  return n !== null;
});

alert(JSON.stringify(out));

＆＃13;

迭代包含不同长度数组的二维数组行

4 个答案: