Qual é a maneira mais eficiente de concatenar matrizes N?

Qual é a maneira mais eficiente de concatenar N matrizes de objetos em JavaScript?

As matrizes são mutáveis ​​e o resultado pode ser armazenado em uma das matrizes de entrada.

Se você concatenar mais de duas matrizes, concat()é o caminho a seguir para conveniência e desempenho provável.

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 apenas duas matrizes, o fato de pushaceitar vários argumentos que consistem em elementos a serem adicionados à matriz pode ser usado para adicionar elementos de uma matriz ao final de outra sem produzir uma nova matriz. Com slice()ele também pode ser usado em vez de, concat()mas parece não haver vantagem de desempenho ao fazer isso .

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

No ECMAScript 2015 e posterior, isso pode ser reduzido ainda mais para

a.push(...b)

No entanto, parece que, para matrizes grandes (da ordem de 100.000 membros ou mais), a técnica que envia uma matriz de elementos para push(usando apply()ou o operador de propagação ECMAScript 2015) pode falhar. Para essas matrizes, usar um loop é uma abordagem melhor. Consulte https://stackoverflow.com/a/17368101/96100 para obter detalhes.

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

edit : prova de eficiência: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie menciona nos comentários que isso pode fazer com que o intérprete exceda o tamanho da pilha de chamadas. Talvez isso dependa do mecanismo js, ​​mas também recebi "Tamanho máximo da pilha de chamadas excedido" no Chrome. Caso de teste: [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])). (Também obtive o mesmo erro ao usar a resposta atualmente aceita; portanto, se você está antecipando esses casos de uso ou construindo uma biblioteca para outros, testes especiais podem ser necessários, independentemente da solução escolhida.)

Para pessoas que usam o ES2015 (ES6)

Agora você pode usar a sintaxe de propagação para concatenar matrizes:

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]

O concat()método é usado para unir duas ou mais matrizes. Ele não altera as matrizes existentes, retorna apenas uma cópia das matrizes unidas.

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

Use Array.prototype.concat.apply para manipular a concatenação de várias matrizes:

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

Exemplo:

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]

Se você estiver no meio da canalização do resultado através de map / filter / sort, etc, e quiser concaturar a matriz de matrizes, poderá 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 matriz de várias matrizes e ES6, use

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

Por exemplo:

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 ]

Agora podemos combinar várias matrizes usando ES6 Spread. Em vez de usar concat()para concatenar matrizes, tente usar a sintaxe de dispersão para combinar várias matrizes em uma matriz nivelada. por exemplo:

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]

resolvido assim.

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

Você pode usar o site jsperf.com para comparar o desempenho. Aqui está o link para concat .

Adicionado comparação entre:

var c = a.concat(b);

e:

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

O segundo é quase 10 vezes mais lento no cromo.

Facilmente com a função concat:

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

Aqui está uma função pela qual você pode concatenar vários números de matrizes

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

    return newArr;
}

Exemplo -

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

irá produzir

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

Se você possui uma matriz de matrizes e deseja concaturar os elementos em uma única matriz, tente o seguinte código (Requer 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];

Ou se você gosta de programação 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];

Ou ainda melhor com a sintaxe ES5, sem o operador spread

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

Dessa forma, é útil se você não souber o não. de matrizes no horário do código.

Encurte com ES6.

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

Isso concat e único os vários arrays;

Demonstração no codepen

Mesclar matriz com push:

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

Usando o operador Concat e 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);

onde 'n' é um número de matrizes, talvez uma matriz de matrizes. . .

var resposta = _.reduce (n, função (a, b) {retorna a.concat (b)})

Se houver apenas duas matrizes para concat, e você realmente precisar anexar uma das matrizes em vez de criar uma nova, o push ou loop será o caminho a percorrer.

Referência: https://jsperf.com/concat-small-arrays-vs-push-vs-loop/

tente isto:

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

i=i.concat(j);

se as matrizes N são obtidas do banco de dados e não codificadas, o farei assim usando o ES6

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