在JavaScript中查找数组的最小/最大元素
如何轻松获取JavaScript数组的min或max元素 伪代码示例:在JavaScript中查找数组的最小/最大元素,javascript,Javascript,如何轻松获取JavaScript数组的min或max元素 伪代码示例: 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];
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;
}
Array.prototype.min=函数(比较器){
if(this.length==0)返回null;
如果(this.length==1)返回此[0];
比较器=(比较器| | Math.min);
var v=该[0];
对于(var i=1;i
如何扩展内置数组对象以使用/替代:
这里有一个
扩充内置函数可能会导致与其他库发生冲突(请参阅一些库),因此您可能更习惯于直接将应用数学.xxx()
应用于阵列:
var min = Math.min.apply(null, arr),
max = Math.max.apply(null, arr);
或者,假设您的浏览器支持ECMAScript 6,您可以使用类似于apply
方法的which函数:
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 );
用作
var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];
var range = arr.range();
console.log(range.min);
console.log(range.max);
如果您使用的是Prototype,则Chaosption的解决方案有效。如果不是,考虑一下:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
如果数组值不是整数,则上述函数将返回NaN,因此您应该构建一些功能来避免这种情况。否则这将起作用。您可以通过扩展数组类型来实现:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
受(John Resig)的推动其他人已经给出了一些解决方案,在这些解决方案中,他们扩展了数组。prototype
。在这个答案中,我只想澄清它应该是Math.min.apply(Math,array)
还是Math.min.apply(null,array)
那么应该使用什么上下文,Math
或null
?
当将null
作为上下文传递给apply
时,上下文将默认为全局对象(浏览器中的窗口
对象)。将Math
对象作为上下文传递是正确的解决方案,但传递null
也不会有什么坏处。下面是一个示例,当装饰Math.max
函数时,null
可能会导致问题:
// 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);
//修饰Math.max
(功能(oldMax){
Math.max=函数(){
this.foo();//调用Math.foo,或者至少这是我们想要的
返回oldMax.apply(这是参数);
};
})(数学max);
Math.foo=函数(){
印刷品(“foo”);
};
Array.prototype.max=函数(){
返回Math.max.apply(null,this);//
有关详细讨论,请参阅:
对于大型阵列(~10⁷ 元素),Math.min
和Math.max
在node.js中产生范围错误(超过最大调用堆栈大小)
对于大型阵列,快速脏的解决方案是:
Array.prototype.min = function() {
var r = this[0];
this.forEach(function(v,i,a){if (v<r) r=v;});
return r;
};
Array.prototype.min=function(){
var r=该[0];
这个.forEach(函数(v,i,a){if(v
var arrayMax = Function.prototype.apply.bind(Math.max, null);
用法:
var max = arrayMax([2, 5, 1]);
对于大型阵列(~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 );
});
}
如果数组中包含字符串而不是数字,则还需要将它们强制转换为数字。下面的代码可以做到这一点,但在我的计算机上,它会将代码速度降低约10倍。请参阅
函数arrayMin(arr){
var len=阵列长度,最小值=无穷大;
而(len--){
if(数量(arr[len])max){
最大值=数量(arr[len]);
}
}
返回最大值;
};
我很惊讶没有人提到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]
这里有一种从对象数组中获取最大值的方法。创建一个副本(使用slice),然后按降序对副本排序并获取第一项
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;
我也遇到了同样的问题,我需要获得数组的最小值和最大值,令我惊讶的是,数组没有内置函数。在阅读了大量内容后,我决定亲自测试“前3个”解决方案:
离散解决方案:一个FOR循环,用于根据当前最大值和/或最小值检查阵列的每个元素
应用解决方案:使用应用(null,数组)将数组发送到Math.max和/或Math.min内部函数
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;
});
}
函数GetMaxDISCRETE(A)
{var MaxX=A[0];
对于(var X=0;X,您可以在项目中的任何位置使用以下函数:
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
通常用于使用参数值列表调用变量函数时,例如
Math.max(...[10, 20], 50); // 50
Math.max(...[-10, -20], 50); // 50
该函数返回零个或多个数字中的最大值
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
Math.max()
方法不允许您传入数组。如果您有一个需要获取最大值的值列表,您通常会使用调用此函数,例如
但是,从ECMAScript 6开始,您可以使用:
spread运算符允许在需要多个参数(用于函数调用)或多个元素(用于数组文本)的位置展开表达式
使用spread运算符,可以将上述内容改写为:
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
奖金:
Spread运算符使您能够在ES5中需要回退的情况下使用数组文字语法创建新数组
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());
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
Math.max.apply(null, [10, 20]); // 20
Math.max.apply(null, [-10, -20]); // -10
Math.max.apply(null, [-10, 20]); // 20
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
let foo = ['b', 'c'];
let bar = ['a', ...foo, 'd', 'e']; // ['a', 'b', 'c', 'd', 'e']
function getMaxOfArray(numArray) {
return Math.max.apply(null, numArray);
}
var arr = [1, 2, 3];
var max = Math.max(...arr);
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);
});
}
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(10, 20); // 20
Math.min(-10, -20); // -20
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
Math.max(...array); // the same with "min" => Math.min(...array);
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); });
A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9
A.reduce((min,val) => Math.min(min,val), A[0]);
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]
let max = Math.max.apply(null, arr)
let max = arr.reduce(function(a, b) {
return Math.max(a, b);
});
const arr = Array.from(Array(1000000).keys());
Math.min(arr);
Math.max(arr);
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 };
}
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];