Crea un array con lo stesso elemento ripetuto più volte

In Python, dove [2]è presente un elenco, il seguente codice fornisce questo output:

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

Esiste un modo semplice per farlo con un array in JavaScript?

Ho scritto la seguente funzione per farlo, ma c'è qualcosa di più breve o migliore?

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

Puoi farlo in questo modo:

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

Raddoppia l'array in ogni iterazione, quindi può creare un array davvero grande con poche iterazioni.

Nota: puoi anche migliorare molto la tua funzione usando pushinvece di concat, in quanto concatcreerà un nuovo array ogni iterazione. In questo modo (mostrato solo come esempio di come lavorare con le matrici):

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

In ES6 utilizzando il metodo fill () dell'array

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]

Puoi provare:

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

Aggiornamento (01/06/2018) :

Ora puoi ripetere una serie di personaggi.

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

Nota: controlla di più su fill (...) e da (...) per compatibilità e supporto del browser.

Aggiornamento (05/11/2019) :

Un altro modo, senza usare fillo from, che funziona con una stringa di qualsiasi lunghezza:

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

Come sopra la risposta . Aggiungendo per completezza.

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

o creare un array con valore crescente

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

A lodash non è poi così male:

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

EDIT : Ancora meglio:

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

EDIT : Ancora meglio:

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

[c] * n può essere scritto come:

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

così per [2] * 5

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

Puoi anche estendere le funzionalità di Array in questo modo:

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] 

Devo notare che l'estensione della funzionalità degli oggetti incorporati può causare problemi se si lavora con librerie di terze parti. Pesare sempre questo nelle tue decisioni.

Nel REPL Node.js:

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

Nel caso in cui sia necessario ripetere più volte un array :

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

ispirato da questa risposta

Nessun modo più semplice. È necessario creare un ciclo e inserire elementi nell'array.

Usa questa funzione:

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

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

O per una versione più compatta:

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

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

O per una versione in grado di curry:

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

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

È possibile utilizzare questa funzione con un elenco:

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

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

Se è necessario ripetere un array, utilizzare quanto segue.

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

sarà di ritorno

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

Un altro one-liner:

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

Questa funzione crea una matrice di (lunghezza) elementi in cui ciascun elemento è uguale a (valore) purché (valore) sia un numero intero o una stringa di un numero intero. Eventuali numeri decimali verranno troncati. Se vuoi numeri decimali, sostituisci "parseInt ( " con " 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;
}

Esempi:

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]

Ho avuto problemi con i metodi citati quando utilizzo un array come

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

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

Per ottenere questo sto usando:

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

L'ho scoperto oggi mentre cercavo di creare un array 2D senza usare i loop. In retrospettiva, unire un nuovo array è pulito; Ho provato a mappare un nuovo array, che non funziona poiché la mappa salta slot vuoti.

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

Il carattere "#" può essere qualsiasi carattere singolo valido. Il 5 sarebbe una variabile per il numero di elementi desiderati. Il 7 sarebbe il valore che vuoi riempire il tuo array.

Il nuovo metodo di riempimento è migliore e quando l'ho codificato non sapevo che esistesse, né sapevo che la ripetizione è es6; Scriverò un post sul blog sull'uso di questo trucco in tandem con Riduci per fare cose interessanti.

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

Prova questo:

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

Se stai usando una cintura di utilità come lodash / underscore puoi farlo in questo modo :)

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

Può essere usato anche come un liner:

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

Migliorando la risposta di Vivek , questo funziona con stringhe di qualsiasi lunghezza, per popolare una matrice di lunghezza n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Avevo bisogno di un modo per ripetere / eseguire il loop di un array (con n elementi) m volte.

Ad esempio, distribuendo un elenco (di persone) a una settimana / mese. Diciamo che ho 3 nomi e che voglio ripetere tra una settimana:

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