复制数组任意次数(javascript)

Question

假设我给了一个数组.这个数组的长度是3,有3个元素:

var array = ['1','2','3'];

最后我需要检查这个数组是否等于具有相同元素的数组,但现在只需要两次.我的新阵列是:

var newArray = ['1','2','3','1','2','3'];

我知道我可以使用array.splice()来复制数组,但是如何复制它的次数不明？基本上我想要的是会产生影响的东西

var dupeArray = array*2;

Answer 1

const duplicateArr = (arr, times) =>
    Array(times)
        .fill([...arr])
        .reduce((a, b) => a.concat(b));

这应该有效。它会创建一个大小为您想要复制它的次数的新数组。它用数组的副本填充它。然后它使用 reduce 将所有数组连接成一个数组。

Answer 2

最简单的解决方案往往是最好的解决方案：

function replicate(arr, times) {
     var al = arr.length,
         rl = al*times,
         res = new Array(rl);
     for (var i=0; i<rl; i++)
         res[i] = arr[i % al];
     return res;
}

（或使用嵌套循环，例如@UsamaNorman）。

但是，如果你想聪明，你也可以concat将数组重复给自己：

function replicate(arr, times) {
    for (var parts = []; times > 0; times >>= 1) {
        if (times & 1)
            parts.push(arr);
        arr = arr.concat(arr);
    }
    return Array.prototype.concat.apply([], parts);
}

Answer 3

这是一种相当简洁的非递归方法，可以将数组复制任意次数：

function replicateArray(array, n) {
  // Create an array of size "n" with undefined values
  var arrays = Array.apply(null, new Array(n)); 

  // Replace each "undefined" with our array, resulting in an array of n copies of our array
  arrays = arrays.map(function() { return array });

  // Flatten our array of arrays
  return [].concat.apply([], arrays);
}

console.log(replicateArray([1,2,3],4)); // output: [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

这是怎么回事？

前两行使用apply和map创建一个由数组的“n”个副本组成的数组。

最后一行用于apply 展平我们最近生成的数组。

说真的，到底发生了什么事？

如果您没有使用过 apply 或 map，代码可能会令人困惑。

这里的第一个魔法是使用apply()它可以将数组传递给函数，就好像它是参数列表一样。

Apply 使用三条信息：x.apply(y,z)

• x 是被调用的函数
• y 是调用该函数的对象（如果null，则使用global）
• z 是参数列表

用代码来说，可以翻译为：y.x(z[0], z[1], z[2],...)

例如

var arrays = Array.apply(null, new Array(n));

和写作一样

var arrays = Array(undefined,undefined,undefined,... /*Repeat N Times*/);

第二个魔法是使用map()它为数组的每个元素调用一个函数并创建一个返回值列表。

这使用了两条信息：x.map(y)

• x 是一个数组
• y 是对数组的每个元素调用的函数

例如

var returnArray = [1,2,3].map(function(x) {return x + 1;});

将创建数组 [2,3,4]

在我们的例子中，我们传入一个函数，它总是返回一个静态值（我们想要复制的数组），这意味着这个映射的结果是我们数组的 n 个副本的列表。