如何在Javascript中最优地交织相同固定N长度的K个数组

我有下面的数据结构，这是一个列表列表

输入数据：

const attributes = {
AO:(15174) [Number …]
jointId:(15174) [Number …]
paletteIdx:(15174) [Number …]
position:(15174) [Array(3) …]
normal:(15174) [Array(3) …]
....//additional variable amount of properties
}

预期产出：

[AO[0], jointId[0], PaletteIdx[0], position[0][0], 
position[0][1], position[0][2], normal[0][0], 
normal[0][1], normal[0][2], AO[1], jointId[1], ...]

我需要将列表交错到一个组合的平面数组中。我尝试了一些不同的解决方案（嵌套循环），但似乎无法扩展。我最近的一次尝试是使用

eval

生成一些代码，将嵌套循环解决方案强制为一个过程

const attributeNames = Object.keys(attributes);

const funcBody = attributeNames.map((attributeName) => {
  return `attributes.${attributeName}[index],`;
}).join('\n');


const output = eval(`
  attributes[attributeNames[0]].reduce((acc, value, index) => {
    acc = acc.concat(${funcBody});
    return acc;
  }, []);
`);

这是一个不频繁的操作，我可能会转移到脱机进程，不幸的是，这将是一个现有系统的大型重构

（顺便说一句，为了避免浏览器中断，还可以使用浏览器。）

就拿你的例子来说，它没有在输出中包含我插入的元素，以使一个数组比其他三个数组长，我在输出中看到的相当于对列表的逐列遍历，也假设它们的长度相等

我们可以很容易地用

for

循环对其进行编码。如果这不能满足您的需求，请提供更多详细信息。对于数组元素，我们可以使用

const属性={
AO:[1,2,3]，
jointId:[4,5,6]，
paletteIdx:[7,8,9]，[10,11,12]，[13,14,15]，
位置：[[16,17,18]，[19,20,21]，[22,23,24]]
}
常量attributeNames=Object.key（属性）；
const funcBody=attributeName.map（（attributeName）=>{
返回`attributes.${attributeName}[index]，`；
}).join（'\n'）；
常量输出=eval(`
属性[AttributeName[0]]。减少（（acc、值、索引）=>{
acc=acc.concat（${funcBody}）；
返回acc；
}, []);
`);
log（'\'output\'来自问题中的代码：'+JSON.stringify（output））；
变量输出1=[]；
var n=属性[Object.keys（attributes）[0]].length；
for（让col=0；col（顺便说一下，为了避免浏览器中断，还可以使用。）

就拿你的例子来说，它没有在输出中包含我插入的元素，以使一个数组比其他三个数组长，我在输出中看到的相当于对列表的逐列遍历，也假设它们的长度相等

我们可以很容易地用
for
循环对其进行编码。如果这不能满足您的需求，请提供更多具体的详细信息。对于数组元素，我们可以使用


const属性={
AO:[1,2,3]，
jointId:[4,5,6]，
paletteIdx:[7,8,9]，[10,11,12]，[13,14,15]，
位置：[[16,17,18]，[19,20,21]，[22,23,24]]
}
常量attributeNames=Object.key（属性）；
const funcBody=attributeName.map（（attributeName）=>{
返回`attributes.${attributeName}[index]，`；
}).join（'\n'）；
常量输出=eval(`
属性[AttributeName[0]]。减少（（acc、值、索引）=>{
acc=acc.concat（${funcBody}）；
返回acc；
}, []);
`);
log（'\'output\'来自问题中的代码：'+JSON.stringify（output））；
变量输出1=[]；
var n=属性[Object.keys（attributes）[0]].length；
对于（让col=0；col我看不出哪里需要嵌套循环。这似乎非常简单：

const { AO: {length}, AO, jointId, paletteIdx, position, normal } = attributes;
const output = []; // test whether using `new Array(length * 9);` is better
for (let i=0, j=0; i<length; i++) {
  output[j++] = AO[i];
  output[j++] = jointId[i];
  output[j++] = PaletteIdx[i];
  output[j++] = position[i][0];
  output[j++] = position[i][1];
  output[j++] = position[i][2];
  output[j++] = normal[i][0];
  output[j++] = normal[i][1];
  output[j++] = normal[i][2];
}

const{AO:{length}，AO，jointId，paletteIdx，position，normal}=属性；
const output=[]；//测试使用`新数组（长度*9）；`是否更好
对于（设i=0，j=0；i我看不出哪里需要嵌套循环。这似乎非常简单：

const { AO: {length}, AO, jointId, paletteIdx, position, normal } = attributes;
const output = []; // test whether using `new Array(length * 9);` is better
for (let i=0, j=0; i<length; i++) {
  output[j++] = AO[i];
  output[j++] = jointId[i];
  output[j++] = PaletteIdx[i];
  output[j++] = position[i][0];
  output[j++] = position[i][1];
  output[j++] = position[i][2];
  output[j++] = normal[i][0];
  output[j++] = normal[i][1];
  output[j++] = normal[i][2];
}

const{AO:{length}，AO，jointId，paletteIdx，position，normal}=属性；
const output=[]；//测试使用`新数组（长度*9）；`是否更好
对于（让i=0，j=0；我可以请您添加一个输入数据和所需输出的示例吗？代码生成可能确实有助于加快速度，但concat？拜托，您可以做得更好。您可以发布简单的嵌套循环解决方案吗？eval代码真的很难理解，我不知道数据格式是什么，也不知道您需要哪种结果。@kevzettler
concat
需要创建一个完整的新数组，复制所有现有元素（我假设您在使用代码生成等高级方法时知道这一点）。如果您以速度为目标，则应仅附加到一个现有数组（使用
push
或直接赋值）.为什么
位置的顺序是
[0][0..2]
，而
正常的顺序是
[0][3]，[1][0]，[1][2]
在示例中？您能添加一个输入数据和所需输出的示例吗？代码生成可能确实有助于加快速度，但
concat
？拜托，您可以做得更好。您能发布简单的嵌套循环解决方案吗？
eval
代码真的很难理解，我不知道确切的数据格式是什么是和您需要的结果。@kevzettler
concat
需要创建一个完整的新数组，复制所有现有元素（我假设您在使用代码生成之类的高级方法时知道这一点）。如果您以速度为目标，您应该只附加到一个现有数组（使用
推送
或直接赋值）.为什么
位置的顺序是
[0][0..2]
，而
正常的顺序是
[0][3]，[1][0]，[1][2]
在本例中？我在代码中使用未知属性，这就是我使用代码生成的原因…@kevzettler哦，好吧，但是你仍然应该生成类似我的代码的东西，而不是使用
reduce
和
concat
：-）生成效率低下的东西我在代码中使用未知属性，这就是我使用代码生成的原因…@kevzettler哦，好吧，但是你仍然应该生成类似我的代码的东西，而不是使用
reduce
和
concat
：-）生成效率低下的东西