我怎样才能轻松地获得一个JavaScript数组的最小或最大元素?
伪代码示例:
let array = [100, 0, 50]
array.min() //=> 0
array.max() //=> 100
这也许适合你的目的。
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;
}
你可以使用数组。排序，但你必须写一个简单的数字排序函数，因为默认是字母排序。
看例2。
然后你可以得到arr[0]和arr[arr。长度-1]来得到最小值和最大值。
如何使用Math.max/Math扩展内置Array对象呢?最小值:
Array.prototype.max = function() { Math.max返回。应用(null,这); }; Array.prototype.min = function() { Math.min返回。应用(null,这); }; 令p = [35,2,65,7,8,9,12,121,33,99]; console.log('最大值为:${p.max()} ' + \nMin值为:${p.min()} ');
这是一个JSFiddle。
扩充内置库可能会导致与其他库的冲突(有些见)，所以你可能更喜欢直接将Math.xxx()应用到你的数组:
var min = Math.min.apply(null, arr),
max = Math.max.apply(null, arr);
另外，假设你的浏览器支持ECMAScript 6，你可以使用扩展语法，它的功能类似于apply方法:
var min = Math.min( ...arr ),
max = Math.max( ...arr );
遍历，在执行过程中保持跟踪。
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);
如果你使用的是原型机，ChaosPandion的解决方案是有效的。如果不是，考虑一下:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
如果数组值不是整数，上面的函数将返回NaN，因此您应该构建一些功能来避免这种情况。否则这个就可以了。
你可以通过扩展Array类型来实现:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
从这里开始(作者:John Resig)
其他人已经给出了一些增强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将工作没有问题。
var max_of_array = Math.max.apply(Math, array);
完整的讨论见: http://aaroncrane.co.uk/2008/11/javascript_max_api/
对于大数组(~10⁷elements)， Math。min和数学。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;
};
我是这样解决问题的:
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);
我希望我能帮上忙。
致以最亲切的问候。
还有一种方法:
var arrayMax = Function.prototype.apply.bind(Math.max, null);
用法:
var max = arrayMax([2, 5, 1]);
创建一个简单的对象
var myArray = new Array();
myArray = [10,12,14,100];
var getMaxHeight = {
hight : function( array ){ return Math.max.apply( Math, array );
}
getMaxHeight.hight(myArray);
对于大数组(~10⁷elements)， Math。min和数学。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;
};
如果你需要性能，那么对于小数组来说这是最好的方法:
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];
}
}
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;
}
}
我很惊讶没有人提到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]
下面是一种从对象数组中获取最大值的方法。创建一个副本(使用切片)，然后按降序对副本排序并抓取第一项。
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;
我喜欢Linus的reduce()方法，特别是对于大型数组。但只要你知道你需要最小值和最大值，为什么要迭代数组两次呢?
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];
};
我遇到了同样的问题，我需要获得数组的最小值和最大值，令我惊讶的是，数组没有内置函数。在阅读了大量内容后，我决定亲自测试“前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解决方案)。
如果你使用sugar.js库，你可以按照你的建议编写arr.min()和arr.max()。您还可以从非数值数组中获得最小值和最大值。
min(map, all = false)返回数组中包含 最小值。Map可以是映射要检查的值的函数或 作为快捷键的字符串。如果全部为真，将返回所有的min 数组中的值。 max(map, all = false)返回数组中带有 最大的价值。Map可以是映射要检查的值的函数 或者是作为快捷键的字符串。如果all为true，将返回all max 数组中的值。
例子:
[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这样的库也提供了类似强大的min和max函数:
例子来自《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 }
你可以在项目的任何地方使用下面的函数:
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 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());
当意图是调用带有参数值列表的变进函数时，.apply经常被使用。
的数学。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开始，你可以使用扩展操作符:
展开运算符允许在需要多个参数(用于函数调用)或多个元素(用于数组字面量)的地方展开表达式。
使用展开运算符，上面的代码可以重写为:
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']
博士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);
如果你像我一样偏执于使用Math.max.apply(根据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。
插入以逗号分隔的数字，然后单击要调用的事件，即获取最大或最小数字。
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>
如果你有一个复杂的对象，你可以使用排序....例如:如果我想获得包含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]是最小值，objs[objs. obs]length-1]是最大值。
为了防止“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
您可能不希望向Array原型添加方法，这可能与其他库冲突。
我见过很多使用forEach的例子，我不推荐它用于大型数组，因为它的性能比for循环差。https://coderwall.com/p/kvzbpa/don-t-use-array-foreach-use-for-instead
同时数学。max(数学,[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.
线性的,almost-purely-functional-approach
var min=[0, 29, 25].map((function(max) {max=-Infinity; return function(e) {return max=Math.max(max, e);}})())[0]
更多的例子:
求最小值
function getMin(arr) {
return (ar || [0, 29, 25]).
map((function(max) {max=-Infinity; return function(e) {return max=Math.max(max, e);}})())[0];
}
或者使用Array。映射方法与变量闭包
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];
}
求最大值
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];
}
使用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
使用展开运算符(ES6)
Math.max(...array) // The same with "min" => Math.min(...array)
Const数组= [10,2,33,4,5]; console.log ( Math.max数组(…) ）
下面的脚本在ndoejs中为我工作:
var numbers = [1, 2, 3, 4];
console.log('Value:: ' + Math.max.apply(null, numbers) ); // 4
我想分享一下我简单易懂的解决方案。
对于最小值:
var arr = [3， 4， 12， 1， 0， 5]; 是我的 = arr[0]; for （var k = 1; k < arr.length; k++） { if （arr[k] < min） { 分钟 = arr[k]; } } console.log（“我的冰淇淋：”+分钟）;
对于最大值:
Var arr = [3,4,12,1,0,5]; Var Max = arr[0]; For (var k = 1;K < arrr .length;k + +) { If (arr[k] > max) { Max = arr[k]; ｝ ｝ console.log("Max is: " + Max);
https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max
function getMaxOfArray（numArray） { 返回 Math.max.apply（null， numArray）; } var arr = [100， 0， 50]; console.log（getMaxOfArray（arr））
这对我很管用。
下面的代码为我工作:
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); });
找到数组元素的最小值的一个简单解决方案是使用数组原型函数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]);
这设置最小值为A[0]，然后检查A[1]…A[n]是否严格小于当前最小值。如果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 }
有两种方法更简单:
let arr = [2, 6, 1, 0]
方式1:
let max = Math.max.apply(null, arr)
方式2:
let max = arr.reduce(function(a, b) {
return Math.max(a, b);
});
替代方法
的数学。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毫秒。
这里还有一个例子。使用lodash从数组中计算Max/Min值。
let 数组 = [100， 0， 50]; var func = _.over（Math.max， Math.min）; var [max， min] = func（...阵列）; => [100， 0] 控制台.log（最大）; 控制台.log（分钟）; <script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js”></script>
let arr = [2,5,3,5,6,7,1];
let max = Math.max(...arr); // 7
let min = Math.min(...arr); // 1
Try
let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);
让max= a=> a.reduce((m,x)=> m>x ?m: x); 令min= a=> a.reduce((m,x)=> m<x ?m: x); // TEST -像素缓冲区 let arr =数组(200*800*4).fill(0); arr.forEach ((x, i) = > arr[我]= 100 -我% 101); console.log (Max,马克斯(arr)); console.log (Min, Min (arr))
对于数学。Min /max(+应用)我们得到错误:
超过最大调用堆栈大小(Chrome 74.0.3729.131)
// TEST -像素缓冲区 let arr =数组(200*800*4).fill(0); arr.forEach ((x, i) = > arr[我]= 100 -我% 101); // Exception:超过最大调用堆栈大小 尝试{ 让max1= Math.max(…arr) } catch(e) {console.error('Math. error ')Max:'， e.message)} 尝试{ let max2= Math.max。应用(null, arr); } catch(e) {console.error('Math.max. error ')应用:'，e.message)} // min相同
下面是一个简单的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;
}
这个问题的递归解
const findMinMax = (arr, max, min, i) => arr。长度=== I ?｛ 分钟, 马克斯 }: findMinMax ( 加勒比海盗, r[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);
您可以使用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
除了使用数学函数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]
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]; 令maximum = array。排序((a, b) => b - a)[0]; 令minimum = array。排序((a, b) => a - b)[0]; console.log(最小值,最大值)
对于包含对象而不是数字的数组:
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 }
对于一个简洁的现代解决方案，可以对数组执行reduce操作，跟踪当前的最小值和最大值，因此数组只迭代一次(这是最优的)。为了简洁起见，这里使用了解构赋值。
Let array = [100, 0, 50]; Let [min, max] =数组。减少(((prevMin prevMax],咕咕叫)= > (数学。min(prevMin, curr)，数学。max(prevMax, curr)]，[∞，-∞]); console.log(“分钟:分钟); console.log(“马克斯:Max);
为了只找到最小值或最大值，我们可以以大致相同的方式使用执行reduce操作，但我们只需要跟踪之前的最优值。这种方法比使用apply更好，因为当数组对堆栈来说太大时，它不会导致错误。
Const arr = [- 1,9,3， - 6,35]; //只找到最小值 const min = arr.reduce((a,b)=>Math.min(a,b)，无穷大); console.log(“分钟:Min); / / 6 //只找到最大值 const max = arr.reduce((a,b)=>Math.max(a,b)， -无穷大); console.log(“马克斯:Max); / / 35
我想用下面的方式来做这件事
const findMaxAndMin = (arr) => {
if (arr.length <= 0) return -1;
let min = arr[0];
let max = arr[0];
arr.forEach((n) => {
n > max ? (max = n) : false;
n < min ? (min = n) : false;
});
return [min, max];
};
另一个解决方案
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}`)
替代溶液
class SmallestIntegerFinder {
findSmallestInt(args) {
return args.reduce((min,item)=>{ return (min<item ? min : item)});
}
}
class SmallestIntegerFinder {
findSmallestInt(args) {
return Math.min(...args)
}
}
class SmallestIntegerFinder {
findSmallestInt(args) {
return Math.min.apply(null, args);
}
}
class SmallestIntegerFinder {
findSmallestInt(args) {
args.sort(function(a, b) {
return a - b; } )
return args[0];
}
}
出于学习目的，你可以使用变量和For循环，而不使用内置函数。
// Input sample data to the function var arr = [-1, 0, 3, 100, 99, 2, 99]; // Just to show the result console.log(findMinMax(arr)); function findMinMax(arr) { let arraySize = arr.length; if (arraySize > 0) { var MaxNumber = MinNumber = arr[0]; for (var i = 0; i <= arraySize; i++) { if (arr[i] > MaxNumber) { MaxNumber = arr[i]; }else if(arr[i] < MinNumber) { MinNumber = arr[i]; } } var minMax = [MinNumber,MaxNumber]; return minMax; } else { return 0; } }
这里有很多不错的答案，下面是一个typescript版本，可以处理一些值未定义的列表。
如何使用:
const testDates = [
undefined,
new Date('July 30, 1986'),
new Date('July 31, 1986'),
new Date('August 1, 1986'),
]
const max: Date|undefined = arrayMax(testDates); // Fri Aug 01 1986
const min: Date|undefined = arrayMin(testDates); // Min: Wed Jul 30 1986
const test: Date = arrayMin(testDates); // Static type error
const anotherTest: undefined = arrayMin(testDates); // Static type error
定义(notEmpty定义来自这篇文章):
function arrayMax<T>(values?: (T | null | undefined)[]): T | undefined {
const nonEmptyValues = filterEmpty(values);
if (nonEmptyValues.length === 0) {
return undefined;
}
return nonEmptyValues.reduce((a, b) => (a >= b ? a : b), nonEmptyValues[0]);
}
function arrayMin<T>(values?: (T | null | undefined)[]): T | undefined {
const nonEmptyValues = filterEmpty(values);
if (nonEmptyValues.length === 0) {
return undefined;
}
return nonEmptyValues.reduce((a, b) => (a <= b ? a : b), nonEmptyValues[0]);
}
function filterEmpty<T>(values?: (T | null | undefined)[] | null): T[] {
return values?.filter(notEmpty) ?? [];
}
function notEmpty<T>(value: T | null | undefined): value is T {
if (value === null || value === undefined) return false;
const testDummy: T = value;
return true;
}
我没有使用数学。max函数，正如文档中建议的那样，因为这样我就可以将这个函数与任何可比对象一起使用(如果你知道如何键入它，请告诉我，这样我就可以更好地定义T)。
在这个时代(2022年)，从数组中获得min + max的最有效方法是通过reduce在一次迭代中完成。
在JavaScript中:
const arr = [3, 0, -2, 5, 9, 4];
const i = arr.reduce((p, c) => {
p.min = c < p.min ? c : p.min ?? c;
p.max = c > p.max ? c : p.max ?? c;
return p;
}, {min: undefined, max: undefined});
console.log(i); //=> { min: -2, max: 9 }
当输入没有数据时，它将输出{min: undefined, max: undefined}。
在TypeScript中，你只需要添加类型强制转换，所以返回类型被推断为{min: number, max: number}，而不是{min: any, max: any}:
const arr = [3, 0, -2, 5, 9, 4];
const i = arr.reduce((p, c) => {
p.min = c < p.min ? c : p.min ?? c;
p.max = c > p.max ? c : p.max ?? c;
return p;
}, {min: undefined as number, max: undefined as number});
//=> {min: number, max: number}
console.log(i); //=> { min: -2, max: 9 }
更新
在kiran goud注释之后，这里有一个使用数组而不是对象的替代方法:
const i = arr.reduce((p, c) => {
p[0] = c < p[0] ? c : p[0] ?? c;
p[1] = c > p[1] ? c : p[1] ?? c;
return p;
}, [undefined, undefined]);
console.log(i); //=> [-2, 9]
