Cree una matriz con el mismo elemento repetido varias veces

En Python, donde [2]hay una lista, el siguiente código proporciona esta salida:

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

¿Existe una manera fácil de hacer esto con una matriz en JavaScript?

Escribí la siguiente función para hacerlo, pero ¿hay algo más corto o mejor?

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

Puedes hacerlo así:

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

Duplica la matriz en cada iteración, por lo que puede crear una matriz realmente grande con pocas iteraciones.

Nota: También puede mejorar mucho su función utilizando en pushlugar de concat, ya concatque creará una nueva matriz en cada iteración. De esta manera (se muestra solo como un ejemplo de cómo puede trabajar con matrices):

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

En ES6 usando matriz de relleno () método

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]

puedes probar:

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

Actualización (01/06/2018) :

Ahora puedes tener un conjunto de personajes que se repiten.

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

Nota: Consulte más información sobre el relleno (...) y de (...) para ver la compatibilidad y el soporte del navegador.

Actualización (05/11/2019) :

Otra forma, sin usar fillo from, que funciona para cadenas de cualquier longitud:

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

Igual que la respuesta anterior . Agregar por el bien de la integridad.

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

o crear una matriz con un valor creciente

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

En lodash no es tan malo:

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

EDITAR : Aún mejor:

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

EDITAR : Aún mejor:

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

[c] * n Se puede escribir como:

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

entonces para [2] * 5

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

También puede ampliar la funcionalidad de Array de esta manera:

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] 

Debo señalar que ampliar la funcionalidad de los objetos integrados puede causar problemas si está trabajando con bibliotecas de terceros. Siempre pon esto en tus decisiones.

En el Node.js REPL:

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

En caso de que necesite repetir una matriz varias veces:

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

inspirado por esta respuesta

No hay manera más fácil. Necesita hacer un bucle e insertar elementos en la matriz.

Utiliza esta función:

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

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

O para una versión más compacta:

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

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

O para una versión con curry:

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

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

Puede usar esta función con una lista:

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

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

Si necesita repetir una matriz, use lo siguiente.

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

volverá

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

Otra frase:

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

Esta función crea una matriz de elementos (longitud) donde cada elemento es igual a (valor) siempre que (valor) sea un entero o una cadena de un entero. Cualquier número decimal será truncado. Si desea números decimales, reemplace "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;
}

Ejemplos:

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]

Tuve problemas con los métodos mencionados cuando uso una matriz como

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

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

Para obtener esto estoy 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;
};

Descubrí esto hoy mientras intentaba hacer una matriz 2D sin usar bucles. En retrospectiva, unirse a una nueva matriz es ordenado; Intenté mapear una nueva matriz, que no funciona ya que el mapa omite los espacios vacíos.

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

El carácter "#" puede ser cualquier carácter único válido. El 5 sería una variable para la cantidad de elementos que desea. El 7 sería el valor con el que desea llenar su matriz.

El nuevo método de relleno es mejor, y cuando codifiqué esto no sabía que existía, ni sabía que repetir es6; Voy a escribir una publicación de blog sobre el uso de este truco en conjunto con reduce para hacer cosas geniales.

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

Prueba esto:

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

Si está utilizando un cinturón de utlidad como lodash / subrayado, puede hacerlo así :)

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

También se puede usar como una sola línea:

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

Mejorando la respuesta de Vivek , esto funciona para cadenas de cualquier longitud, para llenar una matriz de longitud n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Necesitaba una forma de repetir / repetir una matriz (con n elementos) m veces.

Por ejemplo, distribuir una lista (de personas) a una semana / mes. Digamos que tengo 3 nombres, y quiero que se repitan en una semana:

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