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

Antwoord 6, autoriteit 7%

Als je net als ik paranoïde bent over het gebruik van Math.max.apply (wat fouten kan veroorzaken bij grote arrays volgens MDN), probeer dit:

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

Of, in 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));
}

De anonieme functies zijn helaas noodzakelijk (in plaats van Math.max.bind(Math) te gebruiken omdat reduce niet zomaar a doorgeeft en b naar zijn functie, maar ook i en een verwijzing naar de array zelf, dus we moeten ervoor zorgen dat we niet proberen max ook daarop.

Antwoord 7, autoriteit 5%

Alternatieve methoden

De Math.min en Math.max zijn geweldige methoden om het minimale en maximale item uit een verzameling items te halen, maar het is belangrijk om op de hoogte te zijn van enkele gaatjes die daarbij horen.

Als u ze gebruikt met een array die een groot aantal items bevat (meer dan ~10? items, hangt af van de browser van de gebruiker), zal hoogstwaarschijnlijk crasht en de volgende foutmelding verschijnen:

const arr = Array.from(Array(1000000).keys());
Math.min(arr);
Math.max(arr);

Uncaught RangeError: maximale call-stack-grootte overschreden

UPDATE
De nieuwste browsers kunnen in plaats daarvan NaN retourneren. Dat is misschien een betere manier om met fouten om te gaan, maar het lost het probleem nog niet op.

Overweeg in plaats daarvan iets als dit te gebruiken:

function maxValue(arr) {
  return arr.reduce((max, val) => max > val ? max : val)
}

Of met een betere looptijd:

function maxValue(arr) {
  let max = arr[0];
  for (let val of arr) {
    if (val > max) {
      max = val;
    }
  }
  return max;
}

Of om zowel Min als Max te krijgen:

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

Of met een nog betere runtime*:

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

* Getest met 1.000.000 items:
Ter referentie: de runtime van de eerste functie (op mijn computer) was 15,84 ms versus de tweede functie met slechts 4,32 ms.

Antwoord 8, autoriteit 4%

.apply wordt vaak gebruikt wanneer het de bedoeling is om een ​​variadische functie aan te roepen met een lijst met argumentwaarden, bijv.

De Math.max([value1[,value2, ...]]) functie retourneert de grootste van nul of meer getallen.

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

De Math.max() methode staat je niet toe om een ​​array door te geven. Als je een lijst met waarden hebt waarvan je de grootste moet krijgen, zou je deze functie normaal gesproken aanroepen met Function.prototype.apply(), bijv.

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

Vanaf de ECMAScript 6 kunt u echter de spread-operator:

Met de spread-operator kan een uitdrukking worden uitgebreid op plaatsen waar meerdere argumenten (voor functieaanroepen) of meerdere elementen (voor letterlijke arrays) worden verwacht.

Met behulp van de spread-operator kan het bovenstaande als zodanig worden herschreven:

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

Als je een functie aanroept met de variadische operator, kun je zelfs extra waarden toevoegen, bijvoorbeeld

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

Bonus:

Met de operator Spread kunt u de letterlijke syntaxis van arrays gebruiken om nieuwe arrays te maken in situaties waarin u in ES5 zou moeten terugvallen op imperatieve code, met behulp van een combinatie van push, splice, enz.

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

Antwoord 9, autoriteit 4%

Twee manieren zijn korter en gemakkelijk:

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

Manier 1:

let max = Math.max.apply(null, arr)

Manier 2:

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

Antwoord 10, autoriteit 2%

Je doet het door het array-type uit te breiden:

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

Boosted van hier (door John Resig)

Antwoord 11, autoriteit 2%

Een eenvoudige oplossing om de minimumwaarde over een Array van elementen te vinden, is door de Array prototypefunctie reduce te gebruiken:

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9

of met behulp van de ingebouwde Math.Min()-functie van JavaScript (bedankt @Tenflex):

A.reduce((min,val) => Math.min(min,val), A[0]);

Dit stelt min in op A[0] en controleert vervolgens op A[1]...A[n] of het is strikt minder dan de huidige min. Als A[i] < min en vervolgens wordt min geüpdatet naar A[i]. Als alle array-elementen zijn verwerkt, wordt min als resultaat geretourneerd.

EDIT: positie van minimumwaarde opnemen:

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 }

Antwoord 12, autoriteit 2%

Anderen hebben al enkele oplossingen gegeven waarin ze Array.prototype aanvullen. Het enige dat ik in dit antwoord wil, is verduidelijken of het Math.min.apply( Math, array ) of Math.min.apply( null, array ) moet zijn. Dus welke context moet worden gebruikt, Math of null?

Bij het doorgeven van null als context voor apply, dan zal de context standaard het globale object zijn (het window object in het geval van browsers). Het doorgeven van het object Math als context zou de juiste oplossing zijn, maar het kan ook geen kwaad om null door te geven. Hier is een voorbeeld wanneer null problemen kan veroorzaken bij het verfraaien van de functie 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);

Het bovenstaande veroorzaakt een uitzondering omdat this.foo wordt geëvalueerd als window.foo, wat undefined is. Als we null vervangen door Math, werken de dingen zoals verwacht en wordt de tekenreeks “foo” op het scherm afgedrukt (ik heb dit getest met Mozilla Rhino).

Je kunt er vrijwel van uitgaan dat niemand Math.max heeft versierd, dus het doorgeven van null zal zonder problemen werken.

Antwoord 13, autoriteit 2%

Nog een manier om het te doen:

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

Gebruik:

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

Antwoord 14, autoriteit 2%

Het verbaast me dat niemand de reduceerfunctie noemde.

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]

Antwoord 15

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

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

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

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

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

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

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

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

const nums = [12, 67, 58, 30].sort((x, y) => 
x -  y)
let min_val = nums[0]
let max_val = nums[nums.length -1]

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

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

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

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; 

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

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)