Crie uma matriz com o mesmo elemento repetido várias vezes

No Python, onde [2]está uma lista, o código a seguir fornece essa saída:

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

Existe uma maneira fácil de fazer isso com uma matriz em JavaScript?

Eu escrevi a seguinte função para fazê-lo, mas há algo mais curto ou melhor?

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

Você pode fazer assim:

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

Dobra a matriz em cada iteração, para criar uma matriz muito grande com poucas iterações.

Nota: Você também pode melhorar bastante sua função usando em pushvez de concat, pois concatcriará uma nova matriz a cada iteração. Assim (mostrado apenas como um exemplo de como você pode trabalhar com matrizes):

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

Em ES6 usando matriz de enchimento () 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]

podes tentar:

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

Atualização (01/06/2018) :

Agora você pode repetir um conjunto de caracteres.

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

Nota: Verifique mais sobre preenchimento (...) e de (...) para compatibilidade e suporte ao navegador.

Atualização (11/05/2019) :

Outra maneira, sem usar fillou from, que funciona para cadeias de caracteres de qualquer comprimento:

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

O mesmo que a resposta acima . Adicionando por uma questão de integridade.

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

ou criar matriz com valor crescente

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

No lodash não é tão ruim:

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

EDIT : Ainda melhor:

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

EDIT : Ainda melhor:

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

[c] * n pode ser escrito como:

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

então para [2] * 5

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

Você também pode estender a funcionalidade do Array da seguinte maneira:

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 observar que estender a funcionalidade de objetos internos pode causar problemas se você estiver trabalhando com bibliotecas de terceiros. Sempre avalie isso em suas decisões.

No NPL.js REPL:

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

Caso você precise repetir uma matriz várias vezes:

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 resposta

Não há maneira mais fácil. Você precisa fazer um loop e inserir elementos na matriz.

Use esta função:

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

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

Ou para uma versão mais compacta:

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

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

Ou para uma versão com capacidade para curry:

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

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

Você pode usar esta função com uma lista:

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

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

Se você precisar repetir uma matriz, use o seguinte.

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

retornará

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

Outra linha:

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

Essa função cria uma matriz de elementos (comprimento) em que cada elemento é igual (valor) desde que (valor) seja um número inteiro ou sequência de caracteres de um número inteiro. Quaisquer números decimais serão truncados. Se você deseja números decimais, substitua "parseInt ( " por " 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;
}

Exemplos:

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]

Eu tive problemas com os métodos mencionados quando uso uma matriz como

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

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

Para conseguir isso, estou 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;
};

Eu descobri isso hoje enquanto tentava fazer uma matriz 2D sem usar loops. Em retrospecto, juntar uma nova matriz é legal; Tentei mapear uma nova matriz, que não funciona, pois o mapa ignora os slots vazios.

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

O caracter "#" pode ser qualquer caractere único válido. O 5 seria uma variável para o número de elementos que você deseja. O 7 seria o valor com o qual você deseja preencher sua matriz.

O novo método de preenchimento é melhor e, quando codifiquei isso, não sabia que ele existia, nem sabia que repetir é es6; Vou escrever um post sobre como usar esse truque em conjunto com reduzir para fazer coisas legais.

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

Tente isto:

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

Se você estiver usando um cinto de utilidade como lodash / underscore, poderá fazê-lo assim :)

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

Também pode ser usado como uma linha:

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

Melhorando a resposta de Vivek , isso funciona para cadeias de qualquer comprimento, para preencher uma matriz de comprimento n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Eu precisava de uma maneira de repetir / repetir uma matriz (com n itens) m vezes.

Por exemplo, distribuindo uma lista (de pessoas) para uma semana / mês. Digamos que eu tenho 3 nomes e quero que eles repitam em uma 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"]