创建具有相同元素多次重复的数组

在Python [2]的列表中，以下代码给出此输出：

[2] * 5 # Outputs: [2,2,2,2,2]

是否存在使用JavaScript中的数组执行此操作的简便方法？

我编写了以下函数来做到这一点，但是有没有更短或更短的东西呢？

var repeatelem = function(elem, n){
    // returns an array with element elem repeated n times.
    var arr = [];

    for (var i = 0; i <= n; i++) {
        arr = arr.concat(elem);
    };

    return arr;
};

您可以这样做：

function fillArray(value, len) {
  if (len == 0) return [];
  var a = [value];
  while (a.length * 2 <= len) a = a.concat(a);
  if (a.length < len) a = a.concat(a.slice(0, len - a.length));
  return a;
}

它在每次迭代中将数组加倍，因此可以创建很少迭代的真正大数组。

注意：您还可以通过使用push代替来改善您的功能concat，因为concat每次迭代都会创建一个新的数组。这样（作为如何使用数组的示例显示）：

function fillArray(value, len) {
  var arr = [];
  for (var i = 0; i < len; i++) {
    arr.push(value);
  }
  return arr;
}

在ES6中，使用Array fill（）方法

Array(5).fill(2)
//=> [2, 2, 2, 2, 2]

>>> Array.apply(null, Array(10)).map(function(){return 5})
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
>>> //Or in ES6
>>> [...Array(10)].map((_, i) => 5)
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]

你可以试试：

Array(6).join('a').split(''); // returns ['a','a','a','a','a'] (5 times)

更新（01/06/2018）：

现在，您可以重复一组字符。

new Array(5).fill('a'); // give the same result as above;
// or
Array.from({ length: 5 }).fill('a')

注意：有关兼容性和浏览器支持的更多信息，请参见fill（...）和from（...）。

更新（05/11/2019）：

另一种方法，不使用fill或from，可用于任何长度的字符串：

Array.apply(null, Array(3)).map(_ => 'abc') // ['abc', 'abc', 'abc']

与上述答案相同。为了完整性而添加。

Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]

或创建增值数组

Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]

在lodash中，还不错：

_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]

编辑：甚至更好：

_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]

编辑：甚至更好：

_.fill(Array(5), 2);

[c] * n 可以写成：

Array(n+1).join(1).split('').map(function(){return c;})

因此对于 [2] * 5

Array(6).join(1).split('').map(function(){return 2;})

您还可以像这样扩展Array的功能：

Array.prototype.fill = function(val){
    for (var i = 0; i < this.length; i++){
        this[i] = val;
    }
    return this;
};
// used like:
var arry = new Array(5)​.fill(2);
// or
var arry = new Array(5);
arry.fill(2);


​console.log(arry);​ //[2, 2, 2, 2, 2] 

我应该注意，如果您使用第三方库，则扩展内置对象的功能可能会导致问题。始终将其纳入您的决策中。

在Node.js REPL中：

> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]

如果您需要重复一个数组几次：

var arrayA = ['a','b','c'];
var repeats = 3;
var arrayB = Array.apply(null, {length: repeats * arrayA.length})
        .map(function(e,i){return arrayA[i % arrayA.length]});
// result: arrayB = ['a','b','c','a','b','c','a','b','c']

受此答案启发

没有更简单的方法。您需要进行循环并将元素推入数组。

使用此功能：

function repeatElement(element, count) {
    return Array(count).fill(element)
}

>>> repeatElement('#', 5).join('')
"#####"

或更紧凑的版本：

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> repeatElement('#', 5).join('')
"#####"

或针对可咖喱的版本：

const repeatElement = element => count =>
    Array(count).fill(element)

>>> repeatElement('#')(5).join('')
"#####"

您可以将此功能与列表一起使用：

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> ['a', 'b', ...repeatElement('c', 5)]
['a', 'b', 'c', 'c', 'c', 'c', 'c']

如果需要重复一个数组，请使用以下内容。

Array.from({ length: 3 }).fill(['a','b','c']).flat()

将返回

Array(9) [ "a", "b", "c", "a", "b", "c", "a", "b", "c" ]

另一个单线：

Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })

该函数创建一个（长度）元素数组，其中每个元素等于（值），只要（值）是整数或整数字符串即可。任何十进制数字将被截断。如果您确实想要十进制数字，请用“ parseFloat（ ” 替换“ parseInt （ ”

function fillArray(length, intValue) {
     var vals = (new Array(length + 1)).join(intValue + '|').split('|').slice(0,length);
     for(var i = 0; i < length; i += 1) {
         vals[i] = parseInt(vals[i]);
     }
     return vals;
}

例子：

fillArray(5, 7) // returns [7,7,7,7,7]
fillArray(5, 7.5) // returns [7,7,7,7,7]
fillArray(5, 200) // returns [200,200,200,200,200]

我在使用类似数组时遇到上述方法的问题

var array = ['foo', 'bar', 'foobar'];
var filled = array.fill(7);

//filled should be ['foo', 'bar', 'foobar', 'foo', 'bar', 'foobar', 'foo']

为此，我正在使用：

Array.prototype.fill = function(val){
    var l = this.length;
    if(l < val){
        for(var i = val-1-l; i >= 0; i--){
            this[i+l] = this[i % l];
        }
    }
    return this;
};

我今天在尝试不使用循环而制作2D阵列时发现了这一点。回想起来，加入一个新的数组很整齐。我尝试映射新数组，但由于map跳过了空插槽，因此无法正常工作。

"#".repeat(5).split('').map(x => 0)

“＃”字符可以是任何有效的单个字符。5将是所需元素数量的变量。7是您要用来填充数组的值。

新的填充方法更好，当我对此进行编码时，我不知道它的存在，也不知道重复的是es6。我将写一篇博客文章，介绍如何结合使用此技巧和reduce来做一些有趣的事情。

http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/

尝试这个：

"avinash ".repeat(5).trim().split(" ");

如果您使用像lodash / underscore这样的实用皮带，可以这样：)

let result = _.map(_.times(foo), function() {return bar})

也可以用作单线：

function repeat(arr, len) {
    while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
    return arr;
}

改进Vivek的答案，这适用于任何长度的字符串，以填充长度为n的数组：Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

我需要一种方法来重复/循环一个数组（包含n个项）m次。

例如，将（人员）列表分发到一周/一个月。假设我有3个名字，我希望它们在一周内重复出现：

fillArray(["Adam", "Blair", "Curtis"], 7); // returns ["Adam", "Blair", "Curtis", "Adam", "Blair", "Curtis", "Adam"]

function fillArray(pattern, count) {
    let result = [];
    if (["number", "string"].includes(typeof pattern)) {
        result = new Array(5);
        result.fill(pattern);
    }
    else if (pattern instanceof Array) {
        for (let i = 0; i < count; i++) {
            result = result.concat(pattern);
        }
        result = result.slice(0, count);
    }
    return result;
}

fillArray("a", 5);        // ["a", "a", "a", "a", "a"]
fillArray(1, 5);          // [1, 1, 1, 1, 1]
fillArray(["a", "b"], 5); // ["a", "b", "a", "b", "a"]