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

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

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

   

Wenn Sie mehr als zwei Arrays verketten, ist concat() der Weg, aus concat() der Bequemlichkeit und der wahrscheinlichen performance.

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

Zum Verketten von nur zwei Arrays kann die Tatsache, dass push mehrere Argumente akzeptiert, die aus Elementen bestehen, die dem Array hinzugefügt werden, stattdessen verwendet werden, um Elemente von einem Array zum Ende eines anderen zu fügen, ohne ein neues Array zu erzeugen. Mit slice() kann es auch anstelle von concat() aber es scheint keinen performancesvorteil zu geben .

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

In ECMAScript 2015 und später kann dies noch weiter reduziert werden

 a.push(...b) 

Es scheint jedoch, dass für große Arrays (in der Größenordnung von 100.000 Mitgliedern oder mehr) die Technik, die ein Array von Elementen zum push (entweder mit apply() oder dem ECMAScript 2015-Verteilungsoperator) durchlässt, fehlschlagen kann. Für solche Arrays ist die Verwendung einer Schleife ein besserer Ansatz. Einzelheiten finden Sie unter https://stackoverflow.com/a/17368101/96100 .

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

edit : Nachweis der Effizienz: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie erwähnt in den Kommentaren, dass dies dazu führen könnte, dass der Interpreter die Call-Stack-Größe überschreitet. Dies hängt vielleicht von der js-Engine ab, aber ich habe auch “Maximale Call-Stack-Größe überschritten” in Chrome erreicht. Testfall: [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])) . (Ich habe auch den gleichen Fehler mit der aktuell akzeptierten Antwort bekommen, also erwartet man solche Anwendungsfälle oder baut eine Bibliothek für andere, spezielle Tests können notwendig sein, egal welche Lösung du wählst.)

Die concat() -Methode wird verwendet, um zwei oder mehr Arrays zu verbinden. Es ändert die vorhandenen Arrays nicht, es gibt nur eine Kopie der verbundenen Arrays zurück.

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

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

 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] 

Für Menschen mit ES2015 (ES6)

Sie können nun die Spreadsyntax zum Verketten von Arrays verwenden:

 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] 

Wenn Sie gerade dabei sind, das Ergebnis über map / filter / sort usw. zu leiten und Array Arrays zu erstellen, können Sie 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 Arrays aus 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 ES6 Spread kombinieren. Verwenden Sie concat() zum Verketten von Arrays, sondern verwenden Sie die concat() , um mehrere Arrays zu einem flachen Array zusammenzufassen. 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] 

Einfach mit der concat-function:

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

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

Zusätzlicher Vergleich 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]); } 

Die zweite ist fast 10 mal langsamer in Chrom.

wo ‘n’ ist eine Anzahl von Arrays, vielleicht ein Array von Arrays. . .

var antwort = _.reduce (n, funktion (a, b) {return a.concat (b)})

Hier ist eine function, mit der Sie mehrere Array-Nummern 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 mit Arrays haben und die Elemente in ein einzelnes Array einbetten 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 in funktionale Programmierung sind

 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 das Nein nicht kennen. von Arrays zum Zeitpunkt des Codes.

Wenn nur zwei Arrays zu concaten sind und Sie tatsächlich eines der Arrays anhängen müssen, anstatt ein neues zu erstellen, ist Push oder Loop der richtige 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);