在 JavaScript 中查找数组的最小/最大元素

如何扩充内置 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); };让 p = [35,2,65,7,8,9,12,121,33,99]; console.log(`最大值为：${p.max()}` + `\n最小值为：${p.min()}`);

这是一个JSFiddle。

增加内置函数可能会导致与其他库发生冲突（有些人看到），因此您可能更愿意直接将 Math.xxx() apply 写入您的数组：

var min = Math.min.apply(null, arr),
    max = Math.max.apply(null, arr);

或者，假设您的浏览器支持 ECMAScript 6，您可以使用 spread syntax，其功能类似于 apply 方法：

var min = Math.min( ...arr ),
    max = Math.max( ...arr );

---

var max_of_array = Math.max.apply(Math, array);

有关完整的讨论，请参阅：http://aaroncrane.co.uk/2008/11/javascript_max_api/

---

对于大数组（~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 倍。请参阅https://jsben.ch/JPOyL。

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 倍。请参阅https://jsben.ch/uPipD。

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;
};

---

使用扩展运算符 (ES6)

Math.max(...array)  // The same with "min" => Math.min(...array)

常量数组 = [10, 2, 33, 4, 5]; console.log(Math.max(...array))

---

tl;博士

// For regular arrays:
var max = Math.max(...arrayOfNumbers);

// For arrays with tens of thousands of items:
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

MDN 解决方案

official MDN docs on Math.max() 已涵盖此问题：

以下函数使用 Function.prototype.apply() 查找数值数组中的最大元素。 getMaxOfArray([1, 2, 3]) 等价于 Math.max(1, 2, 3)，但您可以在以编程方式构造的任意大小的数组上使用 getMaxOfArray()。函数 getMaxOfArray(numArray) { return Math.max.apply(null, numArray);或者使用新的扩展运算符，获取数组的最大值变得容易得多。 var arr = [1, 2, 3]; var max = Math.max(...arr);

数组的最大大小

According to MDN apply 和传播解决方案具有 65536 的限制，这是来自最大参数数量的限制：

但请注意：以这种方式使用 apply 时，可能会超出 JavaScript 引擎的参数长度限制。应用带有太多参数的函数（考虑超过数万个参数）的后果因引擎而异（JavaScriptCore 的硬编码参数限制为 65536），因为限制（实际上甚至是任何过大堆栈的性质行为）未指定。有些引擎会抛出异常。更有害的是，其他人会任意限制实际传递给应用函数的参数数量。为了说明后一种情况：如果这样的引擎有四个参数的限制（实际限制当然要高得多），就好像参数 5、6、2、3 已被传递以应用于上面的示例，而不是整个数组。

他们甚至提供了一种混合解决方案，与其他解决方案相比，它的性能并不好。有关更多信息，请参阅下面的性能测试。

在 2019 年，实际限制是调用堆栈的最大大小。对于基于 Chromium 的现代桌面浏览器，这意味着在使用 apply 或展开查找最小值/最大值时，实际上仅数字数组的最大大小约为 120000。在此之上，将出现堆栈溢出，并引发以下错误：

RangeError：超出最大调用堆栈大小

使用下面的脚本（基于 this blog post），通过捕获该错误，您可以计算特定环境的限制。

警告！运行此脚本需要时间，并且根据您的系统性能，它可能会减慢或崩溃您的浏览器/系统！

让 testArray = Array.from({length: 10000}, () => Math.floor(Math.random() * 2000000)); for (i = 10000; i < 1000000; ++i) { testArray.push(Math.floor(Math.random() * 2000000));尝试 { Math.max.apply(null, testArray); } 捕捉 (e) { console.log(i);休息; } }

大型阵列上的性能

根据 EscapeNetscape 评论中的测试，我创建了一些基准测试，在具有 100000 个项目的仅随机数数组上测试 5 种不同的方法。

在 2019 年，结果显示 标准循环（顺便说一句，没有大小限制）在任何地方都是最快的。 apply 和传播 紧随其后，然后是 MDN 的混合解决方案，然后是最慢的 reduce。

几乎所有的测试都给出了相同的结果，除了一个传播速度最慢的测试。

如果您将数组提高到拥有 100 万个项目，事情就会开始中断，您将使用标准循环作为快速解决方案，而 reduce 作为较慢的解决方案。

JSPerf 基准测试

https://i.stack.imgur.com/5NHlm.png

JSBen 基准测试

https://i.stack.imgur.com/DcC0N.png

JSBench.me 基准测试

https://i.stack.imgur.com/WTOs3.png

基准测试源代码

var testArrayLength = 100000 var testArray = Array.from({length: testArrayLength}, () => Math.floor(Math.random() * 2000000)); // ES6 传播 Math.min(...testArray); Math.max(...testArray); // reduce testArray.reduce(function(a, b) { return Math.max(a, b); }); testArray.reduce(function(a, b) { return Math.min(a, b); }); // 应用 Math.min.apply(Math, testArray); Math.max.apply(Math, testArray); // 标准循环 let max = testArray[0]; for (let i = 1; i < testArrayLength; ++i) { if (testArray[i] > max) { max = testArray[i]; } } 让 min = testArray[0]; for (let i = 1; i < testArrayLength; ++i) { if (testArray[i] < min) { min = testArray[i]; } } // MDN 混合解决方案 // 来源：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Using_apply_and_built-in_functions function minOfArray(arr) { var min = 无穷大；变量量子 = 32768; for (var i = 0, len = arr.length; i < len; i += QUANTUM) { var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len) )); min = Math.min(submin, min); } 返回分钟； } minOfArray(testArray);函数 maxOfArray(arr) { var max = -Infinity;变量量子 = 32768; for (var i = 0, len = arr.length; i < len; i += QUANTUM) { var submax = Math.max.apply(null, arr.slice(i, Math.max(i + QUANTUM, len) )); max = Math.max(submax, max); } 返回最大值； } maxOfArray(testArray);

---

如果您像我一样偏执于使用 Math.max.apply（在给定大型数组 according to 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。

---

替代方法

Math.min 和 Math.max 是从项目集合中获取最小和最大项目的好方法，但重要的是要注意它可能附带的一些空洞。

将它们与包含大量项目（超过 ~107 个项目，取决于用户的浏览器）的数组很可能会崩溃并给出以下错误消息：

const arr = Array.from(Array(1000000).keys());
Math.min(arr);
Math.max(arr);

未捕获的 RangeError：超出最大调用堆栈大小

更新
最新的浏览器可能会返回 NaN。这可能是处理错误的更好方法，但它还不能解决问题。

相反，考虑使用类似这样的东西：

function maxValue(arr) {
  return arr.reduce((max, val) => max > val ? max : val)
}

或者具有更好的运行时间：

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.84 毫秒，而第二个函数只有 4.32 毫秒。

---

两种方法更短更容易：

let arr = [2, 6, 1, 0]

方式一：

let max = Math.max.apply(null, arr)

方式二：

let max = arr.reduce(function(a, b) {
    return Math.max(a, b);
});

---

.apply 通常用于意图调用带有参数值列表的可变参数函数，例如

Math.max([value1[,value2, ...]]) 函数返回零个或多个数字中的最大值。

Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20

Math.max() 方法不允许您传入数组。如果您有一个需要获取最大值的列表，您通常会使用 Function.prototype.apply() 调用此函数，例如

Math.max.apply(null, [10, 20]); // 20
Math.max.apply(null, [-10, -20]); // -10
Math.max.apply(null, [-10, 20]); // 20

但是，从 ECMAScript 6 开始，您可以使用 spread operator：

扩展运算符允许在需要多个参数（用于函数调用）或多个元素（用于数组字面量）的地方扩展表达式。

使用扩展运算符，上面的内容可以重写为：

Math.max(...[10, 20]); // 20
Math.max(...[-10, -20]); // -10
Math.max(...[-10, 20]); // 20

使用可变参数运算符调用函数时，您甚至可以添加其他值，例如

Math.max(...[10, 20], 50); // 50
Math.max(...[-10, -20], 50); // 50

奖金：

扩展运算符使您能够使用数组文字语法在 ES5 中您需要使用 push、splice 等组合的命令式代码的情况下创建新数组。

let foo = ['b', 'c'];
let bar = ['a', ...foo, 'd', 'e']; // ['a', 'b', 'c', 'd', 'e']

---

您可以通过扩展 Array 类型来做到这一点：

Array.max = function( array ){
    return Math.max.apply( Math, array );
};
Array.min = function( array ){
    return Math.min.apply( Math, array );
}; 

从 here 提升（由 John Resig）

---

找到 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 }

---

对于简洁的现代解决方案，可以对数组执行 reduce 操作，跟踪当前的最小值和最大值，因此数组只迭代一次（这是最佳的）。为了简洁起见，这里使用 Destructuring assignment。

让数组 = [100, 0, 50];让 [min, max] = array.reduce(([prevMin,prevMax], curr)=> [Math.min(prevMin, curr), Math.max(prevMax, curr)], [Infinity, -Infinity]); console.log("Min:", min); console.log("Max:", max);

为了只找到最小值或最大值，我们可以使用几乎相同的方式执行 reduce 操作，但我们只需要跟踪之前的最优值。此方法比使用 apply 更好，因为当数组对于堆栈而言太大时，它不会导致错误。

常量 arr = [-1, 9, 3, -6, 35]; //只求最小值 const min = arr.reduce((a,b)=>Math.min(a,b), Infinity); console.log("Min:", min);//-6 //只求最大值 const max = arr.reduce((a,b)=>Math.max(a,b), -Infinity); console.log("Max:", max);//35

---

其他人已经给出了一些解决方案来增强 Array.prototype。我想要在这个答案中澄清它应该是 Math.min.apply( Math, array ) 还是 Math.min.apply( null, array )。 那么应该使用什么上下文，Math 还是 null？

将 null 作为上下文传递给 apply 时，上下文将默认为全局对象（浏览器中的 window 对象）。将 Math 对象作为上下文传递是正确的解决方案，但传递 null 也无妨。以下是装饰 Math.max 函数时 null 可能导致问题的示例：

// decorate Math.max
(function (oldMax) {
    Math.max = function () {
        this.foo(); // call Math.foo, or at least that's what we want

        return oldMax.apply(this, arguments);
    };
})(Math.max);

Math.foo = function () {
    print("foo");
};

Array.prototype.max = function() {
  return Math.max.apply(null, this); // <-- passing null as the context
};

var max = [1, 2, 3].max();

print(max);

以上将引发异常，因为 this.foo 将被评估为 window.foo，即 undefined。如果我们将 null 替换为 Math，事情将按预期工作，并且字符串“foo”将打印到屏幕上（我使用 Mozilla Rhino 进行了测试）。

您几乎可以假设没有人装饰 Math.max，因此，传递 null 将毫无问题地工作。

---

另一种方法：

var arrayMax = Function.prototype.apply.bind(Math.max, null);

用法：

var max = arrayMax([2, 5, 1]);

---

我很惊讶没有人提到 reduce 功能。

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]

---

https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max

函数 getMaxOfArray(numArray) { return Math.max.apply(null, numArray); } var arr = [100, 0, 50]; console.log(getMaxOfArray(arr))

这对我有用。

---

这可能适合您的目的。

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;
}

---

让数组 = [267, 306, 108] 让最长 = Math.max(...array);

---

我想我会分享我简单易懂的解决方案。

对于分钟：

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);

对于最大值：

var arr = [3, 4, 12, 1, 0, 5];变量最大值 = arr[0]; for (var k = 1; k < arr.length; k++) { if (arr[k] > max) { max = arr[k]; } } console.log("最大值为：" + max);

---

对于大数组（~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;
};

---

除了使用数学函数 max 和 min 之外，另一个要使用的函数是 sort() 的内置函数：我们开始

const nums = [12, 67, 58, 30].sort((x, y) => 
x -  y)
let min_val = nums[0]
let max_val = nums[nums.length -1]

---

我有同样的问题，我需要获取数组的最小值和最大值，令我惊讶的是，数组没有内置函数。在阅读了很多之后，我决定自己测试“前 3 名”的解决方案：

离散解决方案：一个 FOR 循环来检查数组的每个元素与当前的最大值和/或最小值； APPLY 解决方案：使用 apply(null,array); 将数组发送到 Math.max 和/或 Math.min 内部函数； REDUCE 解决方案：使用 reduce(function) 递归检查数组的每个元素。

测试代码是这样的：

function GetMaxDISCRETE(A)
{   var MaxX=A[0];

    for (var X=0;X<A.length;X++)
        if (MaxX<A[X])
            MaxX=A[X];

    return MaxX;
}

function GetMaxAPPLY(A)
{   return Math.max.apply(null,A);
}

function GetMaxREDUCE(A)
{   return A.reduce(function(p,c)
    {   return p>c?p:c;
    });
}

数组 A 用 100,000 个随机整数填充，每个函数在装有 Windows Vista 的 Intel Pentium 4 2.99GHz 桌面上的 Mozilla Firefox 28.0 上执行 10,000 次。时间以秒为单位，由 performance.now() 函数检索。结果是这些，有 3 个小数位数和标准偏差：

离散解：mean=0.161s，sd=0.078 APPLY 解：mean=3.571s，sd=0.487 REDUCE 解：mean=0.350s，sd=0.044

REDUCE 解决方案比离散解决方案慢 117%。 APPLY 解决方案更差，比离散解决方案慢 2,118%。此外，正如 Peter 所观察到的，它不适用于大型数组（大约超过 1,000,000 个元素）。

此外，为了完成测试，我测试了这个扩展的离散代码：

var MaxX=A[0],MinX=A[0];

for (var X=0;X<A.length;X++)
{   if (MaxX<A[X])
        MaxX=A[X];
    if (MinX>A[X])
        MinX=A[X];
}

计时：mean=0.218s，sd=0.094

因此，它比简单的离散解决方案慢 35%，但它同时检索最大值和最小值（任何其他解决方案都需要至少两倍的时间来检索它们）。一旦 OP 需要这两个值，离散解决方案将是最佳选择（即使作为两个单独的函数，一个用于计算最大值，另一个用于计算最小值，它们的性能也会优于第二好的 REDUCE 解决方案）。

---

您可以在项目中的任何位置使用以下功能：

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 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); });

---

对于包含对象而不是数字的数组：

arr = [
  { name: 'a', value: 5 },
  { name: 'b', value: 3 },
  { name: 'c', value: 4 }
]

您可以使用 reduce 获取具有最小值 (min) 的元素

arr.reduce((a, b) => a.value < b.value ? a : b)
// { name: 'b', value: 3 }

或最大值（max）

arr.reduce((a, b) => a.value > b.value ? a : b)
// { name: 'a', value: 5 }

---

让 arr=[20,8,29,76,7,21,9] Math.max.apply( Math, arr ); // 76

---

迭代，随时跟踪。

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 为空。如果数组有任何元素，将一次性设置最小值和最大值。

您还可以使用上述方法使用 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);

---

array.sort((a, b) => b - a)[0];

为您提供数字数组中的最大值。

array.sort((a, b) => a - b)[0];

为您提供数字数组中的最小值。

让数组 = [0,20,45,85,41,5,7,85,90,111];让最大值 = array.sort((a, b) => b - a)[0];让最小值 = array.sort((a, b) => a - b)[0]; console.log（最小，最大）

---

简单的东西，真的。

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 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; 

---