objetos - javascript for each

Crea una matriz con el mismo elemento repetida varias veces

Question

En Python, donde [2] es 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;
};

Answer 1

Descubrí esto hoy mientras intentaba hacer una matriz 2D sin usar bucles. En retrospectiva, unirse a una nueva matriz es nítido; Intenté mapear una nueva matriz, que no funciona ya que el mapa omite las ranuras vacías.

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

El carácter "#" puede ser cualquier carácter único válido. El 5 sería una variable para el número 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 es es6; Voy a escribir una publicación en el blog sobre el uso de este truco en conjunto con reducir para hacer cosas geniales.

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

Answer 2

En lodash no es tan malo:

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

EDIT : aún mejor:

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

EDIT : aún mejor:

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

Answer 3

En ES6 usando el método Array fill()

Array(5).fill(2)
//=> [2, 2, 2, 2, 2]

Answer 4

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

Answer 5

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

Answer 6

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

Answer 7

No hay forma más fácil. Es necesario hacer un bucle y empujar elementos en la matriz.

Answer 8

Otro de una sola línea:

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

Answer 9

Prueba esto:

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

Answer 10

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 push lugar de concat , ya que concat creará una nueva matriz en cada iteración. De esta forma (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;
}

Answer 11

Si está utilizando un cinturón de utlity como lodash / guión bajo, puede hacerlo así :)

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

Answer 12

También puede ampliar la funcionalidad de Array así:

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 tener en cuenta que extender la funcionalidad de los objetos incorporados puede causar problemas si trabaja con bibliotecas de terceros. Siempre pesa esto en tus decisiones.

Answer 13

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

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

Answer 14

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

Answer 15

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 repitiendo.

new Array(5).fill(''a''); // give the same result as above;

Nota: busque asistencia ( https://mzl.la/1tBUwu4 ).

Answer 16

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

o crear matriz con valor creciente

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

Answer 17

[c] * n puede escribirse como:

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

así que para [2] * 5

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

Answer 18

var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);

Answer 19

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