Quelle est la manière la plus efficace de concaténer des tableaux N?

Quelle est la manière la plus efficace de concaténer des tableaux N d'objets en JavaScript?

Les tableaux sont modifiables et le résultat peut être stocké dans l'un des tableaux d'entrée.

Si vous concaténez plus de deux baies, concat()c'est la voie à suivre pour plus de commodité et des performances probables.

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

Pour concaténer seulement deux tableaux, le fait d' pushaccepter plusieurs arguments constitués d'éléments à ajouter au tableau peut être utilisé à la place pour ajouter des éléments d'un tableau à la fin d'un autre sans produire un nouveau tableau. Avec slice()elle peut aussi être utilisé à la place , concat()mais il semble y avoir aucun avantage de performance de le faire .

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

Dans ECMAScript 2015 et versions ultérieures, cela peut être encore réduit

a.push(...b)

Cependant, il semble que pour les grands tableaux (de l'ordre de 100 000 membres ou plus), la technique passant un tableau d'éléments à push(soit en utilisant apply()l'opérateur de propagation ECMAScript 2015) peut échouer. Pour de tels tableaux, l'utilisation d'une boucle est une meilleure approche. Voir https://stackoverflow.com/a/17368101/96100 pour plus de détails.

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

edit : preuve d'efficacité: http://jsperf.com/multi-array-concat/7

edit2 : Tim Supinie mentionne dans les commentaires que cela peut entraîner un dépassement de la taille de la pile d'appels par l'interpréteur. Cela dépend peut-être du moteur js, mais j'ai également obtenu "Taille maximale de la pile d'appels dépassée" sur Chrome au moins. Cas de test: [].concat.apply([], Array(300000).fill().map(_=>[1,2,3])). (J'ai également eu la même erreur en utilisant la réponse actuellement acceptée, donc on anticipe de tels cas d'utilisation ou on construit une bibliothèque pour d'autres, des tests spéciaux peuvent être nécessaires quelle que soit la solution que vous choisissez.)

Pour les personnes utilisant ES2015 (ES6)

Vous pouvez maintenant utiliser la syntaxe Spread pour concaténer des tableaux:

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]

La concat()méthode est utilisée pour joindre deux ou plusieurs tableaux. Il ne modifie pas les tableaux existants, il ne renvoie qu'une copie des tableaux joints.

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

Utilisez Array.prototype.concat.apply pour gérer la concaténation de plusieurs tableaux:

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

Exemple:

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]

Si vous êtes en train de passer le résultat par carte / filtre / tri, etc. et que vous souhaitez concaténer un tableau de tableaux, vous pouvez utiliser 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']

Pour un tableau de plusieurs baies et ES6, utilisez

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

Par exemple:

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 ]

Maintenant, nous pouvons combiner plusieurs tableaux en utilisant ES6 Spread. Au lieu d'utiliser concat()pour concaténer des tableaux, essayez d'utiliser la syntaxe d'étalement pour combiner plusieurs tableaux en un seul tableau aplati. par exemple:

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]

résolu comme ça.

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

Vous pouvez utiliser le site jsperf.com pour comparer les performances. Voici le lien pour concat .

Ajout d'une comparaison entre:

var c = a.concat(b);

et:

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

Le second est presque 10 fois plus lent en chrome.

Facilement avec la fonction concat:

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

Voici une fonction par laquelle vous pouvez concaténer plusieurs nombres de tableaux

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

    return newArr;
}

Exemple -

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

affichera

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

Fusionner un tableau avec Push:

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

Utilisation de l' opérateur Concat et 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);

Si vous disposez d'un tableau de tableaux et que vous souhaitez concaténer les éléments en un seul tableau, essayez le code suivant (nécessite 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 si vous aimez la programmation fonctionnelle

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 encore mieux avec la syntaxe ES5, sans l'opérateur de propagation

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

Cette façon est pratique si vous ne connaissez pas le non. des tableaux au moment du code.

Raccourcissez avec ES6.

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

Cela concatène et unique les tableaux multiples;

Démo sur codepen

où 'n' est un certain nombre de tableaux, peut-être un tableau de tableaux. . .

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

S'il n'y a que deux tableaux à concaténer et que vous devez réellement ajouter l' un des tableaux plutôt que d'en créer un nouveau, pousser ou boucler est la solution.

Référence: https://jsperf.com/concat-small-arrays-vs-push-vs-loop/

essaye ça:

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

i=i.concat(j);

si les tableaux N proviennent de la base de données et ne sont pas codés en dur, je le ferai comme ceci en utilisant ES6

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