为了防止“max”和“min”被列在“for…”在“循环:

Object.defineProperty(Array.prototype, "max", {
    enumerable: false,
    configurable: false,
    writable: false,    
    value: function() {
        return Math.max.apply(null, this);
    }
});
Object.defineProperty(Array.prototype, "min", {
    enumerable: false,
    configurable: false,
    writable: false,    
    value: function() {
        return Math.min.apply(null, this);
    }
});

用法:

var x = [10,23,44,21,5];
x.max(); //44
x.min(); //5

如果你需要性能，那么对于小数组来说这是最好的方法:

var min = 99999;
var max = 0;
for(var i = 0; i < v.length; i++)
{
    if(v[i] < min)
    {
        min = v[i];
    }
    if(v[i] >= max)
    {
        max = v[i];
    }
}

使用展开运算符(ES6)

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

Const数组= [10,2,33,4,5]; console.log ( Math.max数组(…) ）

我遇到了同样的问题，我需要获得数组的最小值和最大值，令我惊讶的是，数组没有内置函数。在阅读了大量内容后，我决定亲自测试“前3个”解决方案:

离散解决方案:FOR循环检查数组中的每个元素是否符合当前的最大和/或最小值; 应用解决方案:将数组发送到Math。max和/或Math。最小内部函数使用apply(null，数组); REDUCE解决方案:使用REDUCE(函数)递归检查数组的每个元素。

测试代码是这样的:

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个随机整数填充，每个函数在Mozilla Firefox 28.0、intel Pentium 4 2.99GHz台式机和Windows Vista上执行10,000次。时间以秒为单位，由performance.now()函数检索。结果是这样的，有3个小数位数和标准偏差:

离散解:mean=0.161s, sd=0.078 应用溶液:mean=3.571s, sd=0.487 REDUCE解:mean=0.350 0s, 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解决方案)。

Let array = [267, 306, 108] let longest = Math.max(…数组);

替代方法

的数学。min和数学。Max是一个很好的方法，可以从一个项目集合中获得最小和最大项目，但重要的是要意识到它可能带来的一些空腔。 将它们与包含大量条目的数组(超过~10⁷条，取决于用户的浏览器)一起使用，很可能会崩溃并给出以下错误消息:

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

Uncaught 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毫秒。