我有一个类的代码，我应该使用reduce（）方法来查找数组中的最小值和最大值。但是，我们只需要使用一次调用来减少。返回数组的大小应为2，但我知道reduce（）方法总是返回一个大小为1的数组。我可以使用下面的代码获得最小值，但我不知道如何在同一个调用中获取最大值。我假设一旦我获得了最大值，我只需在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;
}
答案 0 :(得分：12)
在 ES6 中，您可以使用点差运算符。一个字符串解决方案：
Math.min(...items)
答案 1 :(得分：8)
技巧包括提供一个空数组作为initialValue参数
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;
}, []);
}
答案 2 :(得分：5)
您可以使用数组作为返回值：
" 34
R 82
e 101
v 118
i 105
e 101
w 119
10
" 34
答案 3 :(得分：3)
使用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]));
答案 4 :(得分：2)
由于根本不需要降低呼叫，你可以享受它的乐趣
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)]
答案 5 :(得分：2)
const values = [1,2,3,4,5];
const [first] = values;
const maxValue = values.reduce((acc, value) => Math.max(acc, value), first);
答案 6 :(得分：1)
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);
工作方式：
|| min支票号码是v。
[Infinity, -Infinity]是.reduce的初始值
它使用js destructuring分配
答案 7 :(得分：0)
Math.min和Math.max的解决方案：⚠️
如果您使用大数组，则此方法将不起作用，即为Math.min()提供许多参数，如“ ，您将面临超过JavaScript引擎参数长度限制的风险。参数过多的函数（认为有数以万计的参数）在各个引擎之间有所不同（JavaScriptCore的硬编码参数限制为65536），因为未指定限制（甚至包括任何过大堆栈行为的性质）。某些引擎会引发异常。” from MDN web docs。
function minMax(items) {
return [
Math.min.apply(null, items),
Math.max.apply(null, items)
]
}
...或者您更喜欢ES6's Spread syntax：
const minMax = items => [
Math.min(...items),
Math.max(...items)
]
Array.prototype.reduce，Math.min和Math.max function 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(function(acc, cur) {
return [
Math.min(cur, acc[0]),
Math.max(cur, acc[1])
]
}, [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])
}
return newItems
}
Math.min的文档
Math.max的文档
答案 8 :(得分：0)
使用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(pre,curr)
});
console.log(LargestNum);
console.log(MinNum);
答案 9 :(得分：0)
您可以使用do这样的方法。可以有任意数量的参数。
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;
}
答案 10 :(得分：0)
我们可以通过声明一个空数组作为reduce函数的累加器值，然后在reduce方法的最后一次迭代中执行一组不同的操作来实现这一点。为此，我们将所有四个参数传递给 reduce 方法（total、item、index、array），并使用索引与数组长度的比较在最后一次迭代中做一些不同的事情。
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) 表示在通过价格数组的 reduce 方法的最后一次迭代中，发生了一组不同的操作。到目前为止，我们只是重新创建价格数组，这是微不足道的。但是在最后一次迭代中，在完全重新创建价格数组之后，我们做了一些不同的事情。我们创建另一个空数组，我们打算返回的数组。然后我们对 'accumulatorArray' 变量进行排序 - 这是重新创建的价格数组，从最低到最高对其进行排序。我们现在取最低价格和最高价格并将它们存储在变量中。按升序对数组进行排序后，我们知道最低的是索引 0，最高的是索引 array.length - 1。然后我们将这些变量推送到我们之前声明的返回数组中。而不是返回累加器变量本身，我们返回我们自己特别声明的返回数组。结果是一个数组，价格最低，然后是最高价格。
答案 11 :(得分：-1)
我知道已经回答了这个问题，但是我放弃了@Sergey Zhukov的回答（似乎不完整），并且能够在2行中获取最小值和最大值：
let vals = [ numeric values ]
let min = Math.min.apply(undefined, vals)
let max = Math.max.apply(undefined, vals)
我确实看到了Array.reduce中的值，但是有了这样一个非常简单的用例和，只要您了解Function.apply的作用，这就是我的目标。解决方案。