Javascript 按子数组处理数组

假设我们有一个可变长度的数组，我想用最大长度为100的块来处理它，并以最小的块数来处理。因此，对于长度为241的数组，它将是3个子数组，大小为41、100、100（或100、100、41）

curr\u len=arr.length；
偏移量=当前长度%100；
具有子阵列的dosomething（arr.slice（offset））
对于（j=offset；j不是真的，使用如下方式：

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

var splitArrays = array.reduce(function(arr, cur, i) {
    if (i % 3 === 0) arr.push([]);
    arr[i / 3 | 0].push(cur);
    return arr;
}, []);
//splitArrays looks like:
//[[1,2,3],[4,5,6],[7,8,9],[10,11]]

更通用的函数

function splitArray(array, num) {
    return array.reduce(function(arr, cur, i) {
        if (i % num === 0) arr.push([]);
        arr[i / num | 0].push(cur);
        return arr;
    }, []);
}

不完全是这样，使用看起来像这样：

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

var splitArrays = array.reduce(function(arr, cur, i) {
    if (i % 3 === 0) arr.push([]);
    arr[i / 3 | 0].push(cur);
    return arr;
}, []);
//splitArrays looks like:
//[[1,2,3],[4,5,6],[7,8,9],[10,11]]

更通用的函数

function splitArray(array, num) {
    return array.reduce(function(arr, cur, i) {
        if (i % num === 0) arr.push([]);
        arr[i / num | 0].push(cur);
        return arr;
    }, []);
}

我希望最后一个块的大小更小。然后代码是：

for (var i=0; i<arr.length; i+=100)
    doSomethingWithSubArray(arr.slice(i, 100));

我希望最后一个块的大小更小。然后代码是：

for (var i=0; i<arr.length; i+=100)
    doSomethingWithSubArray(arr.slice(i, 100));

使用块函数~

function chunk(a, s){
    for(var x, i = 0, c = -1, l = a.length, n = []; i < l; i++)
        (x = i % s) ? n[c][x] = a[i] : n[++c] = [a[i]];
    return n;
}

console.log(chunk([1,2,3,4,5,6,7,8,9,10], 3));

功能块（a，s）{
对于（变量x，i=0，c=-1，l=a.length，n=[]；i
使用块函数~

function chunk(a, s){
    for(var x, i = 0, c = -1, l = a.length, n = []; i < l; i++)
        (x = i % s) ? n[c][x] = a[i] : n[++c] = [a[i]];
    return n;
}

console.log(chunk([1,2,3,4,5,6,7,8,9,10], 3));

功能块（a，s）{
对于（变量x，i=0，c=-1，l=a.length，n=[]；i
使您的
doSomethingWithSubArray
函数接受一个起始索引并返回下一个未处理的索引，或者如果没有更多工作，则返回
null
。将此“迭代器”放入
while
循环中。在调用此“迭代器”后立即在块之间执行您想要执行的其余工作（更新UI？）在
while
条件下。
使您的
doSomethingWithSubArray
函数接受一个起始索引并返回下一个未处理的索引，或者如果没有更多工作，则返回
null
。将此“迭代器”放入
while
循环中。在调用此函数后立即在块之间执行您想要执行的其余工作（更新UI？）在
while
条件下使用“迭代器”。
这是函数式递归解决方案。
没有变量，没有循环，没有计数，因为它更清晰

var chunk = function(arr, n){
    if (arr.length == 0) return [];
    var head = arr.slice(0, n), rest = arr.slice(n);

    return [head].concat( chunk(rest, n) );
};

console.log(chunk([1,2,3,4,5,6,7,8,9,10], 3));​

这是函数式递归解决方案。
没有变量，没有循环，没有计数，因为它更清晰

var chunk = function(arr, n){
    if (arr.length == 0) return [];
    var head = arr.slice(0, n), rest = arr.slice(n);

    return [head].concat( chunk(rest, n) );
};

console.log(chunk([1,2,3,4,5,6,7,8,9,10], 3));​

当然。出于某种原因，我的大脑为了避免索引自动失效而避免了这个。我想javascript很好。我的解决方案比你的好。这个呢？当然。出于某种原因，我的大脑为了避免索引自动失效而避免了这个。我想javascript很好。我的解决方案比你的好。这个怎么样？不“var“不是真的：-）然而，大多数人理解循环比递归调用更容易-而且它们也更快。没有“var”不是真的：-）然而，大多数人理解循环比递归调用更容易-而且它们也更快。