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

У 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.01.2018) :

Тепер ви можете повторити набір символів.

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

Примітка: Перевірте детальніше про заливку (...) та від (...) на сумісність та підтримку браузера.

Оновлення (11.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]

EDIT : Ще краще:

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

EDIT : Ще краще:

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

Ця функція створює масив (довжина) елементів, де кожен елемент дорівнює (значення) до тих пір, як (значення) - ціле число або рядок цілого числа. Будь-які десяткові числа будуть усічені. Якщо ви хочете десяткових чисел, замініть "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;
};

Я виявив це сьогодні, намагаючись зробити 2D масив без використання циклів. Зрештою, приєднання до нового масиву є акуратним; Я спробував зіставити новий масив, який не працює, оскільки карта пропускає порожні слоти.

"#".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(" ");

Якщо ви користуєтеся поясом, наприклад лодаш / підкреслення, ви можете зробити це так :)

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

Удосконалюючись у відповідь Вівека , це працює для рядків будь-якої довжини, щоб заповнити масив довжиною n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Мені знадобився спосіб повторити / циклічити масив (з n елементів) м разів.

Наприклад, розповсюдження списку (осіб) на тиждень / місяць. Скажімо, у мене є 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"]