Es6 spread gebruiken om meerdere arrays samen te voegen

We weten allemaal dat je het volgende kunt doen:

let arr1 = [1,2,3];
let arr2 = [3,4,5];
let arr3 = [...arr1, ...arr2]; // [1,2,3,3,4,5]

Maar hoe maak je dit dynamisch om N arrays samen te voegen?


Antwoord 1, autoriteit 100%

Eén optie is om reducete gebruiken:

let arrs = [[1, 2], [3, 4], [5, 6]];
arrs.reduce((a, b) => [...a, ...b], []);

Dit is natuurlijk een langzame oplossing (kwadratische tijd). Als alternatief, als u Lodash kunt gebruiken, doet _.flattenprecies wat u wilt, en efficiënter (lineaire tijd).

BEWERKEN

Of, aangepast van de opmerking van Xotic750 hieronder,

[].concat(...arrs);

Wat efficiënt moet zijn (lineaire tijd).


Antwoord 2, autoriteit 26%

Een andere optie zou kunnen zijn:

const nArrays = [
  [1, 2, 3, 4, 5],
  [6, 7, 8, 9],
  [10, 11]
];
const flattened = [].concat(...nArrays);
console.log(flattened)

Snippet uitvouwen


Antwoord 3, autoriteit 21%

let fruits = ["apples", "bananas", "pears"];
let vegetables = ["corn", "potatoes", "carrots"];
let produce = [...fruits, ...vegetables];
console.log(produce);

Snippet uitvouwen


Antwoord 4, autoriteit 4%

De volgende oplossing werkt voor mij (spread-operator in ES6):

let array = ['my','solution','works'];
let newArray = [];
let newArray2 = [];
newArray.push(...array); //adding to same array
newArray2.push([...array]); //adding as child/leaf/sub-array
console.log(newArray);
console.log(newArray2);

Snippet uitvouwen


Antwoord 5, autoriteit 3%

Je kunt dat niet doen met alleen de gespreide syntaxis, omdat de gespreide syntaxis vereist dat u van tevoren weet hoeveel arrays u aaneenvoegt. U kunt echter de volgende functie schrijven:

function concatN(...arguments) {
    let accumulator = [];
    for(let arg = 0; arg < arguments.length; arg = arg + 1) {
        accumulator = [...accumulator, ...arguments[arg]];
    }
    return accumulator;
}

Het zal echter waarschijnlijk niet erg efficiënt zijn (herhaaldelijk gebruik van de spread-syntaxis is O(n²)). Het gebruik van Array.prototype.concatzou beter zijn. Je kunt gewoon doen:

[].concat(all, of, your, arrays);

Antwoord 6, autoriteit 3%

U kunt het spread-element in de for..of-lus gebruiken om arraywaarden samen te voegen tot een enkele array

let arr1 = [1,2,3];
let arr2 = [3,4,5];
let arr3 = [];
for (let arr of [arr1, arr2 /* , arrN */]) arr3.push(...arr);
console.log(arr3);

Snippet uitvouwen


Antwoord 7

U kunt een recursieve functie en Array.prototype.concat

gebruiken

const concatN = (x,...xs) =>
  x === undefined ? [] : x.concat(concatN(...xs))
console.log(concatN([1,2,3], [4,5,6], [7,8,9]))
// [1,2,3,4,5,6,7,8,9]

Snippet uitvouwen


Antwoord 8

We kunnen het oplossen met es6 op de volgende manier

function mergeTwo(arr1, arr2) {
  let result = [...arr1, ...arr2];
  return result.sort((a,b) => a-b);
}

Antwoord 9

De beste optie is om FlatMap te gebruiken, waarmee we meerdere arrays in één array kunnen samenvoegen.

Voorbeeld:

let arrs = [[1, 2], [3, 4], [5, 6]];
arrs.flatMap(a => a);

het resultaat zal zijn

> (6) [1, 2, 3, 4, 5, 6]

Veel plezier met coderen…


Antwoord 10

let arr1 = [1,2,3];
let arr2 = [3,4,5];
let arrs = [arr1, arr2].flat(); // [1,2,3,3,4,5]
console.log(arrs);

Other episodes