Jaki jest najskuteczniejszy sposób konkatenacji tablic N?

Jaki jest najskuteczniejszy sposób łączenia N tablic obiektów w JavaScript?

Tablice są zmienne, a wynik można zapisać w jednej z tablic wejściowych.

Jeśli łączysz więcej niż dwie tablice, concat()jest to droga do wygody i prawdopodobnej wydajności.

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

W celu połączenia tylko dwóch tablic pushmożna użyć zamiast tego wielu argumentów składających się z elementów do dodania do tablicy, aby dodać elementy z jednej tablicy do końca drugiej bez tworzenia nowej tablicy. Dzięki slice()niemu można go również użyć zamiast, concat()ale wydaje się, że nie ma żadnej przewagi wydajności .

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

W ECMAScript 2015 i nowszych wersjach można to jeszcze bardziej zmniejszyć

a.push(...b)

Wydaje się jednak, że w przypadku dużych tablic (rzędu 100 000 lub więcej elementów) technika przekazywania tablicy elementów do push(przy użyciu apply()lub operatora rozprzestrzeniania ECMAScript 2015) może się nie powieść. W przypadku takich tablic lepszym rozwiązaniem jest użycie pętli. Szczegółowe informacje można znaleźć na stronie https://stackoverflow.com/a/17368101/96100 .

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

edycja : dowód wydajności: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie wspomina w komentarzach, że może to spowodować, że interpreter przekroczy rozmiar stosu wywołań. Być może zależy to od silnika js, ale dostałem również „Przekroczono maksymalny rozmiar stosu wywołań” przynajmniej w Chrome. Przypadek testowy: [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])). (Otrzymałem również ten sam błąd przy użyciu obecnie akceptowanej odpowiedzi, więc ktoś przewiduje takie przypadki użycia lub buduje bibliotekę dla innych, specjalne testy mogą być konieczne bez względu na wybrane rozwiązanie).

Dla osób używających ES2015 (ES6)

Możesz teraz używać składni spreadu do łączenia tablic:

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]

Ta concat()metoda służy do łączenia dwóch lub więcej tablic. Nie zmienia istniejących tablic, zwraca tylko kopię połączonych tablic.

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

Użyj Array.prototype.concat.apply do obsługi konkatenacji wielu tablic:

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

Przykład:

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]

Jeśli jesteś w trakcie przepuszczania wyniku przez mapę / filtr / sortowanie itp. I chcesz skonkatować tablicę tablic, możesz użyć 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']

W przypadku tablicy wielu tablic i ES6 użyj

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

Na przykład:

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 ]

Teraz możemy łączyć wiele tablic za pomocą ES6 Spread. Zamiast używać concat()do konkatenacji tablic, spróbuj użyć składni rozproszonej, aby połączyć wiele tablic w jedną spłaszczoną tablicę. na przykład:

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]

rozwiązane w ten sposób.

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

Możesz użyć strony jsperf.com do porównania wydajności. Oto link do konkat .

Dodano porównanie między:

var c = a.concat(b);

i:

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

Drugi jest prawie 10 razy wolniejszy w chromie.

Z łatwością dzięki funkcji concat:

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

Oto funkcja, dzięki której można połączyć wiele tablic

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

    return newArr;
}

Przykład -

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

wyjdzie

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

Jeśli masz tablicę tablic i chcesz połączyć elementy w jedną tablicę, wypróbuj następujący kod (wymaga 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];

Lub jeśli lubisz programowanie funkcjonalne

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

Lub jeszcze lepiej ze składnią ES5, bez operatora spreadu

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

Ten sposób jest przydatny, jeśli nie znasz nie. tablic w czasie kodowania.

Skróć za pomocą ES6.

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

Powoduje to konkatację i unikalność wielu tablic;

Demo na codepen

Scal tablicę za pomocą push:

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

Korzystanie z operatora Concat and 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);

gdzie „n” to pewna liczba tablic, może tablica tablic. . .

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

Jeśli istnieją tylko dwie tablice do konkatacji, a tak naprawdę musisz dołączyć jedną z tablic, zamiast tworzyć nową, push lub loop.

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

Spróbuj tego:

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

i=i.concat(j);

jeśli tablice N są pobierane z bazy danych i nie są zakodowane na stałe, zrobię to w ten sposób za pomocą ES6

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