我怎样才能轻松地获得一个JavaScript数组的最小或最大元素?
伪代码示例:
let array = [100, 0, 50]
array.min() //=> 0
array.max() //=> 100
当前回答
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;
}
}
其他回答
你可以通过扩展Array类型来实现:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
从这里开始(作者:John Resig)
让arr =[76年20日8日,29日,7日,21日,9] Math.max。应用(数学，arr);/ / 76
我遇到了同样的问题，我需要获得数组的最小值和最大值，令我惊讶的是，数组没有内置函数。在阅读了大量内容后，我决定亲自测试“前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解决方案)。
您可以使用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
博士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解决方案
关于Math.max()的官方MDN文档已经涵盖了这个问题:
下面的函数使用function .prototype.apply()来查找数值数组中的最大元素。getMaxOfArray([1,2,3])等价于Math。max(1,2,3)，但是您可以在任何大小的编程构造数组上使用getMaxOfArray()。 函数getMaxOfArray(numArray) { Math.max返回。应用(null, numArray); ｝ 或者使用新的展开运算符，获得数组的最大值变得容易得多。 Var arr = [1,2,3]; var max = Math.max(…arr);
数组的最大大小
根据MDN, apply和spread解决方案的限制为65536，这来自于参数的最大数量的限制:
But beware: in using apply this way, you run the risk of exceeding the JavaScript engine's argument length limit. The consequences of applying a function with too many arguments (think more than tens of thousands of arguments) vary across engines (JavaScriptCore has hard-coded argument limit of 65536), because the limit (indeed even the nature of any excessively-large-stack behavior) is unspecified. Some engines will throw an exception. More perniciously, others will arbitrarily limit the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments 5, 6, 2, 3 had been passed to apply in the examples above, rather than the full array.
他们甚至提供了一种混合解决方案，与其他解决方案相比，它的性能并不好。有关更多信息，请参阅下面的性能测试。
2019年的实际限制是调用堆栈的最大大小。对于现代基于Chromium的桌面浏览器，这意味着当使用apply或spread来查找min/max时，实际上只有数字的数组的最大大小是~120000。在此之上，将会出现堆栈溢出，并抛出以下错误:
RangeError:超过最大调用堆栈大小
使用下面的脚本(基于本文)，通过捕获该错误，可以计算特定环境的限制。
警告!运行此脚本需要时间，并且根据您的系统性能，它可能会减慢或崩溃您的浏览器/系统!
let 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。应用(null, testArray); } catch (e) { console.log(我); 打破; ｝ ｝
大型阵列的性能
基于EscapeNetscape评论中的测试，我创建了一些基准测试，在一个只有100000项的随机数数组上测试5种不同的方法。
2019年的结果显示，标准循环(BTW没有大小限制)在任何地方都是最快的。apply和spread紧随其后，然后是MDN的混合解决方案，然后reduce是最慢的。
几乎所有的测试都给出了相同的结果，除了其中一个扩散somewhy的结果是最慢的。
如果你将你的数组增加到100万个项目，事情就会开始中断，你只剩下标准循环作为快速解决方案，而减少作为较慢的解决方案。
JSPerf基准
JSBen基准
JSBench。我的基准
基准测试源代码
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);
