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

我试图得到每个数组的序列索引，就像我有一个数组元素，5个数组有多个元素一样，我想得到每个数组的第一个索引，然后是第二个索引，依此类推

下面是我的数组数据

const arrData = [[1,2,4,6],[3,8,7],[12,13],[],[9,10]];

以及我的预期结果

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

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

• 您需要跟踪

  索引

  ，该索引定义了每个迭代中要获取的元素的位置

• 使用

  while

  循环，该循环将在某个

  索引处的任何数组中没有剩余元素时终止
  
  

• 用于获取索引处每个数组中的元素列表

• 如果其中一个数组的索引中没有元素，请使用删除此列表中未定义的

  元素
  
  

• 用于检查此列表是否为空，然后终止

const arrData=[[1,2,4,6]，[3,8,7]，[12,13]，[9,10]；
设res=[]，index=0；
while（true）{
常量elementsAtIndex=\过滤器(
_.map（arrData，e=>e[index]），
e=>e！==未定义
);
如果（u.isEmpty（elementsAtIndex））中断；
res=[…res，…elementsAtIndex]；
索引++；
}
console.log（…res）
由于它是一个嵌套数组，您可以循环检查每个嵌套数组的第一个元素是否未定义。如果否，则可以将其推入结果数组。我为您的参考编写了函数。请检查

 const arrData = [[1, 2, 4, 6], [3, 8, 7], [12, 13], [], [9, 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 arrData=[[1,2,4,6]，[3,8,7]，[12,13]，[9,10]；
功能分拣机（arr）{
var结果=[]；
如果（arr.length>0）{
对于（变量i=0；i0）{
if（arr[i][0]！==未定义）{
结果：push（arr[i][0]）；
}
}
}
}
返回结果；
}
控制台日志（分拣机（arrData））；

我希望这是你所期望的！如果您需要澄清，请联系我。
以下内容可能有效：


const src=[[1,2,4,6]，[3,8,7]，[12,13]，[9,10]，
pickByOne=arr=>{
常量结果=[]，
{length}=arr.flat（）
while（result.length
您也可以使用from
lodash
。由于函数接受一系列参数，并且您有一个数组，因此需要使用
…

const _ = require("lodash");
const arrData = [[1,2,4,6],[3,8,7],[12,13],[],[9,10]];
const z =  _.zip(...arrData)

这将为您提供以下结果：

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

你已经可以看到它是按你想要的顺序排列的。现在来收拾一下。您可以以最简单的形式使用
flatMap
来展平阵列

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

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

这将为您提供一个数组

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

现在，您只需要通过过滤（保留）所有未定义的元素来删除所有未定义的元素

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

你有你的最终结果

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

解决此问题的方法有很多，因此您需要根据具体情况做出决定，并在简单性、代码易读性、效率等方面取得平衡。
使用
array.map（）
获得所有子数组的长度，并使用
Math.max（）
找到子数组的最长长度。使用
Array.from（）
创建长度为最长的数组。对于创建的数组中的每个索引，使用
array.flatMap（）
从原始子数组中获取所有项。如果项未定义，请使用替换为空数组，在展平结果数组时，
array.flatMap（）
将忽略该空数组。使用
Array.flat（）
展平
Array.from（）
的输出以获得单个数组

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


const fn=arr=>
from（{length:Math.max（…arr.map（o=>o.length））}，（\ux，i）=>
arr.flatMap（o=>o[i]？？[]）
).flat（）；
常数arrData=[1,2,4,6]、[3,8,7]、[12,13]、[9,10]；
const result=fn（arrData）；
控制台日志（结果）简单的一个，没有任何操作符，看起来像

    const ipArr = [ [1, 2, 4, 6], [8, 9, 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)

const ipArr=[[1,2,4,6]，[8,9,10]，[12]，[14,15]，]
设maxLength=0
for（设i=0；imaxLength）maxLength=ipArr[i].length
}
常数opar=[]
对于（设j=0；j