Was ist der effizienteste Weg, um N Arrays zu verketten?

Question

Was ist der effizienteste Weg, um N Arrays von Objekten in JavaScript zu verketten?

Die Arrays sind veränderbar, und das Ergebnis kann in einem der Eingabe-Arrays gespeichert werden.

Answer 1

Wenn es nur zwei Arrays gibt, die zusammengefügt werden müssen, und Sie tatsächlich anhängen. eines der Arrays, anstatt ein neues zu erstellen, ist push oder loop der richtige Weg.

Benchmark: https://jsperf.com/concat-small-arrays-vs-push-vs-loop/

Answer 2

Wobei 'n' eine bestimmte Anzahl von Feldern ist, vielleicht ein Feld von Feldern

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

Answer 3

Wenn die N-Arrays aus der Datenbank geholt werden und nicht hardcodiert sind, werde ich es wie folgt mit ES6 tun

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

Answer 4

Versuchen Sie dies:

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

i=i.concat(j);

Answer 5

Am schnellsten geht es um den Faktor 10, wenn man über die Arrays iteriert, als ob sie eins wären, ohne sie tatsächlich zu verbinden (wenn man es vermeiden kann).

Ich war überrascht, dass concat etwas schneller ist als push, es sei denn, der Test ist irgendwie unfair.

const arr1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'];
const arr2 = ['j', 'k', 'l', 'i', 'm', 'n', 'o', 'p', 'q', 'r', 's'];
const arr3 = ['t', 'u', 'v', 'w'];
const arr4 = ['x', 'y', 'z'];

let start;

// Not joining but iterating over all arrays - fastest
// at about 0.06ms
start = performance.now()

const joined = [arr1, arr2, arr3, arr4];

for (let j = 0; j < 1000; j++) {
  let i = 0;
  while (joined.length) {
    // console.log(joined[0][i]);
    if (i < joined[0].length - 1) i++;
    else {
      joined.shift()
      i = 0;
    }
  }
}

console.log(performance.now() - start);

// Concating (0.51ms).
start = performance.now()

for (let j = 0; j < 1000; j++) {
  const a = [].concat(arr1, arr2, arr3, arr4);
}

console.log(performance.now() - start);

// Pushing on to an array (mutating). Slowest (0.77ms)
start = performance.now()

const joined2 = [arr1, arr2, arr3, arr4];

for (let j = 0; j < 1000; j++) {
  const arr = [];
  for (let i = 0; i < joined2.length; i++) {
    Array.prototype.push.apply(arr, joined2[i])
  }
}

console.log(performance.now() - start);

Sie können die Iteration ohne Verbindung sauberer machen, wenn Sie sie abstrahieren, und sie ist immer noch doppelt so schnell:

const arr1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'];
const arr2 = ['j', 'k', 'l', 'i', 'm', 'n', 'o', 'p', 'q', 'r', 's'];
const arr3 = ['t', 'u', 'v', 'w'];
const arr4 = ['x', 'y', 'z'];

function iterateArrays(arrays, onEach) {
  let i = 0;
  while (joined.length) {
    onEach(joined[0][i]);
    if (i < joined[0].length - 1) i++;
    else {
      joined.shift();
      i = 0;
    }
  }
}

// About 0.23ms.
let start = performance.now()

const joined = [arr1, arr2, arr3, arr4];

for (let j = 0; j < 1000; j++) {
  iterateArrays(joined, item => {
    //console.log(item);
  });
}

console.log(performance.now() - start);