¿Cuál es la forma más eficiente de concatenar N arrays?

¿Cuál es la forma más eficiente de concatenar N matrices de objetos en JavaScript?

Las matrices son mutables y el resultado puede almacenarse en una de las matrices de entrada.

Si está concatenando más de dos matrices, este concat()es el camino a seguir para mayor comodidad y rendimiento probable.

var a = [1, 2], b = ["x", "y"], c = [true, false];
var d = a.concat(b, c);
console.log(d); // [1, 2, "x", "y", true, false];

Para concatenar solo dos matrices, el hecho de que pushacepta múltiples argumentos que consisten en elementos para agregar a la matriz se puede usar en su lugar para agregar elementos de una matriz al final de otra sin producir una nueva matriz. Con slice()esto también se puede usar en lugar de, concat()pero parece que no hay una ventaja de rendimiento al hacerlo .

var a = [1, 2], b = ["x", "y"];
a.push.apply(a, b);
console.log(a); // [1, 2, "x", "y"];

En ECMAScript 2015 y versiones posteriores, esto se puede reducir aún más a

a.push(...b)

Sin embargo, parece que para matrices grandes (del orden de 100,000 miembros o más), la técnica que pasa una matriz de elementos push(ya sea usando apply()o el operador de propagación ECMAScript 2015) puede fallar. Para tales matrices, usar un bucle es un mejor enfoque. Consulte https://stackoverflow.com/a/17368101/96100 para más detalles.

[].concat.apply([], [array1, array2, ...])

editar : prueba de eficiencia: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie menciona en los comentarios que esto puede causar que el intérprete exceda el tamaño de la pila de llamadas. Esto quizás dependa del motor js, pero también obtuve el "Tamaño máximo de pila de llamadas excedido" en Chrome al menos. Caso de prueba: [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])). (También recibí el mismo error al usar la respuesta actualmente aceptada, por lo que uno está anticipando tales casos de uso o construyendo una biblioteca para otros, puede ser necesario realizar pruebas especiales sin importar la solución que elija).

Para personas que usan ES2015 (ES6)

Ahora puede usar la sintaxis de propagación para concatenar matrices:

const arr1 = [0, 1, 2],
      arr2 = [3, 4, 5];

const result1 = [...arr1, ...arr2]; // -> [0, 1, 2, 3, 4, 5]

// or...

const result2 = [...arr2, ...arr1]; // -> [3, 4, 5, 0, 1, 2]

El concat()método se usa para unir dos o más matrices. No cambia las matrices existentes, solo devuelve una copia de las matrices unidas.

array1 = array1.concat(array2, array3, array4, ..., arrayN);

Use Array.prototype.concat.apply para manejar la concatenación de múltiples matrices:

var resultArray = Array.prototype.concat.apply([], arrayOfArraysToConcat);

Ejemplo:

var a1 = [1, 2, 3],
    a2 = [4, 5],
    a3 = [6, 7, 8, 9];
Array.prototype.concat.apply([], [a1, a2, a3]); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

Si está en medio de canalizar el resultado a través de map / filter / sort, etc. y desea concatenar una matriz de matrices, puede usar reduce

let sorted_nums = ['1,3', '4,2']
  .map(item => item.split(','))   // [['1', '3'], ['4', '2']]
  .reduce((a, b) => a.concat(b))  // ['1', '3', '4', '2']
  .sort()                         // ['1', '2', '3', '4']

Para una matriz de múltiples matrices y ES6, use

Array.prototype.concat(...arr);

Por ejemplo:

const arr = [[1, 2, 3], [4, 5, 6], [7, 8 ,9]];
const newArr = Array.prototype.concat(...arr);
// output: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Ahora podemos combinar múltiples matrices usando ES6 Spread. En lugar de usar concat()para concatenar matrices, intente usar la sintaxis extendida para combinar múltiples matrices en una matriz aplanada. p.ej:

var a = [1,2];
var b = [3,4];
var c = [5,6,7];
var d = [...a, ...b, ...c];
// resulting array will be like d = [1,2,3,4,5,6,7]

resuelto así.

let arr = [[1, 2], [3, 4], [5, 6]];
 console.log([].concat(...arr));

Puede usar el sitio jsperf.com para comparar el rendimiento. Aquí hay un enlace a concat .

Comparación agregada entre:

var c = a.concat(b);

y:

var c = [];
for (i = 0; i < a.length; i++) {
    c.push(a[i]);
}
for (j = 0; j < b.length; j++) {
    c.push(b[j]);
}

El segundo es casi 10 veces más lento en cromo.

Fácilmente con la función concat:

var a = [1,2,3];
var b = [2,3,4];
a = a.concat(b);
>> [1,2,3,2,3,4]

Aquí hay una función por la cual puede concatenar múltiples números de matrices

function concatNarrays(args) {
    args = Array.prototype.slice.call(arguments);
    var newArr = args.reduce( function(prev, next) {
       return prev.concat(next) ;
    });

    return newArr;
}

Ejemplo

console.log(concatNarrays([1, 2, 3], [5, 2, 1, 4], [2,8,9]));

saldrá

[1,2,3,5,2,1,4,2,8,9]

Combinar matriz con Push:

const array1 = [2, 7, 4];
const array2 = [3, 5,9];
array1.push(...array2);
console.log(array1)

Usando el operador Concat y Spread:

const array1 = [1,2];
const array2 = [3,4];

// Method 1: Concat 
const combined1 = [].concat(array1, array2);

// Method 2: Spread
const combined2 = [...array1, ...array2];

console.log(combined1);
console.log(combined2);

Si tiene una matriz de matrices y desea concatenar los elementos en una sola matriz, intente con el siguiente código (Requiere ES2015):

let arrOfArr = [[1,2,3,4],[5,6,7,8]];
let newArr = [];
for (let arr of arrOfArr) {
    newArr.push(...arr);
}

console.log(newArr);
//Output: [1,2,3,4,5,6,7,8];

O si te gusta la programación funcional

let arrOfArr = [[1,2,3,4],[5,6,7,8]];
let newArr = arrOfArr.reduce((result,current)=>{
    result.push(...current);
    return result;
});

console.log(newArr);
//Output: [1,2,3,4,5,6,7,8];

O incluso mejor con la sintaxis ES5, sin el operador de propagación

var arrOfArr = [[1,2,3,4],[5,6,7,8]];
var newArr = arrOfArr.reduce((result,current)=>{
    return result.concat(current);
});
console.log(newArr);
//Output: [1,2,3,4,5,6,7,8];

Este camino es útil si no sabes el no. de matrices en el momento del código.

Acortar con ES6.

new Set([].concat(...Array));

Esto hace concat y único los múltiples arreglos;

Demo en codepen

donde 'n' es un número de matrices, tal vez una matriz de matrices. . .

var answer = _.reduce (n, function (a, b) {return a.concat (b)})

Si solo hay dos matrices para concat, y en realidad necesita agregar una de ellas en lugar de crear una nueva, el camino a seguir es push o loop.

Punto de referencia: https://jsperf.com/concat-small-arrays-vs-push-vs-loop/

prueba esto:

i=new Array("aaaa", "bbbb");
j=new Array("cccc", "dddd");

i=i.concat(j);

si las matrices N se obtienen de la base de datos y no están codificadas, lo haré así usando ES6

let get_fruits = [...get_fruits , ...DBContent.fruit];