是否有一种优雅，实用的方法来改变这个阵列：
[ 1, 5, 9, 21 ]
进入这个
[ [1, 5], [5, 9], [9, 21] ]
我知道我可以forEach数组并收集值来创建一个新数组。是否有一种优雅的方法可以在_.lodash中使用forEach
答案 0 :(得分：5)
您可以映射拼接数组并检查索引。如果它不为零，则取前一个，否则为原始数组的第一个元素。
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; }
When using “bundle” packaging with maven-bundle-plugin goals are executed twice 建议的更短版本：
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; }
答案 1 :(得分：3)
使用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; }
答案 2 :(得分：2)
使用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);
答案 3 :(得分：1)
答案 4 :(得分：0)
我注意到目前的解决方案在某种程度上都是向前或向后（arr[i + 1]或arr[i - 1]）。
在探索使用reduce的方法和在函数闭包中定义的附加数组来存储待完成的分区时，可能会有用。
注意：
part在处理仅2个项目时不必是数组，但通过使用数组，我们将该方法扩展为适用于n大小的项目集shift的粉丝，可以使用slice的组合并重新定义part，但我认为这里很安全。< / LI>
length小于所需元素数的分区
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));
答案 5 :(得分：0)
您可以使用 this.geolocation.getCurrentPosition(posOptions).then((localisation,err) => {
})
this.storage.get('param1').then((param1) => {
})
this.storage.get('param2').then((param2) => {
// Do some stuff with localisation, param1 & param2
alert(localisation);
alert(param1);
alert(param2);
})
没有首字母的单个衬垫执行以下操作;
.reduce()
答案 6 :(得分：0)
我确信有一种优雅的方式，以编程方式，但是，在数学上我不禁看到每个新对与原始数组的索引差异为1。
如果您（稍后）需要将数组[ 1, 5, 9, 21, 33 ]转换为[ [1, 9], [5, 21], [9, 33] ]，则可以使用索引之间的差异为2的事实。
如果您为索引差异1创建代码，那么扩展它将很容易。
答案 7 :(得分：0)
这里是slide，它有两个参数来控制切片的大小以及切片之间丢弃的元素数
slide与其他答案的不同之处在于给出了这些控制参数。此处的其他答案仅限于生成2个切片，或者每次将切片递增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]]