Создать массив с одним и тем же элементом, повторенным несколько раз

Ответ 1

Вы можете сделать это следующим образом:

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

Ответ 2

В ES6 с использованием метода Array fill()

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

Ответ 3

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

Ответ 4

Вы можете попробовать:

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 (...) см. на предмет совместимости и поддержки браузера.

Ответ 5

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

или создать массив с возрастающим значением

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

Ответ 6

В lodash это не так уж плохо:

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

EDIT: еще лучше:

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

EDIT: еще лучше:

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

Ответ 7

[c] * n может быть записана как:

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

поэтому для [2] * 5

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

Ответ 8

Вы также можете расширить функциональность массива так:

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] 

Я должен заметить, что расширение функциональности встроенных объектов может вызвать проблемы, если вы работаете с сторонними библиотеками. Всегда взвешивайте это в своих решениях.

Ответ 9

Нет более простого способа. Вам нужно сделать цикл и вставить элементы в массив.

Ответ 10

Если вам нужно повторить массив несколько раз:

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

вдохновлен этим ответом

Ответ 11

Другой однострочный:

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

Ответ 12

Используйте эту функцию:

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

Ответ 13

Эта функция создает массив (длина) элементов, где каждый элемент равен (значение), если (значение) является целым числом или строкой целого числа. Любые десятичные числа будут усечены. Если вы хотите десятичные числа, замените "parseInt (" на " 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]

Ответ 14

У меня были проблемы с указанными методами, когда я использую массив вроде

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

Ответ 15

Я обнаружил это сегодня, пытаясь сделать 2D-массив без использования циклов. Оглядываясь назад, объединение нового массива является опрятным; Я попытался сопоставить новый массив, который не работает, поскольку карта пропускает пустые слоты.

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

"#" char может быть любым допустимым одиночным символом. 5 будет переменной для количества элементов, которые вы хотите. Значение 7 будет значением, которое вы хотите заполнить своим массивом.

Новый метод заполнения лучше, и когда я закодировал это, я не знал, что он существует, и я не знаю, что повторение - это es6; Я собираюсь написать сообщение в блоге об использовании этого трюка в тандеме с уменьшением, чтобы сделать классные вещи.

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

Ответ 16

var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);

Ответ 17

В ответе Node.js:

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

Ответ 18

Если вы используете ленту utlity, например lodash/underscore, вы можете сделать это следующим образом:)

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

Ответ 19

Может использоваться как однострочный:

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

Ответ 20

Улучшение Vivek answer, это работает для строк любой длины, чтобы заполнить массив длины n: Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Ответ 21

Попробуй это:

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

Ответ 22

Мне нужен был способ повторить/зациклить массив (с 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"]