创建一个数组，同一元素重复多次

没有更简单的方法了。您需要创建一个循环并将元素推入数组。

你可以这样做:

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;
}

你也可以像这样扩展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]

我应该指出，如果您使用第三方库，扩展内置对象的功能可能会导致问题。在做决定时一定要考虑到这一点。

这个函数创建一个长度为(length)的元素数组，只要(value)为整数或整数字符串，每个元素都等于(value)。任何十进制数都将被截断。如果你想要小数，将“方法(”替换为“parseFloat (”

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]

[c] * n可以写成:

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

所以对于[2] * 5

Array(6).join(1).split('').map(function(){return 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)

# EYZ0:

现在你可以有一组重复的字符。

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

注意:查看更多关于填充(…)和从(…)的兼容性和浏览器支持。

# EYZ0:

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

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

同上文回答。为了完整而添加。

我有问题与提到的方法，当我使用数组像

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;
};

另一个一行程序:

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

在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);

如果你需要重复数组几次:

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']

灵感来自这个答案

如果你正在使用一个多功能带，如lodash/下划线，你可以这样做:)

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

在ES6中使用array# EYZ0方法

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

我今天在尝试制作一个不使用循环的2D数组时发现了这一点。回想起来，加入一个新数组很简单;我尝试映射一个新数组，这不能作为映射跳过空槽。

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

新的填充方法更好，当我编码这个我不知道它的存在，我也不知道repeat是es6;我打算写一篇博客，介绍如何将这个技巧与reduce结合起来做一些很酷的事情。

< a href = " http://jburger.us。/ 2016/07/14 / functionally-create-a-2d-array /“rel = " http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/ nofollow”> < / >

# EYZ0

或者创建值递增的数组

# EYZ0

也可以作为一行语句使用:

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)的数组

试试这个:

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

我需要一种方法来重复/循环一个数组(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"]

使用这个函数:

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']

在Node.js的REPL中:

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

如果需要重复一个数组，请使用下面的方法。

Array(3).fill(['a','b','c']).flat()

将返回

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

这可能是另一个答案。

让卡=[“A",“2“,“3”、“4”、“5”、“6”、“7”、“8”,“9”,“10“,“J",“Q",“K"];

let totalCards =[…]卡,…卡,…卡,……卡);

您可以使用spreadoperator和map()函数创建一个数组，该数组多次重复相同的元素。

function fillArray(value,len){
return [...Array(len).keys()].map(x=> value);
}

.．.Array.fill()来拯救它!

以前写这一切手动知道这一个🤦🏽‍♂️

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


Array(4).fill(0)  // =>  [0, 0, 0, 0]

您还可以使用fill() + map()轻松创建顺序数组。

Array(4).fill('').map((_, i) => i + ' 🌵') // =>  ['0 🌵','1 🌵','2 🌵','3 🌵']




Array(3).fill(' 🌻').map((flower, i) => i + flower) // =>  ['0 🌻','1 🌻','2 🌻']

❗️只是在使用.fill()创建对象和数组时要小心，因为它们是引用的类型❗️

这意味着Javascript将把所有创建的项目视为相同的对象(如果您想进一步与创建的对象进行交互，可能会引入意想不到的错误)

// ❌ Careful when using .fill() with objects and arrays:


Array(3).fill({ value: 2 })  // =>  [{ value: 2 },{ value: 2 },{ value: 2 }]

上面的行可以工作，但坚持使用.fill().map()模式会更安全。是这样的:

// 👍🏽 Much better!


Array(3).fill().map(item => ({ value: 2 }))