Question

我应该编写一个函数，将一个数组（第一个参数）拆分为大小的长度（第二个参数），并将它们作为二维数组返回。因此，chunkArrayInGroups（[＆＃34; a＆＃34;，＆＃34; b＆＃34;，＆＃34; c＆＃34;，＆＃34; d＆＃34;]，2）应返回[[＆## 34; a＆＃34;，＆＃34; b＆＃34;]，[＆＃34; c＆＃34;，＆＃34; d＆＃34;]]

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);

我得到了理想的结果，但我对我的解决方案不太满意，而且，更重要的是＆＃34;如果＆＃34; arr.length = 4;并且，size = 2;那么为什么arr.length / size = 1？不应该是4/2 = 2？

Answer 1

我会让i迭代每个组开始的原始数组中的索引，而不是组的索引。

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

还考虑一个发电机：

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

Answer 2

您可以修改循环内部的大小。这基本上使每一步的尺寸加倍。您的示例只有两个子数组的事实隐藏了这个问题。尝试使用更大的数组来查看结果中的问题。

要解决此问题，请在循环外部声明j。切片后将大小添加到j。

修改：代码，按要求

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;
}

或者，略微简化：

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

Answer 3

以下解决方案效果很好：

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;

}

它通过使用模运算符来查看是否应该创建一个新数组。

Answer 4

您可以将reduce()与slice()

一起使用

＆＃13;

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))

＆＃13;

Answer 5

更重要的是为什么arr.length = 4

原始数组arr因chunkArrayInGroups使用<{1}}而在.slice()内不受影响

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

Answer 6

这是我想出的：

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 7

您可以使用不带切片的方法。

＆＃13;

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;
    }, []);
}
		
console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2));

＆＃13;

Answer 8

简化它的方法可能如下所示：

    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;
}

如果您想要对它们进行不同的划分，您可能希望为不可分割的数组或替代方法添加一些错误逻辑，但这与之前的一些更改接近。我不确定你是如何得到1.5的arr.length / size-我得到了正确的数字。

Answer 9

我认为它没有比完全减少解决方案更好的事情可以做到;

＆＃13;

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);

＆＃13;

将数组拆分成组

9 个答案: