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

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

javascript

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

如何轻松获取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];

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