使用序列输出从每个数组数组中获取数据

如何解决使用序列输出从每个数组数组中获取数据

我正在尝试获取每个数组数组的序列索引，就像我有一个数组元素一样，并且 5 个数组有多个元素，我想获取每个数组的第一个索引，然后是第二个，依此类推。

下面是我的数组数据

ListOperationTrait

和我预期的输出 const arrData = [[1,2,4,6],[3,8,7],[12,13],[],[9,10]];

给我一些解决我问题的解决方案

解决方法

以下可能有效：

const src = [[1,2,4,6],[3,8,7],[12,13],[],[9,10]],pickByOne = arr => {
        const result = [],{length} = arr.flat()
        while(result.length < length){
          for(a of arr){
            a.length && result.push(a.shift())
          }
        }
        return result
      }
      
console.log(pickByOne(src))

您也可以使用 lodash 中的 zip。由于该函数采用一系列参数并且您有一个数组，因此您需要使用 ...

展开数组

const _ = require("lodash");
const arrData = [[1,10]];
const z =  _.zip(...arrData)

这会给你以下结果：

[
  [ 1,3,12,undefined,9 ],[ 2,13,10 ],[ 4,7,undefined ],[ 6,undefined ]
]

您已经可以看到它按照您想要的顺序排列。现在收拾东西。您可以以最简单的形式使用 flatMap 来展平数组。

// lodash
const fm = _.flatMap(z)

// or with Array.prototype.flat()
const fm = z.flat()

这会给你一个数组。

[
  1,9,10,6,undefined
]

现在您只需通过过滤（保留）所有不是 undefined 的元素来删除所有 undefined 元素。

// lodash
_.filter(fm,_.negate(_.isUndefined))

你就有了最终的结果。

[1,6]

有很多方法可以解决这个问题，因此您需要根据自己的具体情况做出决定，并在简单性、代码易读性、效率等之间取得平衡。

求子数组的最长长度，使用Array.map()得到所有子数组的长度，Math.max()。使用 Array.from() 创建一个长度为最长长度的数组。对于创建的数组中的每个索引，使用 Array.flatMap() 从原始子数组中获取所有项。如果项目是 undefined，则使用 Nullish coalescing operator (??) 将其替换为一个空数组，Array.flatMap() 在展平结果数组时将忽略该数组。使用 Array.from() 展平 Array.flat() 的输出以获得单个数组。

const fn = arr =>
  Array.from({ length: Math.max(...arr.map(o => o.length)) },(_,i) => 
    arr.flatMap(o => o[i] ?? [])
  ).flat();

const arrData = [[1,10]];

const result = fn(arrData);

console.log(result);

您需要跟踪 init_app，它定义了每次迭代中要获取的元素的位置。
使用 index 循环，当特定 while 处的任何数组中没有剩余元素时，该循环将终止。
使用 .map 获取每个数组在索引处的元素列表
使用 .filter 删除此列表中的 index 元素，以防其中一个数组在索引处没有元素
使用.isEmpty检查这个列表是否为空，然后，终止

undefined

const arrData = [[1,10]];

let res = [],index = 0;

while(true) {
  const elementsAtIndex = _.filter(
    _.map(arrData,e => e[index]),e => e!==undefined
  );
  if(_.isEmpty(elementsAtIndex)) break;
  res = [...res,...elementsAtIndex];
  index++;
}

console.log(...res);

由于它是一个嵌套数组，您可以循环检查每个嵌套数组的第一个元素是否未定义。如果没有，您可以将其推送到结果数组中。我为您的 ref 编写了函数。请检查

 const arrData = [[1,10]];
    function sorter(arr) {
  var result = [];
  if (arr.length > 0) {
    for (var i = 0; i < arr.length; i++) {
      if (arr[i].length > 0) {
        if (arr[i][0] !== undefined) {
          result.push(arr[i][0]);
        }
      }
    }
  }
  return result;
}

console.log(sorter(arrData));

我希望这是你所期望的！如果您需要澄清，请联系我。

没有任何运算符的简单一个看起来像......

    const ipArr = [ [1,[8,10],[12],[14,15],[] ]
    let maxLength = 0
    for (let i = 0; i < ipArr.length; i++) {
        if (ipArr[i].length > maxLength) maxLength = ipArr[i].length
    }
    const opArr = []
    for (let j = 0; j < maxLength; j++) {
        for (let k = 0; k < ipArr.length; k++) {
            if (ipArr[k][j]) opArr.push(ipArr[k][j])
        }            
    }
    console.log('opArr = ',opArr)

请尝试我的以下解决方案可能会解决您的问题

let data = [[],[1,[]],index = 0;
data = data.filter(o => o.length != 0)
const result = [];
for (i = 0; i < data.length; i++) {
    if (data[i].length > index) {
        index = data[i].length
    }
    if (data[i].length > 0) {
        for (j = 0; j < index; j++) {
            if (data[j][i] != undefined) {
                result.push(data[j][i]);
            }
        }
    }
}
console.log("Result",result);