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

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 Eingabearrays gespeichert werden.

Wenn Sie mehr als zwei Arrays verketten, concat()ist dies der richtige Weg, um Komfort und wahrscheinliche Leistung zu erzielen.

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

Um nur zwei Arrays zu verketten, kann die Tatsache, dass pushmehrere Argumente akzeptiert werden, die aus Elementen bestehen, die dem Array hinzugefügt werden sollen, stattdessen verwendet werden, um Elemente von einem Array zum Ende eines anderen hinzuzufügen, ohne ein neues Array zu erzeugen. Mit slice()kann es auch anstelle von verwendet werden, concat()aber es scheint keinen Leistungsvorteil zu geben, wenn dies getan wird .

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

In ECMAScript 2015 und höher kann dies noch weiter reduziert werden

a.push(...b)

Es scheint jedoch, dass bei großen Arrays (in der Größenordnung von 100.000 Mitgliedern oder mehr) die Technik, an die ein Array von Elementen übergeben wird push(entweder unter Verwendung apply()oder des ECMAScript 2015-Spread-Operators), fehlschlagen kann. Für solche Arrays ist die Verwendung einer Schleife ein besserer Ansatz. Weitere Informationen finden Sie unter https://stackoverflow.com/a/17368101/96100 .

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

Bearbeiten : Effizienznachweis: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie erwähnt in den Kommentaren, dass dies dazu führen kann, dass der Interpreter die Größe des Aufrufstapels überschreitet. Dies hängt möglicherweise von der js-Engine ab, aber ich habe auch zumindest in Chrome die Option "Maximale Call-Stack-Größe überschritten" erhalten. Testfall : [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])). (Ich habe auch den gleichen Fehler bei der Verwendung der aktuell akzeptierten Antwort erhalten, sodass man solche Anwendungsfälle vorwegnimmt oder eine Bibliothek für andere erstellt. Je nachdem, welche Lösung Sie wählen, sind möglicherweise spezielle Tests erforderlich.)

Für Benutzer von ES2015 (ES6)

Sie können jetzt die Spread-Syntax verwenden, um Arrays zu verketten:

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]

Die concat()Methode wird verwendet, um zwei oder mehr Arrays zu verbinden. Die vorhandenen Arrays werden nicht geändert, sondern nur eine Kopie der verknüpften Arrays zurückgegeben.

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

Verwenden Sie Array.prototype.concat.apply, um die Verkettung mehrerer Arrays zu verarbeiten:

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

Beispiel:

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]

Wenn Sie gerade dabei sind, das Ergebnis durch Map / Filter / Sort usw. zu leiten, und Sie ein Array von Arrays zusammenfassen möchten, können Sie es verwenden 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']

Verwenden Sie für ein Array mit mehreren Arrays und ES6

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

Beispielsweise:

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 ]

Jetzt können wir mehrere Arrays mit kombinieren ES6 Spread. concat()Versuchen Sie, mithilfe der Spread-Syntax mehrere Arrays zu einem reduzierten Array zu kombinieren, anstatt Arrays zu verketten. z.B:

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]

so gelöst.

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

Sie können die Website jsperf.com verwenden , um die Leistung zu vergleichen. Hier ist der Link zu concat .

Vergleich hinzugefügt zwischen:

var c = a.concat(b);

und:

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

Der zweite ist in Chrom fast zehnmal langsamer.

Einfach mit der Concat-Funktion:

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

Hier ist eine Funktion, mit der Sie mehrere Arrays verketten können

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

    return newArr;
}

Beispiel -

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

wird ausgegeben

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

Wenn Sie ein Array von Arrays haben und die Elemente zu einem einzigen Array zusammenfassen möchten, versuchen Sie den folgenden Code (erfordert 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];

Oder wenn Sie sich für funktionale Programmierung interessieren

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

Oder noch besser mit ES5-Syntax ohne den Spread-Operator

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

Dieser Weg ist praktisch, wenn Sie die Nr. Nicht kennen. von Arrays zur Codezeit.

Mit ES6 kürzen.

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

Dadurch werden die mehreren Arrays konkattiert und eindeutig .

Demo auf Codepen

Array mit Push zusammenführen:

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

Verwenden des Concat and Spread-Operators:

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

Dabei ist 'n' eine Anzahl von Arrays, möglicherweise ein Array von Arrays. . .

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

Wenn nur zwei Arrays zu verknüpfen sind und Sie tatsächlich anhängen müssen eines der Arrays anstatt ein neues zu erstellen, ist Push oder Loop der Weg.

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

Versuche dies:

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

i=i.concat(j);

Wenn die N Arrays aus der Datenbank stammen und nicht fest codiert sind, mache ich das mit ES6 so

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