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

Mein Trick ist die Verwendung von parseInt(i/chunkSize) y parseInt(i%chunkSize) und füllt dann das Array

// filling items
let array = [];
for(let i = 0; i< 543; i++)
  array.push(i);

 // printing the splitted array
 console.log(getSplittedArray(array, 50));

 // get the splitted array
 function getSplittedArray(array, chunkSize){
  let chunkedArray = [];
  for(let i = 0; i<array.length; i++){
    try{
      chunkedArray[parseInt(i/chunkSize)][parseInt(i%chunkSize)] = array[i];
    }catch(e){
      chunkedArray[parseInt(i/chunkSize)] = [];
      chunkedArray[parseInt(i/chunkSize)][parseInt(i%chunkSize)] = array[i];
    }
  }
  return chunkedArray;
 }

Answer 2

In JS,

const splitInChunks = (arr,n) => {
  let chunksArr = [];
  if(arr !=null && arr!= undefined){
      for(i=0; i<arr.length;i+=n){
      if(arr.length-i>=n)
          chunksArr.push(arr.slice(i,i+n))
      else
           chunksArr.push(arr.slice(i,arr.length))
  }
  return chunksArr
  }
}

Answer 3

Mein Favorit ist der Generator generateChunks mit der zusätzlichen Funktion getChunks um den Generator auszuführen.

function* generateChunks(array, size) {
    let start = 0;
    while (start < array.length) {
        yield array.slice(start, start + size);
        start += size;
    }
}

function getChunks(array, size) {
    return [...generateChunks(array, size)];
}

console.log(getChunks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3)) // [ [ 0, 1, 2 ], [ 3, 4, 5 ], [ 6, 7, 8 ], [ 9 ] ]

Als Zusatz wird hier der Generator generatePartitions mit der weiteren Funktion getPartitions um n gleich große Arrays zu erhalten.

function generatePartitions(array, count) {
    return generateChunks(array, Math.ceil(array.length / count));
}

function getPartitions(array, count) {
    return [...generatePartitions(array, count)];
}

console.log(getPartitions([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3)) // [ [ 0, 1, 2, 3 ], [ 4, 5, 6, 7 ], [ 8, 9 ] ]

Ein Vorteil des Generators im Vergleich zu vielen anderen Lösungen ist, dass nicht mehrere unnötige Arrays erstellt werden.

Answer 4

Hier ist ein spezifischerer Fall, der für jemanden interessant sein könnte. Ich habe noch nicht gesehen, dass er hier erwähnt wurde.

Was ist, wenn Sie keine konstanten/geraden Stückgrößen wollen und stattdessen die Indizes angeben wollen, an denen das Array aufgeteilt wird? In diesem Fall können Sie dies verwenden:

const splitArray = (array = [], splits = []) => {
  array = [...array]; // make shallow copy to avoid mutating original
  const chunks = []; // collect chunks
  for (const split of splits.reverse()) chunks.push(array.splice(split)); // go backwards through split indices and lop off end of array
  chunks.push(array); // add last remaining chunk (at beginning of array)
  return chunks.reverse(); // restore chunk order
};

Dann:

splitArray([1, 2, 3, 4, 5, 6, 7, 8, 9], [4, 6]) 
// [ [1, 2, 3, 4] , [5, 6] , [7, 8, 9] ]

Beachten Sie, dass dies komische Dinge tun wird, wenn Sie ihm nicht aufsteigende/duplizierende/negative/nicht-ganzzahlige/etc Split-Indizes geben. Sie könnten Prüfungen für diese Randfälle hinzufügen (z.B. Array.from(new Set(array)) zu de-duplizieren.

Answer 5

TypeScript-Version. Demonstriert werden 101 zufällige uid's aufgeteilt in Gruppen von 10

const idArrayLengthLimit = 10;
const randomOneHundredOneIdArray = Array
    .from(Array(101).keys())
    .map(() => generateUid(5));

function generateUid(length: number) {
  const uidString: string[] = [];
  const uidChars = 'abcdefghijklmnopqrstuvwxyz0123456789';
  for (let i = 0; i < length; i++) {
    uidString
      .push(uidChars.charAt(Math.floor(Math.random() * uidChars.length)));
  }
  return uidString.join('');
}

for (let i = 0; i < randomOneHundredOneIdArray.length; i++) {
 if(i % idArrayLengthLimit === 0){
     const result = randomOneHundredOneIdArray
       .filter((_,id) => id >= i && id < i + idArrayLengthLimit);
    // Observe result
    console.log(result);
 }
}