Aufteilen eines Arrays in Gruppen

Question

Es wird erwartet, dass ich eine Funktion schreibe, die ein Array (erstes Argument) in Gruppen der Länge der Größe (zweites Argument) aufteilt und sie als zweidimensionales Array zurückgibt. Daher sollte chunkArrayInGroups (["a", "b", "c", "d"], 2) [["a", "b"], ["c", "d"]]

zurückgeben

function chunkArrayInGroups(arr, size) { 
    // Break it up. 
    var result=[]; 
    for (var i=0;i<=Math.ceil(arr.length/size);i++){ 

     var j=0; 
     if(i!== 0){ 
     j+=size; 
     size+=size; 
     } 

     result[i] = arr.slice(j , size); 

    } 
    //return arr.length/size 
    //results in 1.5 

return result; 
// results [["a", "b"], ["c", "d"]] 


} 

chunkArrayInGroups(["a", "b", "c", "d"], 2); 

mir das gewünschte Ergebnis zu erzielen, aber ich bin nicht sehr zufrieden mit meiner Lösung, auch, was noch wichtiger ist „if“ arr.length = 4; und, Größe = 2; warum ist arr.length/size = 1? sollte es nicht 4/2 = 2 sein?

Answer 1

Sie ändern Größe innerhalb der Schleife. Dies verdoppelt die Größe bei jedem Schritt. Die Tatsache, dass Ihr Beispiel nur zwei Sub-Arrays enthält, verbirgt dieses Problem. Versuchen Sie größere Arrays, um das Problem im Ergebnis zu sehen.

Um dies zu beheben, deklarieren Sie j außerhalb der Schleife. Fügen Sie nach dem Schneiden die Größe zu j hinzu.

bearbeiten: Code beantragte als

function chunkArrayInGroups(arr, size) { 
    var result = []; 
    var j = 0; 
    for (var i = 0; i < Math.ceil(arr.length/size); i++) { 
    result[i] = arr.slice(j, j + size); 
    j = j + size; 
    } 
    return result; 
} 

Oder etwas vereinfacht:

function chunkArrayInGroups(arr, size) { 
    var result = []; 
    var pos = 0; 
    while (pos < size) { 
    result.push(arr.slice(pos, pos + size)); 
    pos += size; 
    } 
    return result; 
} 

Answer 2

Sie reduce() mit slice()

können

function chunkArrayInGroups(ar, num) { 
 
    return ar.reduce(function(r, v, i) { 
 
    if (i % num == 0) r.push(ar.slice(i, i + num)); 
 
    return r; 
 
    }, []); 
 
} 
 

 
console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2))

Answer 3

was noch wichtiger ist, warum arr.length = 4

Original-Array arr nicht aufgrund der Verwendung innerhalb chunkArrayInGroups betroffen von .slice() bei

result[i] = arr.slice(j , size) 

Answer 4

hier ist, was ich kam mit :

function divyArray(input,size){ 
    var output = []; 
    for(var i = 0;i<input.length;i){ 
     var chunk = []; 
     for(var j = 0;j<size;j++){ 
      chunk.push(input[i]); 
      i++; 
     } 
     output.push(chunk); 
    } 
    return output; 
} 

Answer 5

Yo Du könntest eine Methode ohne Slice benutzen.

function chunkArrayInGroups(array, size) { 
 
    return array.reduce(function (r, a, i) { 
 
     var p = Math.floor(i/size); 
 
     r[p] = r[p] || []; 
 
     r[p].push(a); 
 
     return r; 
 
    }, []); 
 
} 
 
\t \t 
 
console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2));

Answer 6

Die folgende Lösung funktioniert ganz gut:

function chunkv2(arr,size) { 
    var result = []; 
    for(var i = 0; i < arr.length; i++) { 
     if(i%size === 0) 
      // Push a new array containing the current value to the result array 
      result.push([arr[i]]); 
     else 
      // Push the current value to the current array 
      result[result.length-1].push(arr[i]); 
    } 
    return result; 

} 

Es funktioniert durch den Modul-Operator, um zu sehen, ob es ein neues Array erstellen soll.

Answer 7

Ich würde machen i Iterieren Sie die Indizes im ursprünglichen Array, wo jede Gruppe beginnt, anstelle der Indizes der Gruppen.

function chunkArrayInGroups(arr, size) { 
    var result = []; 
    for (var i=0; i<arr.length; i+=size) 
    result.push(arr.slice(i, i+size)); 
    return result; 
} 

Und bedenken Sie auch einen Generator:

function* chunkArrayInGroups(arr, size) { 
    for (var i=0; i<arr.length; i+=size) 
    yield arr.slice(i, i+size); 
} 

Answer 8

Eine Art und Weise zu vereinfachen, wie folgt aussehen könnte:

function chunkArrayInGroups(arr, size) { 
    var result=[], j=0, divisions = arr.length/size; 

    if (divisions % size != 0) { 
     console.log("Array of length"+ arr.length +"is undividable by "+divisions); 
    } 
    for (var i=0;i<=divisions-1;i++){ 
     result[i] = arr.slice(j , size); console.log(result[i]); 
     j+=size; 
     size+=size; 
    } 
    return result; 
} 

Sie könnten einige Fehler Logik für unteilbar Arrays hinzugefügt werden sollen oder alternative Methoden, wenn Sie sie anders teilen möchten, aber dies ist nahe, wie es vorher mit ein paar Änderungen war. Ich bin nicht sicher, wie Sie 1,5 für arr.length/size bekommen - ich bekomme die richtige Anzahl dafür.

Answer 9

Ich denke, es wird nicht besser, als eine Totalreduktionslösung es tun kann;

var arr = ["a", "b", "c", "d"], 
 
     g = 2, 
 
    res = arr.reduce((p,c,i) => !(i%g) ? p.concat([[c]]) : (p[p.length-1].push(c),p),[]); 
 
console.log(res);