如何轻松获得JavaScript数组的min或max元素？
伪代码示例：
let array = [100, 0, 50]
array.min() //=> 0
array.max() //=> 100
在JavaScript中找到数组的最小/最大元素
let arr = [2,5,3,5,6,7,1];
let max = Math.max(...arr); // 7
let min = Math.min(...arr); // 1
如果您正在使用原型，ChaosPandion的解决方案就可以使用。如果没有，请考虑以下问题：
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
如果数组值不是整数，则上面的代码将返回NaN，因此您应该构建一些功能来避免这种情况。否则，它将起作用。
这是一种从对象数组中获取最大值的方法。创建一个副本（带有切片），然后按降序对副本进行排序并获取第一项。
var myArray = [
{"ID": 1, "Cost": 200},
{"ID": 2, "Cost": 1000},
{"ID": 3, "Cost": 50},
{"ID": 4, "Cost": 500}
]
maxsort = myArray.slice(0).sort(function(a, b) { return b.ID - a.ID })[0].ID;
简单的东西，真的。
var arr = [10,20,30,40];
arr.max = function() { return Math.max.apply(Math, this); }; //attach max funct
arr.min = function() { return Math.min.apply(Math, this); }; //attach min funct
alert("min: " + arr.min() + " max: " + arr.max());
我以为我会分享我简单易懂的解决方案。
对于分钟：
var arr = [3, 4, 12, 1, 0, 5];
var min = arr[0];
for (var k = 1; k < arr.length; k++) {
if (arr[k] < min) {
min = arr[k];
}
}
console.log("Min is: " + min);对于最大：
var arr = [3, 4, 12, 1, 0, 5];
var max = arr[0];
for (var k = 1; k < arr.length; k++) {
if (arr[k] > max) {
max = arr[k];
}
}
console.log("Max is: " + max);以下代码对我有用：
var valueList = [10,4,17,9,3];
var maxValue = valueList.reduce(function(a, b) { return Math.max(a, b); });
var minValue = valueList.reduce(function(a, b) { return Math.min(a, b); });
您可以在项目中的任何地方使用以下功能：
function getMin(array){
return Math.min.apply(Math,array);
}
function getMax(array){
return Math.max.apply(Math,array);
}
然后，您可以调用传递数组的函数：
var myArray = [1,2,3,4,5,6,7];
var maximo = getMax(myArray); //return the highest number
反复进行，随时随地进行跟踪。
var min = null;
var max = null;
for (var i = 0, len = arr.length; i < len; ++i)
{
var elem = arr[i];
if (min === null || min > elem) min = elem;
if (max === null || max < elem) max = elem;
}
alert( "min = " + min + ", max = " + max );
如果数组中没有元素，则将min / max保留为null。如果数组中有任何元素，将一遍设置最小值和最大值。
您也可以range使用上述方法扩展Array，以允许重用并提高可读性。在http://jsfiddle.net/9C9fU/上看到有效的小提琴
Array.prototype.range = function() {
var min = null,
max = null,
i, len;
for (i = 0, len = this.length; i < len; ++i)
{
var elem = this[i];
if (min === null || min > elem) min = elem;
if (max === null || max < elem) max = elem;
}
return { min: min, max: max }
};
用作
var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];
var range = arr.range();
console.log(range.min);
console.log(range.max);
替代方法
该Math.min和Math.max方法都是递归操作正在添加到JS引擎调用堆栈，并且最有可能的崩溃对包含大量项目的数组
（超过〜10⁷项目，取决于用户的浏览器）。
Math.max（... Array（1000000）.keys（））;
未捕获的RangeError：超出最大调用堆栈大小
相反，请使用如下所示的内容：
arr.reduce((max, val) => max > val ? max : val, arr[0])
或具有更好的运行时间：
function maxValue(arr) {
let max = arr[0];
for (let val of arr) {
if (val > max) {
max = val;
}
}
return max;
}
或同时获得最小和最大：
function getMinMax(arr) {
return arr.reduce(({min, max}, v) => ({
min: min < v ? min : v,
max: max > v ? max : v,
}), { min: arr[0], max: arr[0] });
}
或具有更好的运行时*：
function getMinMax(arr) {
let min = arr[0];
let max = arr[0];
let i = arr.length;
while (i--) {
min = arr[i] < min ? arr[i] : min;
max = arr[i] > max ? arr[i] : max;
}
return { min, max };
}
*经过1,000,000项测试：
仅供参考，第一个函数运行时（在我的机器上）为15.84ms，而第二个函数运行时仅为4.32ms。
我很惊讶没有人提到减少功能。
var arr = [1, 10, 5, 11, 2]
var b = arr.reduce(function(previous,current){
return previous > current ? previous:current
});
b => 11
arr => [1, 10, 5, 11, 2]
对于大数组（〜10个元素），Math.min并Math.max在node.js中产生RangeError（超出最大调用堆栈大小）。
对于大型阵列，一种快速而肮脏的解决方案是：
Array.prototype.min = function() {
var r = this[0];
this.forEach(function(v,i,a){if (v<r) r=v;});
return r;
};
这可能适合您的目的。
Array.prototype.min = function(comparer) {
if (this.length === 0) return null;
if (this.length === 1) return this[0];
comparer = (comparer || Math.min);
var v = this[0];
for (var i = 1; i < this.length; i++) {
v = comparer(this[i], v);
}
return v;
}
Array.prototype.max = function(comparer) {
if (this.length === 0) return null;
if (this.length === 1) return this[0];
comparer = (comparer || Math.max);
var v = this[0];
for (var i = 1; i < this.length; i++) {
v = comparer(this[i], v);
}
return v;
}
https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max
function getMaxOfArray(numArray) {
return Math.max.apply(null, numArray);
}
var arr = [100, 0, 50];
console.log(getMaxOfArray(arr))这对我有用。
另一种方法是：
var arrayMax = Function.prototype.apply.bind(Math.max, null);
用法：
var max = arrayMax([2, 5, 1]);
找到一个Array元素的最小值的简单解决方案是使用Array原型函数reduce：
A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9
或使用JavaScript的内置Math.Min（）函数（感谢@Tenflex）：
A.reduce((min,val) => Math.min(min,val), A[0]);
设置min为A[0]，然后检查A[1]...A[n]是否严格小于当前值min。如果A[i] < min随后min更新为A[i]。处理min完所有数组元素后，将返回结果。
编辑：包括最小值的位置：
A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min._min ? {_min: val, _idx: min._curr, _curr: min._curr + 1} : {_min: min._min, _idx: min._idx, _curr: min._curr + 1}, {_min: A[0], _idx: 0, _curr: 0}); // returns { _min: -9, _idx: 2, _curr: 6 }
您可以通过扩展Array类型来实现：
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
从这里提振（约翰·雷西格）
两种方法更短，更容易：
let arr = [2, 6, 1, 0]
方式1：
let max = Math.max.apply(null, arr)
方式二：
let max = arr.reduce(function(a, b) {
return Math.max(a, b);
});
对于大阵列（〜10⁷元素），Math.min并且Math.max二者在产生Node.js的下面的错误
RangeError：超出最大调用堆栈大小
一个更健壮的解决方案是不将每个元素都添加到调用堆栈中，而是传递一个数组：
function arrayMin(arr) {
return arr.reduce(function (p, v) {
return ( p < v ? p : v );
});
}
function arrayMax(arr) {
return arr.reduce(function (p, v) {
return ( p > v ? p : v );
});
}
如果您担心速度，下面的代码将比Math.max.apply我的计算机快3倍。参见http://jsperf.com/min-and-max-in-array/2。
function arrayMin(arr) {
var len = arr.length, min = Infinity;
while (len--) {
if (arr[len] < min) {
min = arr[len];
}
}
return min;
};
function arrayMax(arr) {
var len = arr.length, max = -Infinity;
while (len--) {
if (arr[len] > max) {
max = arr[len];
}
}
return max;
};
如果您的数组包含字符串而不是数字，则还需要将它们强制转换为数字。下面的代码可以做到这一点，但是它会使我的机器上的代码速度降低约10倍。参见http://jsperf.com/min-and-max-in-array/3。
function arrayMin(arr) {
var len = arr.length, min = Infinity;
while (len--) {
if (Number(arr[len]) < min) {
min = Number(arr[len]);
}
}
return min;
};
function arrayMax(arr) {
var len = arr.length, max = -Infinity;
while (len--) {
if (Number(arr[len]) > max) {
max = Number(arr[len]);
}
}
return max;
};
如果您像我一样偏执于使用Math.max.apply（根据MDN给定大数组，这可能会导致错误），请尝试以下操作：
function arrayMax(array) {
return array.reduce(function(a, b) {
return Math.max(a, b);
});
}
function arrayMin(array) {
return array.reduce(function(a, b) {
return Math.min(a, b);
});
}
或者，在ES6中：
function arrayMax(array) {
return array.reduce((a, b) => Math.max(a, b));
}
function arrayMin(array) {
return array.reduce((a, b) => Math.min(a, b));
}
不幸的是，匿名函数是必需的（而不是Math.max.bind(Math)因为reduce不只是传递a和传递b给函数而使用，而且还i需要对数组本身的引用，因此我们必须确保我们也不要尝试调用max这些函数。
使用传播算子（ES6）
Math.max(...array); // the same with "min" => Math.min(...array);
const array = [10, 2, 33, 4, 5];
console.log(
Math.max(...array)
)var max_of_array = Math.max.apply(Math, array);
有关完整的讨论，请参见：http : //aaroncrane.co.uk/2008/11/javascript_max_api/
如何扩充内置Array对象以使用Math.max/ Math.min代替：
Array.prototype.max = function() {
return Math.max.apply(null, this);
};
Array.prototype.min = function() {
return Math.min.apply(null, this);
};
这是一个JSFiddle。
增强内置功能可能会导致与其他库发生冲突（有些人看到了），因此您可能更愿意直接直接apply读取Math.xxx()数组：
var min = Math.min.apply(null, arr),
max = Math.max.apply(null, arr);
Alternately, assuming your browser supports ECMAScript 6, you can use the spread operator which functions similarly to the apply method:
var min = Math.min( ...arr ),
max = Math.max( ...arr );
使用
Math.max()或Math.min()以下函数用于
Function.prototype.apply()在数字数组中查找最大元素。getMaxOfArray([1, 2, 3])等价于Math.max(1, 2, 3)，但是您可以getMaxOfArray()在以编程方式构造的任意大小的数组上使用。或者使用新的散布运算符，获得数组的最大值变得容易得多。