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

В 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')

Примечание: Проверьте больше о заполнении (...) и 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]

В Лодаше все не так плохо

_.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'; })

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

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

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

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

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

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

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

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

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

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

Если вы используете пояс utlity, например, 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"]