Javascript将数组拆分为n个子数组，块的大小为'；没关系

我想把一个数组分成n个子数组。 我不在乎每个数组中有多少个元素，但这些元素必须分布在所有可用的子数组中

像这样，解决方案A和B是两种方法，但我正在寻找解决方案A：

a=[1,2,3,4,5,6,7,8,9]

进入_子阵（a，2）

• 溶液A=>[[1,3,5,7,9]，[2,4,6,8]]
• 溶液B=>[[1,2,3,4,5]，[6,7,8,9]]

进入_子阵（a，4）

• 解决方案A=>[[1,5,9]，[2,6]，[3,7]，[4,8]]
• 溶液B=>[[1,2,3]，[4,5]，[6,7]，[8,9]]

进入_子阵（a，6）

• 解A=>[[1,7]，[2,8]，[3,9]，[4]，[5]，[6]]
• 解决方案B=>[[1,2]，[3,4]，[5,6]，[7]，[8]，[9]]

进入_子阵（a，12）

• 解决方案A=>[[1]、[2]、[3]、[4]、[5]、[6]、[7]、[8]、[9]、[]、[]、[]、[]
• 解决方案B=>[1]、[2]、[3]、[4]、[5]、[6]、[7]、[8]、[9]、[]、[]、[]、[]

我有这个解决方案，我只想确保它尽可能高效：

into_subarrays(myArray, chunks=2){
  var a = myArray.slice(); //Copy array so that the original is not modified
  var i = 0;
  var result = [];
          
  while(a.length){
   //Create array if needed
   if (typeof result[i] == 'undefined'){
     result[i] = [];
   }

   result[i].push(a.shift());
   i++;
   i = (i == chunks) ? 0 : i; //Wrap around chunk selector
  }

  return result;
}

---

谢谢。

我可以建议一些更紧凑的：

const src=[…'abcdefghijklmn']，
chunkArr=（arr，数量）=>
arr.reduce（（r，e，i）=>
（r[i%数量]。推（e），r），
[…数组（数量）].map（=>[]））
console.log（chunkArr（src，4））

---

。作为控制台包装{minheight:100%；}

关于您当前的方法，有几点需要注意

我个人不会使用

if（typeof result[I]==“undefined”）

。相反，您可以省略

typeof

并执行

if（result[i]==undefined）

。但是，由于您知道该值要么是数组，要么根本不存在，因此检查（！result[i]）就足够了

行

i++

和

i=（i==块）？如果使用余数运算符，则可以组合0:i

。产生

i=（i+1）%chunk

您的解决方案仅在需要新阵列时添加空阵列。当您尝试使用当前解决方案执行子阵列（a，12）时，这将导致无效结果。最好先用

Array.from（{length:chunks}，（）=>[]）

之类的东西创建正确数量的数组。这也将消除对if语句的需要

应用上述方法，结果将类似于：

函数到_子数组（数组，块=2）{
array=array.slice（）；//复制数组，以便不修改原始数组
const result=Array.from（{length:chunks}，（）=>[]）；
for（设i=0；array.length；i=（i+1）%chunks）{
结果[i].push（array.shift（））；
}
返回结果；
}
常量数组=[1,2,3,4,5,6,7,8,9]；
log（进入_子数组（数组，4））；
log（进入_子数组（数组，12））大多数微基准测试的差异将归结为以下优化：


你的问题需要更多的上下文来关联。取决于引擎/环境特定的优化、块大小、数据集大小和数据类型（用于利用打包优化）。性能特征可能会有所不同，这会成为一个意见问题，而不是事实问题，因为它只是一个猜测，当现实世界中的情况很可能是这样的时候，它并不是你的瓶颈。

例如：在React中，不变性为库用户提供了性能优势，但React开发人员在内部使用了上述链接优化。

尽管如此，绩效的相关性仍有争议，应该用真实世界的数据来衡量。这些优化不太可能适用于您

例如，生成器方法不必迭代整个列表并构建整个列表，在不必迭代整个数组并将所有内容存储在内存中的情况下，其性能可能会显著提高。在一个需要多次运行的微型计算机中，挑战在于使用一个具有本机级别访问优化的同质阵列构建整个列表，这只会增加开销

到目前为止，关于其他答案和演示代码性能的一些要点：


（相对V8（铬合金）而言）
使用
shift
（+push）非常慢
访问超出实际长度的数组索引会中断快速路径
生成器延迟了性能，而在microbench中，OP的给定问题只会增加阵列访问的开销
对于小型阵列，几乎看不到任何差异。几乎都是对象初始化
较大的块也会缩小差距

此处的基准：

注意：调整数组大小和块大小将极大地改变结果

由于避免了开销、对象初始化和压缩优化，For循环实现将优于所有其他答案。还可控制内存使用：


array=[1,2,3,4,5,6,7,8,9]
常量块=（a，n）=>{
常数res=[]
for（设i=0；i对于（设j=0；j<（a.长度/n | 0）+（这个问题可能更适合。谢谢，我不知道这个问题的存在。我将把我的答案作为解决方案发布到codereview。StackExchange这是解决方案B真的，我在寻找解决方案a。@Nelo:最新的更新实现了你所谓的“解决方案a”，它比你当前的codeArray快20%左右。from和shift are只是缓慢（相对而言），OP的while循环方法会破坏v8压缩选项。
数组（数量）.fill（）.map（=>[]）
并删除| |[]检查，问题已解决。或
…fill（[]，数量，arr.length）
如果指向同一引用的空数组是可以接受的。或者停止尝试一行，让循环填充其余部分。@3limin4t0r:已修复，请随时删除您的注释，不再重复relevant@user120242
into_subarrays(myArray, chunks=2){
  var a = myArray.slice(); //Copy array so that the original is not modified
  var i = 0;
  var result = [];
          
  while(a.length){
   //Create array if needed
   if (typeof result[i] == 'undefined'){
     result[i] = [];
   }

   result[i].push(a.shift());
   i++;
   i = (i == chunks) ? 0 : i; //Wrap around chunk selector
  }

  return result;
}