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

Dies sollte eine einfache Antwort ohne viele mathematische Komplikationen sein.

function chunkArray(array, sizeOfTheChunkedArray) {
  const chunked = [];

  for (let element of array) {
    const last = chunked[chunked.length - 1];

    if(!last || last.length === sizeOfTheChunkedArray) {
      chunked.push([element])
    } else {
      last.push(element);
    }
  }
  return chunked;
}

Answer 2

Hier ist mein Ansatz unter Verwendung des Coffeescript-Listenverständnisses. Ein großartiger Artikel, der die Verständigung in Coffeescript beschreibt, ist hier gefunden .

chunk: (arr, size) ->
    chunks = (arr.slice(index, index+size) for item, index in arr by size)
    return chunks

Answer 3

Hier ist eine saubere und optimierte Implementierung von chunk() Funktion. Unter der Annahme, dass die Standard-Chunk-Größe 10 .

var chunk = function(list, chunkSize) {
  if (!list.length) {
    return [];
  }
  if (typeof chunkSize === undefined) {
    chunkSize = 10;
  }

  var i, j, t, chunks = [];
  for (i = 0, j = list.length; i < j; i += chunkSize) {
    t = list.slice(i, i + chunkSize);
    chunks.push(t);
  }

  return chunks;
};

//calling function
var list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
var chunks = chunk(list);

Answer 4

Für dieses Problem kann es viele Lösungen geben.

einer meiner Favoriten ist:

function chunk(array, size) {
    const chunked = [];

    for (element of array){
        let last = chunked[chunked.length - 1];

        if(last && last.length != size){
            last.push(element)
        }else{
            chunked.push([element])
        }
    }

    return chunked;
}

function chunk1(array, size) {
    const chunked = [];

    let index = 0;

    while(index < array.length){
        chunked.push(array.slice(index,index+ size))
        index += size;
    }
    return chunked;
}

console.log('chunk without slice:',chunk([1,2,3,4,5,5],2));
console.log('chunk with use of slice funtion',chunk1([1,2,3,4,5,6],2))

Answer 5

Das Problem mit den derzeitigen Top-Antworten ist, dass sie zu einseitigen Stücken führen. Zum Beispiel verteilt die derzeit akzeptierte Antwort ein Array mit 101 Elementen in 10 Chunks der Größe 10, gefolgt von einem Chunk der Größe 1.

Mit Hilfe einer modularen Arithmetik können einheitliche Stückgrößen erzeugt werden, die sich nie um mehr als 1 unterscheiden:

function split_array(a, nparts) {
  const quot = Math.floor(a.length / nparts)
  const rem = a.length % nparts
  var parts = []
  for (var i = 0; i < nparts; ++i) {
    const begin = i * quot + Math.min(rem, i)
    const end = begin + quot + (i < rem)
    parts.push(a.slice(begin, end))
  }
  return parts
}

var chunks = split_array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)
console.log(JSON.stringify(chunks))

Ausgabe:

[[1,2,3,4],[5,6,7],[8,9,10]]

(Kopiert aus einer zugehörige Antwort .)