[ 1, 5, 9, 21 ]
转换为：
[ [1, 5], [5, 9], [9, 21] ]
我知道可以使用 forEach 循环遍历数组并收集值来创建一个新数组。在不使用 forEach 的情况下，是否有一种优雅的方式在 _.lodash 中实现这个功能呢？var array = [1, 5, 9, 21],
result = array.slice(1).map((a, i, aa) => [i ? aa[i - 1] : array[0], a]);
console.log(result);.as-console-wrapper { max-height: 100% !important; top: 0; }var array = [1, 5, 9, 21],
result = array.slice(1).map((a, i) => [array[i], a]);
console.log(result);.as-console-wrapper { max-height: 100% !important; top: 0; }(a, i) => [array[i], a]呢？ - Bergi使用map的快速方法如下：
const arr = [ 1, 5, 9, 21 ];
const grouped = arr.map((el, i) => [el, arr[i+1]]).slice(0, -1);
console.log(grouped);.as-console-wrapper { max-height: 100% !important; top: 0; }pop指令。现在的代码更加优雅了。 - Diego这可以很容易地通过使用array.reduce来完成。以下操作使用数组作为聚合器，跳过第一个项目，然后对于之后的每个项目，将上一个项目和当前项目作为一对推送到数组中。
const arr = [ 1, 5, 9, 21 ];
const chunked = arr.reduce((p, c, i, a) => i === 0 ? p : (p.push([c, a[i-1]]), p), []);
console.log(chunked);扩展版本应如下：
const arr = [1, 5, 9, 21];
const chunked = arr.reduce(function(previous, current, index, array) {
if(index === 0){
return previous;
} else {
previous.push([ current, array[index - 1]]);
return previous;
}
}, []);
console.log(chunked);R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
R.aperture(7, [1, 2, 3, 4, 5]); //=> []
我注意到当前的解决方案在某种程度上都是向前或向后查找(arr[i + 1]或arr[i - 1])。
也许探索一种使用reduce和另一个数组的方法会很有用，该数组在函数闭包中定义，用于存储待完成的分区。
注：
part不必是一个数组，但使用数组可以将此方法扩展为适用于n个项的集合shift，可以使用slice的组合并重新定义part，但我认为在这里使用它是安全的。const partition = partitionSize => arr => {
const part = [];
return arr.reduce((parts, x) => {
part.push(x);
if (part.length === partitionSize) {
parts.push(part.slice());
part.shift();
}
return parts;
}, []);
};
const makePairs = partition(2);
const makeTrios = partition(3);
const pairs = makePairs([1,2,3,4,5,6]);
const trios = makeTrios([1,2,3,4,5,6]);
console.log("partition(2)", JSON.stringify(pairs));
console.log("partition(3)", JSON.stringify(trios));.reduce()而不需要初始值来执行以下操作；
var arr = [ 1, 5, 9, 21 ],
pairs = arr.reduce((p,c,i) => i == 1 ? [[p,c]] : p.concat([[p[p.length-1][1],c]]));
console.log(pairs);[1]时。 - Redu我相信在编程上有一种优雅的方法，但数学上我不能帮助看到每对新数组与原始数组之间存在着索引差为1。
如果你（后来）需要将数组[1, 5, 9, 21, 33]转换为[[1, 9]，[5, 21]，[9, 33]]，你可以利用索引之间的差为2的事实。
如果你为索引差为1创建代码，扩展它将会很容易。
slide的函数，它有两个参数控制切片大小和每个切片之间要丢弃多少元素。
slide与其他答案不同，它提供了这些控制参数。其他答案只能产生固定大小或每次增加1的切片。
// take :: (Int, [a]) -> [a]
const take = (n, xs) =>
xs.slice(0, n)
// drop :: (Int, [a]) -> [a]
const drop = (n, xs) =>
xs.slice(n)
// slice :: (Int, Int, [a]) -> [[a]]
const slide = (m, n, xs) =>
xs.length > m
? [take(m, xs), ...slide(m, n, drop(n, xs))]
: [xs]
const arr = [0,1,2,3,4,5,6]
// log helper improves readability of output in stack snippet
const log = x => console.log(JSON.stringify(x))
log(slide(1, 1, arr))
// [[0],[1],[2],[3],[4],[5],[6]]
log(slide(1, 2, arr))
// [[0],[2],[4],[6]]
log(slide(2, 1, arr))
// [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]]
log(slide(2, 2, arr))
// [[0,1],[2,3],[4,5],[6]]
log(slide(3, 1, arr))
// [[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6]]
log(slide(3, 2, arr))
// [[0,1,2],[2,3,4],[4,5,6]]
log(slide(3, 3, arr))
// [[0,1,2],[3,4,5],[6]] slide 包含 部分 切片（小于 m 的切片），我们可以将其编辑为以下内容。// slice :: (Int, Int, [a]) -> [[a]]
const slide = (m, n, xs) =>
xs.length > m
? [take(m, xs), ...slide(m, n, drop(n, xs))]
: [] // <- return [] instead of [xs]
log(slide(2, 2, arr))
// now prints: [[0,1],[2,3],[4,5]]
// instead of: [[0,1],[2,3],[4,5],[6]]