Array in Stücke aufteilen

Question

Nehmen wir an, dass ich ein Javascript-Array habe, das wie folgt aussieht:

["Element 1","Element 2","Element 3",...]; // with close to a hundred elements.

Welcher Ansatz wäre angemessen, um das Array in viele kleinere Arrays mit, sagen wir, höchstens 10 Elementen aufzuteilen?

Answer 1

ES6-Einlinienansatz auf der Grundlage von Array.prototype reduce y push Methoden:

const doChunk = (list, size) => list.reduce((r, v) =>
  (!r.length || r[r.length - 1].length === size ?
    r.push([v]) : r[r.length - 1].push(v)) && r
, []);

console.log(doChunk([0,1,2,3,4,5,6,7,8,9,10,11,12], 5));
// [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12]]

Answer 2

Hier ist eine nicht-mutierende Lösung, die nur Rekursion und slice() verwendet.

const splitToChunks = (arr, chunkSize, acc = []) => (
    arr.length > chunkSize ?
        splitToChunks(
            arr.slice(chunkSize),
            chunkSize,
            [...acc, arr.slice(0, chunkSize)]
        ) :
        [...acc, arr]
);

Dann verwenden Sie es einfach wie splitToChunks([1, 2, 3, 4, 5], 3) zu erhalten [[1, 2, 3], [4, 5]] .

Hier ist eine Geige, die Sie ausprobieren können: https://jsfiddle.net/6wtrbx6k/2/

Answer 3

Ich habe eine rekursive Funktion ausprobiert

const chunk = (arr, n) =>
    arr.length ? [arr.slice(0, n), ...chunk(arr.slice(n), n)] : [];

was zwar schön und kurz ist, aber anscheinend etwa 256× so lange dauert wie @AymKdn's Antwort für 1.000 Elemente und 1.058× so lang für 10.000 Elemente!

Answer 4

EDIT: @mblase75 fügte der früheren Antwort einen prägnanteren Code hinzu, während ich meinen schrieb, daher empfehle ich, seine Lösung zu verwenden.

Sie könnten einen Code wie diesen verwenden:

var longArray = ["Element 1","Element 2","Element 3", /*...*/];
var smallerArrays = []; // will contain the sub-arrays of 10 elements each
var arraySize = 10;
for (var i=0;i<Math.ceil(longArray.length/arraySize);i++) {
    smallerArrays.push(longArray.slice(i*arraySize,i*arraySize+arraySize));
}

Ändern Sie den Wert von arraySize um die maximale Länge der kleineren Arrays zu ändern.

Answer 5

Der effizienteste Weg ist, das Array als Iterable und eine faule Paginierung durchführen. Auf diese Weise werden die Daten nur auf Anforderung ausgegeben. Der folgende Code verwendet den Operator Seite de iter-ops Bibliothek:

import {pipe, page} from 'iter-ops';

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]; // some input data

const i = pipe(arr, page(2)); //=> Iterable<number>

console.log(...i); //=> [ 1, 2 ] [ 3, 4 ] [ 5, 6 ] [ 7, 8 ] [ 9 ]

Funktioniert auf die gleiche Weise für alle Iterable o AsyncIterable .

---

P.S. Ich bin der Autor der Bibliothek.