另一个解决方案

   let arr = [1,10,25,15,31,5,7,101];
    let sortedArr = arr.sort((a, b) => a - b)

    let min = sortedArr[0];
    let max = sortedArr[arr.length-1]

    console.log(`min => ${min}. Max => ${max}`)

下面是一个简单的JS方法。

function getMinArrayVal(seq){
    var minVal = seq[0];
    for(var i = 0; i<seq.length-1; i++){
        if(minVal < seq[i+1]){
        continue;
        } else {
        minVal = seq[i+1];
        }
    }
    return minVal;
}

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

当将null作为上下文传递给apply时，上下文将默认为全局对象(浏览器中的窗口对象)。将Math对象作为上下文传递是正确的解决方案，但传递null也不会造成伤害。这里有一个例子，当装饰Math时，null可能会引起麻烦。max函数:

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

上面的代码将抛出异常，因为。Foo将被计算为window。Foo，没有定义。如果我们用Math替换null，事情就会像预期的那样工作，字符串“foo”将被打印到屏幕上(我使用Mozilla Rhino进行测试)。

你几乎可以假设没有人授予过数学勋章。所以，传递null将工作没有问题。

为了防止“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

我遇到了同样的问题，我需要获得数组的最小值和最大值，令我惊讶的是，数组没有内置函数。在阅读了大量内容后，我决定亲自测试“前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解决方案)。

使用展开运算符(ES6)

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

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