Math.min和Math.max

Question

如何轻松获取JavaScript数组的最小或最大元素？

示例Psuedocode：

let array = [100, 0, 50]

array.min() //=> 0
array.max() //=> 100

Answer 1

如何扩充内置的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);

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

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

Answer 2

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

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

Answer 3

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

Answer 4

使用传播运营商（ES6）

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

＆＃13;

const array = [10, 2, 33, 4, 5];

console.log(
  Math.max(...array)
)

＆＃13;

Answer 5

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()。
function getMaxOfArray(numArray) {
    return Math.max.apply(null, numArray);
}
或者使用新的spread operator，获得数组的最大值变得容易多了。
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），通过捕获该错误，您可以计算特定环境的限制。

警告！运行此脚本需要一些时间，具体取决于系统的性能，它可能会降低您的浏览器/系统速度或崩溃！

let testArray = Array.from({length: 10000}, () => Math.floor(Math.random() * 2000000));
for (i = 10000; i < 1000000; ++i) {
  testArray.push(Math.floor(Math.random() * 2000000));
  try {
    Math.max.apply(null, testArray);
  } catch (e) {
    console.log(i);
    break;
  }
}

大型阵列上的性能

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

在2019年，结果显示标准循环（BTW没有大小限制）是最快的。 apply和传播紧随其后，然后很久以后MDN的混合解决方案reduce最慢。

几乎所有的测试都给出了相同的结果，除了传播的一些最终是最慢的。

如果你提升你的数组有100万个项目，那么事情就会开始破坏，你可以将标准循环作为一个快速解决方案，reduce作为一个较慢的解决方案。

JSPerf benchmark

JSBen benchmark

JSBench.me benchmark

基准源代码

var testArrayLength = 100000
var testArray = Array.from({length: testArrayLength}, () => Math.floor(Math.random() * 2000000));

// ES6 spread
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);
});

// apply
Math.min.apply(Math, testArray);
Math.max.apply(Math, testArray);

// standard loop
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

let min = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] < min) {
    min = testArray[i];
  }
}

// MDN hibrid soltuion
// Source: 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 = Infinity;
  var QUANTUM = 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);
  }

  return min;
}

minOfArray(testArray);

function maxOfArray(arr) {
  var max = -Infinity;
  var QUANTUM = 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);
  }

  return max;
}

maxOfArray(testArray);

Answer 6

如果你像我这样偏执狂使用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。

Answer 7

当意图使用参数值列表调用可变参数函数时，经常使用

.apply，例如

Math.max([value1[,value2, ...]])函数返回0或0以上的最大数字。

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

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

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

<强>加成：

Spread运算符使您可以使用数组文字语法在ES5中使用push，splice等组合回退到命令式代码的情况下创建新数组。

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

Answer 8

您可以通过扩展数组类型来实现：

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

来自here（John Resig）

Answer 9

找到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作为结果。

Answer 10

两种方式更简单：

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

// Way 1:
let max = Math.max.apply(null, arr)

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

Answer 11

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

将null作为上下文传递给apply时，上下文将默认为全局对象（在浏览器的情况下为window对象）。将Math对象作为上下文传递将是正确的解决方案，但也不会伤害传递null。以下是null在装饰Math.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);

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

你几乎可以假设没有人装饰Math.max所以，通过null可以毫无问题地工作。

Answer 12

另一种方法：

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

用法：

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

Answer 13

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

＆＃13;

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

＆＃13;

这对我有用。

Answer 14

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

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]

Answer 15

对于大数组（~10⁷元素），Math.min和Math.max会在node.js中产生RangeError（超出最大调用堆栈大小）。

对于大型阵列，快速＆amp;肮脏的解决方案是：

Array.prototype.min = function() {
    var r = this[0];
    this.forEach(function(v,i,a){if (v<r) r=v;});
    return r;
};

Answer 16

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

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

Answer 17

我遇到了同样的问题，我需要获取数组的最小值和最大值，令我惊讶的是，没有内置的数组函数。经过大量阅读后，我决定测试前三名＆＃34;解决方案我自己：

离散解决方案：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个小数位和标准差：

离散解：平均值= 0.161s，sd = 0.078
APPLY solution：mean = 3.571s，sd = 0.487
REDUCE解决方案：平均值= 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];
}

时间：均值= 0.218s，sd = 0.094

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

Answer 18

以下代码适用于我：

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

Answer 19

这可能适合您的目的。

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

Answer 20

除了使用数学函数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]

Answer 21

Math.min和Math.max

Math.min和Math.max都是递归操作，对于大数组（大于约10个项目），很可能 crach 。

相反，您可以像这样使用旧的javascript循环：

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。

Answer 22

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

对于分钟：

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

Answer 23

使用Math.max()或Math.min()

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

以下函数使用Function.prototype.apply()查找数值数组中的最大元素。 getMaxOfArray([1, 2, 3])相当于Math.max(1, 2, 3)，但您可以在任何大小的编程构造数组上使用getMaxOfArray()。

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

或者使用新的扩展运算符，获得数组的最大值变得更加容易。

var arr = [1, 2, 3];
var max = Math.max(...arr); // 3
var min = Math.min(...arr); // 1

Answer 24

简单的东西，真的。

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

Answer 25

这是从一组对象中获取最大值的一种方法。创建一个副本（带有切片），然后按降序对副本进行排序并获取第一个项目。

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;

Answer 26

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

let array = [100, 0, 50];
let [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);

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

const arr = [-1, 9, 3, -6, 35];

//Only find minimum
const min = arr.reduce((a,b)=>Math.min(a,b), Infinity);
console.log("Min:", min);//-6

//Only find maximum
const max = arr.reduce((a,b)=>Math.max(a,b), -Infinity);
console.log("Max:", max);//35

Answer 27

迭代，随时跟踪。

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。如果数组有任何元素，将在一次传递中设置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);

Answer 28

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

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

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

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

let array = [0,20,45,85,41,5,7,85,90,111];

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

console.log(minimum, maximum)

Answer 29

如果你正在使用原型，ChaosPandion的解决方案是有效的。如果没有，请考虑一下：

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

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

如果数组值不是整数，则上面将返回NaN，因此您应该构建一些功能来避免这种情况。否则这将有效。

Answer 30

如果您使用图书馆sugar.js，则可以按照建议撰写arr.min()和arr.max()。您还可以从非数字数组中获取最小值和最大值。

min（map，all = false）返回数组中的元素   最低价值。 map可以是映射要检查的值的函数   一个充当快捷方式的字符串。如果一切都是真的，将返回所有分钟   数组中的值。

max（map，all = false）返回数组中的元素   最大的价值。 map可以是映射要检查的值的函数   或者作为快捷方式的字符串。如果一切都是真的，将返回所有最大值   数组中的值。

示例：

[1,2,3].min() == 1
['fee','fo','fum'].min('length') == "fo"
['fee','fo','fum'].min('length', true) == ["fo"]
['fee','fo','fum'].min(function(n) { return n.length; }); == "fo"
[{a:3,a:2}].min(function(n) { return n['a']; }) == {"a":2}
['fee','fo','fum'].max('length', true) == ["fee","fum"]

Lo-Dash和underscore.js等图书馆也提供类似的强大的最小和最大功能：

Lo-Dash的例子：

_.max([4, 2, 8, 6]) == 8
var characters = [
  { 'name': 'barney', 'age': 36 },
  { 'name': 'fred',   'age': 40 }
];
_.max(characters, function(chr) { return chr.age; }) == { 'name': 'fred', 'age': 40 }

Answer 31

如果您使用 prototype.js 框架，那么此代码将正常运行：

arr.min();
arr.max();

此处记录：Javascript prototype framework for max

Answer 32

minHeight = Math.min.apply({},YourArray);
minKey    = getCertainKey(YourArray,minHeight);
maxHeight = Math.max.apply({},YourArray);
maxKey    = getCertainKey(YourArray,minHeight);
function getCertainKey(array,certainValue){
   for(var key in array){
      if (array[key]==certainValue)
         return key;
   }
}

Answer 33

阅读完所有答案后，我认为最好写出我遇到的最合理的解决方案（此处未提供）。如果您的值数组可能增长到成千上万，请使用一种混合策略：一次将函数应用于数组的大块：

function minOfArray(arr) {
  var min = Infinity;
  var QUANTUM = 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);
  }

  return min;
}

var min = minOfArray([5, 6, 2, 3, 7]);

来源：MDN

Answer 34

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

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

您可以使用reduce来获得最小值（最小）的元素

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

或最大值（最大值）

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

Answer 35

我喜欢Linus's reduce() approach，特别是对于大型数组。但只要你知道你需要最小值和最大值，为什么要重复两次数组呢？

Array.prototype.minmax = function () {
  return this.reduce(function (p, v) {
    return [(p[0] < v ? p[0] : v), (p[1] > v ? p[1] : v)];
  }, [this[0], this[0]]);
}

当然，如果你更喜欢迭代方法，你也可以这样做：

Array.prototype.minmax = function () {
    var mn = this[0], mx = this[0];
    this.forEach(function (v) {
        if (v < mn) mn = v;
        if (v > mx) mx = v;
    });
    return [mn, mx];
};

Answer 36

下面的脚本在ndoejs中为我工作：

 var numbers = [1, 2, 3, 4];
 console.log('Value:: ' + Math.max.apply(null, numbers) ); // 4

Answer 37

让数组= [267、306、108] 让最长的= Math.max（... array）;

Answer 38

创建一个简单的对象

var myArray = new Array();

myArray = [10,12,14,100];

var getMaxHeight = {
     hight : function( array ){ return Math.max.apply( Math, array );
}

getMaxHeight.hight(myArray);

Answer 39

尝试

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

let ar = Array(200*800*4).fill(0);         // pixel buffer
ar.forEach((x,i)=> ar[i]=100-i%101);       // test data

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

console.log('Max', max(ar));
console.log('Min', min(ar))

对于Math.min / max（+应用）：

超出了最大调用堆栈大小（Chrome 74.0.3729.131）

let ar = Array(200*800*4).fill(0);  // pixel buffer
ar.forEach((x,i)=> ar[i]=100-i%101);       // test data

let max1= Math.max(...ar);          // Maximum call stack size exceeded
let max2= Math.max.apply(null, ar); // Maximum call stack size exceeded

// same for min

console.log('Max', max(ar));

Answer 40

如果你有复杂的对象，你可以使用sort ....例如：如果我想得到包含MAX / MIN值低于objs的项目。

var objs= [
{name:"Apple",value:3},
{name:"Love",value:32},
{name:"Cheese",value:1},
{name:"Pork",value:77},
{name:"Xmas",value:99}        
];

我会做一个分类：

objs.sort(function(a, b){return a.value-b.value});

然后： objs[0]是MIN，objs[objs.length-1]是MAX。

Answer 41

问题的递归解决方案

const findMinMax = (arr, max, min, i) => arr.length === i ? {
    min,
    max
  } :
  findMinMax(
    arr,
    arr[i] > max ? arr[i] : max,
    arr[i] < min ? arr[i] : min,
    ++i)

const arr = [5, 34, 2, 1, 6, 7, 9, 3];
const max = findMinMax(arr, arr[0], arr[1], 0)
console.log(max);

Answer 42

您可以使用lodash的方法

_.max([4, 2, 8, 6]);
returns => 8

https://lodash.com/docs/4.17.15#max

_.min([4, 2, 8, 6]);
returns => 2

https://lodash.com/docs/4.17.15#min

Answer 43

let arr = [20,8,29,76,7,21,9]
Math.max.apply（Math，arr）; // 76

Answer 44

好吧，我想以下面的方式做到这一点

const findMaxAndMin = (arr) => {
  if (arr.length <= 0) return -1;
  let min = arr[0];
  let max = arr[0];
  arr.map((n) => {
    n > max ? (max = n) : false;
    n < min ? (min = n) : false;
  });
  return [min, max];
};

Answer 45

这是普通的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;
}

Answer 46

线性的，几乎纯粹的功能性方法

var min=[0, 29, 25].map((function(max) {max=-Infinity; return function(e) {return max=Math.max(max, e);}})())[0]

更多例子：

找出 min 值

function getMin(arr) {
    return (ar || [0, 29, 25]).
        map((function(max) {max=-Infinity; return function(e) {return max=Math.max(max, e);}})())[0];
}

或使用带有变量闭包的Array.map方法

function getMin(arrObjs) {
    return (arrObjs || [{val: 0}, {val: 29}, {val: 25}]).
        map((function(max) {max=-Infinity; return function(e) {return max=(max.val>e.val?max:e);}})())[0];
}

找出 max 值

function getMax(arr) {
    return (ar || [0, 29, 25]).
        map((function(v) {v=Infinity; return function(e) {return v=Math.min(v, e);}})())[0];
}

表示对象数组

function getMax(arrObjs) {
    return (arrObjs || [{val: 0}, {val: 29}, {val: 25}]).
        map((function(v) {v=-Infinity; return function(e) {return v=(v.val<e.val?v:e);}})())[0];
}

Answer 47

您可能不希望向Array原型添加方法，这可能与其他库冲突。

我已经看过很多使用forEach的例子，我不推荐大型阵列，因为它的性能低于for循环。 https://coderwall.com/p/kvzbpa/don-t-use-array-foreach-use-for-instead

另外Math.max(Math, [1,2,3]);总是给我NaN？

function minArray(a) {
  var min=a[0]; for(var i=0,j=a.length;i<j;i++){min=a[i]<min?a[i]:min;}
  return min;
}

function maxArray(a) {
  var max=a[0]; for(var i=0,j=a.length;i<j;i++){max=a[i]>max?a[i]:max;}
  return max;
}

minArray([1,2,3]); // returns 1

如果你有一个对象数组，下面的minArray（）函数示例将接受2个参数，第一个是数组，第二个是要比较的对象键值的键名。在这种情况下，函数将返回具有最小给定键值的数组的索引。

function minArray(a, key) {
  var min, i, j, index=0;
  if(!key) {
    min=a[0]; 
    for(i=0,j=a.length;i<j;i++){min=a[i]<min?a[i]:min;}
    return min;
  }
  min=a[0][key];
  for(i=0,j=a.length;i<j;i++){
    if(a[i][key]<min) {
      min = a[i][key];
      index = i;
    }
  }
    return index;
}

var a = [{fee: 9}, {fee: 2}, {fee: 5}];

minArray(a, "fee"); // returns 1, as 1 is the proper array index for the 2nd array element.

Answer 48

防止＆＃34; max＆＃34;和＆＃34; min＆＃34;被列入＆＃34; for ... in＆＃34;循环：

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

Answer 49

插入用逗号分隔的数字，然后点击要调用的事件，即获取最大或最小数字。

        function maximumNumber() {
       
            var numberValue = document.myForm.number.value.split(",");
            var numberArray = [];
    
            for (var i = 0, len = numberValue.length; i < len; i += 1) {
    
                numberArray.push(+numberValue[i]);
    
                var largestNumber = numberArray.reduce(function (x, y) {
                    return (x > y) ? x : y;
                });
            }
    
            document.getElementById("numberOutput").value = largestNumber;
    
        }
    
        function minimumNumber() {
  
            var numberValue = document.myForm.number.value.split(",");
            var numberArray = [];
    
            for (var i = 0, len = numberValue.length; i < len; i += 1) {
    
                numberArray.push(+numberValue[i]);
    
                var smallestNumber = numberArray.reduce(function (x, y) {
                    return (x < y) ? x : y;
                });
            }
    
            document.getElementById("numberOutput").value = smallestNumber;
    
        }
    
    
            function restrictCharacters(evt) {
    
                evt = (evt) ? evt : window.event;
                var charCode = (evt.which) ? evt.which : evt.keyCode;
                if (((charCode >= '48') && (charCode <= '57')) || (charCode == '44')) {
                    return true;
                }
                else {
                    return false;
                }
            }

    <div>    
            <form name="myForm">
            <table>
            <tr>
                <td>Insert Number</td>
               
                <td><input type="text" name="number" id="number" onkeypress="return restrictCharacters(event);" /></td>
                
                <td><input type="button" value="Maximum" onclick="maximumNumber();" /></td>
                
                <td><input type="button" value="Minimum" onclick="minimumNumber();"/></td>
                
                <td><input type="text" id="numberOutput" name="numberOutput" /></td>
    
            </tr>
            </table>
            </form>
        </div>

Answer 50

如果您需要性能，那么这是小型阵列的最佳方式：

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

Answer 51

你可以使用Array.sort，但你必须编写一个简单的数字排序函数，因为默认是字母。

Look at example 2 here.

然后，您可以抓取arr[0]和arr[arr.length-1]来获取最小值和最大值

Answer 52

这里是另一个示例。使用 lodash 从数组中计算最大值/最小值。

let array = [100, 0, 50];
var func = _.over(Math.max, Math.min);
var [max, min] = func(...array);
// => [100, 0]
console.log(max);
console.log(min);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

Answer 53

我设法以这种方式解决了我的问题：

    var strDiv  = "4,8,5,1"
var arrayDivs   = strDiv.split(",")
var str = "";

for (i=0;i<arrayDivs.length;i++)
{
    if (i<arrayDivs.length-1)
    {
      str = str + eval('arrayDivs['+i+']')+',';
    } 
    else if (i==arrayDivs.length-1)
    {
      str = str + eval('arrayDivs['+i+']');
    }
}

str = 'Math.max(' + str + ')';
    var numMax = eval(str);

我希望我有所帮助。

最好的问候。

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

54 个答案:

TL;博士

MDN解决方案

数组的最大大小

大型阵列上的性能

JSPerf benchmark

JSBen benchmark

JSBench.me benchmark

基准源代码

Math.min和Math.max