Question

假设我有一个阵列。这个数组的长度是3，有3个元素：

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

最终我需要检查这个数组是否等于具有相同元素的数组，但现在只需要两次。我的新阵列是：

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

我知道我可以使用array.splice（）来复制数组，但是如何将它复制到未知的次数？基本上我想要的是具有

效果的东西

var dupeArray = array*2;

Answer 1

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

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 2

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

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

Answer 3

你可以这样做：

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


function nplicate(times, array){
      //Times = 2, then concat 1 time to duplicate. Times = 3, then concat 2 times for duplicate. Etc.
     times = times -1;
     var result = array;

    while(times > 0){
        result = result.concat(array);
        times--;
    }

    return result;
}

console.log(nplicate(2,array));

你将同一个数组连续n次。

使用concat函数和一些逻辑：http://www.w3schools.com/jsref/jsref_concat_array.asp

Answer 4

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

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来创建数组的an array of "n" copies。

最后一行使用apply to flatten我们最近生成的数组数组。

说真的，发生了什么？

如果您还没有使用过应用或地图，则代码可能会造成混淆。

这里的第一块魔术酱是使用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个副本的列表。

Answer 5

基本但为我工作。

var num = 2;

while(num>0){
array = array.concat(array);
num--}

Answer 6

我认为你必须编写自己的函数，试试这个：

function dupArray(var n,var arr){
var newArr=[];
for(var j=0;j<n;j++)
    for(var i=0;i<arr.length;i++){
        newArr.push(arr[i]);
    }
return newArr;
}

Answer 7

一个相当粗略的解决方案，用于检查它是否重复...... 您可以使用模数检查长度的变化：

然后，如果可能，循环内容并比较每个值，直到完成。如果在结束之前它在任何时候都不匹配，那么它要么在结束之前没有重复或停止重复。

if (array2.length % array1.length == 0){
    // It might be a dupe
    for (var i in array2){
        if (i != array1[array2.length % indexOf(i)]) { // Not Repeating }
    }
}

Answer 8

保持简短和甜蜜

function repeat(a, n, r) {
    return !n ? r : repeat(a, --n, (r||[]).concat(a));
}

console.log(repeat([1,2,3], 4)); // [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

<强> http://jsfiddle.net/fLo3uubk/

Answer 9

如果您在循环内，则可以使用数组长度验证当前循环索引，然后将其内容相乘。

let arr = [1, 2, 3];

if(currentIndex > arr.length){ 
  //if your using a loop, make sure to keep arr at a level that it won't reset each loop

  arr.push(...arr);

}

完整示例： https://jsfiddle.net/5k28yq0L/

复制数组任意次数（javascript）

9 个答案: