我有一个类的代码，在这个类中我应该使用
reduce()reduce()我可以使用下面的代码获得最小值，但是我不知道如何在同一个调用中获得最大值。我假设一旦我确实获得了最大值，我就在
reduce()/**
* Takes an array of numbers and returns an array of size 2,
* where the first element is the smallest element in items,
* and the second element is the largest element in items.
*
* Must do this by using a single call to reduce.
*
* For example, minMax([4, 1, 2, 7, 6]) returns [1, 7]
*/
function minMax(items) {
var minMaxArray = items.reduce(
(accumulator, currentValue) => {
return (accumulator < currentValue ? accumulator : currentValue);
}
);
return minMaxArray;
}
在 ES6 中，您可以使用扩展运算符。一串解决方案：
Math.min(...items)
技巧在于提供一个空数组作为初始值参数
arr.reduce(callback, [initialValue])
initialValue [可选] 用作第一个参数的值 第一次调用回调。如果未提供初始值，则第一个 将使用数组中的元素。
所以代码看起来像这样：
function minMax(items) {
return items.reduce((acc, val) => {
acc[0] = ( acc[0] === undefined || val < acc[0] ) ? val : acc[0]
acc[1] = ( acc[1] === undefined || val > acc[1] ) ? val : acc[1]
return acc;
}, []);
}
您可以使用数组作为返回值：
function minMax(items) {
return items.reduce(
(accumulator, currentValue) => {
return [
Math.min(currentValue, accumulator[0]),
Math.max(currentValue, accumulator[1])
];
}, [Number.MAX_VALUE, Number.MIN_VALUE]
);
}
你可以像这样使用。可以有任意数量的参数。
function minValue(...args) {
const min = args.reduce((acc, val) => {
return acc < val ? acc : val;
});
return min;
}
function maxValue(...args) {
const max= args.reduce((acc, val) => {
return acc > val ? acc : val;
});
return max;
}
使用
Math.min()Math.max()function minMax(items) {
var minMaxArray = items.reduce(function (r, n) {
r[0] = (!r[0])? n : Math.min(r[0], n);
r[1] = (!r[1])? n : Math.max(r[1], n);
return r;
}, []);
return minMaxArray;
}
console.log(minMax([4, 1, 2, 7, 6]));由于根本不需要 reduce 调用，您可以从中获得一些乐趣
let items = [62, 3, 7, 9, 33, 6, 322, 67, 853];
let arr = items.reduce((w,o,r,k,s=Math)=>[s.min.apply(0, k),s.max.apply(0, k)],[]);
console.log(arr);你真正需要的是
let minMaxArray = [Math.min.apply(0,items), Math.max.apply(0,items)]const values = [1,2,3,4,5];
const [first] = values;
const maxValue = values.reduce((acc, value) => Math.max(acc, value), first);
使用 reduce 函数获取数组的最小值和最大值
const ArrayList = [1, 2, 3, 4, 3, 20, 0];
const LargestNum = ArrayList.reduce((prev, curr) => {
return Math.max(prev, curr)
});
const MinNum = ArrayList.reduce((prev,curr)=>{
return Math.min(prev,curr)
});
console.log(LargestNum);
console.log(MinNum);
这里是 reduce vs Array 的例子
const result = Array(-10,1,2,3,4,5,6,7,8,9).reduce((a,b)=>{ return (a<b) ? a : b })
您可能想使用相同的方法来获取字符串的长度
const result = Array("ere","reeae","j","Mukono Municipality","Sexy in the City and also").reduce((a,b)=>{ return (a.length<b.length) ? a : b })
Math.minMath.max⚠️ 如果你使用大数组，这将不起作用，即提供
Math.min()function minMax(items) {
return [
Math.min.apply(null, items),
Math.max.apply(null, items)
]
}
...或者如果您更喜欢 ES6 的 Spread 语法：
const minMax = items => [
Math.min(...items),
Math.max(...items)
]
Array.prototype.reduceMath.minMath.maxfunction minMax(arr) {
return arr.reduce(function(acc, cur) {
return [
Math.min(cur, acc[0]),
Math.max(cur, acc[1])
]
}, [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]);
}
...或缩短：
const minMax = items =>
items.reduce((acc, cur) =>
[Math.min(cur, acc[0]), Math.max(cur, acc[1])],
[Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]
)
function minMax(items) {
let newItems = []
const isArray = Array.isArray(items)
const onlyHasNumbers = !items.some(i => isNaN(parseFloat(i)))
// only proceed if items is a non-empty array of numbers
if (isArray && items.length > 0 && onlyHasNumbers) {
newItems = items.reduce((acc, cur) => [
Math.min(cur, acc[0]),
Math.max(cur, acc[1])
], [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])
}
return newItems
}
Documentation for Math.min
文档Math.max
let arr = [8978, 'lol', -78, 989, NaN, null, undefined, 6, 9, 55, 989];
let minMax = arr.reduce(([min, max], v) => [
Math.min(min, v) || min,
Math.max(max, v) || max], [Infinity, -Infinity]);
console.log(minMax);工作原理：
|| minv[Infinity, -Infinity].reduce它使用js解构赋值
我们可以通过声明一个空数组作为 reduce 函数的累加器值，然后在 reduce 方法的最后一次迭代中执行一组不同的操作来实现这一点。我们通过将所有四个参数传递给 reduce 方法（总计、项目、索引、数组）并使用索引与数组长度的比较来在最后一次迭代中做一些不同的事情来做到这一点。
var prices = [32.99, 21.99, 6.99, 4.99, 12.99, 8.98, 5.99];
var highLowPrices = prices.reduce(function(accumulatorArray, price, index, pricesArray){
if (index === pricesArray.length-1){
accumulatorArray.push(price);
var returnArray = [];
accumulatorArray.sort(function(price1, price2){
return price1 - price2;
});
var lowestPrice = accumulatorArray[0];
var highestPrice = accumulatorArray[accumulatorArray.length-1];
returnArray.push(lowestPrice);
returnArray.push(highestPrice);
return returnArray;
} else {
accumulatorArray.push(price);
return accumulatorArray;
}
}, []);
console.log(highLowPrices);
我故意使用了比必要更多的步骤，并使用了语义冗长的变量名称以使逻辑更清晰。
if (index === pricesArray.length-1)let x = [4, 1, 2, 7, 6]
const r = x.reduce((acumularo, currenvalue)=>{
if(acumularo[0]>currenvalue) acumularo[0] = currenvalue
if(acumularo[1]<currenvalue) acumularo[1] = currenvalue
return acumularo
},[x[0],x[0]])
console.log(r)
console.log(r[0]+r[1])
使用 Javascript 中的 reduce 函数获取数组中最大值的代码
const movements = [200, 450, -400, 3000, -650, -130, 70, 1300];
const large = movements.reduce(function (acc, mov) {
if (acc > mov) {
return acc;
} else {
return mov;
}
}, movements[0]);
console.log(large);
答案是：3000
function minMax(items) {
var minMaxArray = [Math.min(...items), Math.max(...items)]
return minMaxArray;
}我知道这已经得到回答，但我放弃了 @Sergey Zhukov 的回答（这似乎不完整）并且能够在 2 行中获得最小值和最大值：
let vals = [ numeric values ]
let min = Math.min.apply(undefined, vals)
let max = Math.max.apply(undefined, vals)
我确实看到了
Array.reduceFunction.apply