Come posso ottenere facilmente l'elemento minimo o massimo di un array JavaScript?

Esempio Psuedocode:

let array = [100, 0, 50]

array.min() //=> 0
array.max() //=> 100

Che ne dici di aumentare l'oggetto Array incorporato per usare Math.max/ Math.mininvece:

Array.prototype.max = function() {
  return Math.max.apply(null, this);
};

Array.prototype.min = function() {
  return Math.min.apply(null, this);
};

Ecco un JSFiddle .

Aumentare le built-in può causare collisioni con altre librerie (alcuni vedono), così si può essere più a suo agio con il proprio apply'ing Math.xxx()per l'array direttamente:

var min = Math.min.apply(null, arr),
    max = Math.max.apply(null, arr);

In alternativa, supponendo che il tuo browser supporti ECMAScript 6, puoi utilizzare l' operatore spread che funziona in modo simile al applymetodo:

var min = Math.min( ...arr ),
    max = Math.max( ...arr );

var max_of_array = Math.max.apply(Math, array);

Per una discussione completa, consultare: http://aaroncrane.co.uk/2008/11/javascript_max_api/

Per array di grandi dimensioni (~ 10⁷ elementi) Math.mined Math.maxentrambi producono il seguente errore in Node.js.

RangeError: dimensione massima dello stack di chiamate superata

Una soluzione più solida è quella di non aggiungere tutti gli elementi allo stack di chiamate, ma invece di passare un array:

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

Se sei preoccupato per la velocità, il seguente codice è ~ 3 volte più veloce Math.max.applyrispetto al mio computer. Vedi http://jsperf.com/min-and-max-in-array/2 .

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

Se le tue matrici contengono stringhe anziché numeri, devi anche forzarle in numeri. Il codice seguente lo fa, ma rallenta il codice ~ 10 volte sulla mia macchina. Vedi http://jsperf.com/min-and-max-in-array/3 .

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

Utilizzo dell'operatore spread (ES6)

Math.max(...array);  // the same with "min" => Math.min(...array);

const array = [10, 2, 33, 4, 5];

console.log(
  Math.max(...array)
)

tl; dr

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

Soluzione MDN

I documenti MDN ufficiali suMath.max() già trattano questo problema:

La seguente funzione utilizza Function.prototype.apply () per trovare l'elemento massimo in un array numerico. getMaxOfArray([1, 2, 3])è equivalente a Math.max(1, 2, 3), ma è possibile utilizzarlo getMaxOfArray()su array costruiti a livello di programmazione di qualsiasi dimensione.

function getMaxOfArray(numArray) {
    return Math.max.apply(null, numArray);
}

O con il nuovo operatore di diffusione , ottenere il massimo da un array diventa molto più semplice.

var arr = [1, 2, 3];
var max = Math.max(...arr);

Dimensione massima di un array

Secondo MDN le applysoluzioni e spread avevano una limitazione di 65536 che derivava dal limite del numero massimo di argomenti:

Ma attenzione: nell'uso di applicare in questo modo, si corre il rischio di superare il limite di lunghezza degli argomenti del motore JavaScript. Le conseguenze dell'applicazione di una funzione con troppi argomenti (si pensi a più di decine di migliaia di argomenti) variano a seconda dei motori ( JavaScriptCore ha un limite di argomenti hard-codificato di 65536 ), perché il limite (anzi persino la natura di uno stack eccessivamente grande comportamento) non è specificato. Alcuni motori genereranno un'eccezione. Più perniciosamente, altri limiteranno arbitrariamente il numero di argomenti effettivamente passati alla funzione applicata. Per illustrare quest'ultimo caso: se un tale motore avesse un limite di quattro argomenti (i limiti effettivi sono ovviamente significativamente più alti), sarebbe come se gli argomenti 5, 6, 2, 3 fossero stati passati per applicarsi negli esempi precedenti, piuttosto che l'array completo.

Forniscono persino una soluzione ibrida che in realtà non ha buone prestazioni rispetto ad altre soluzioni. Vedi il test delle prestazioni di seguito per ulteriori informazioni.

Nel 2019 il limite effettivo è la dimensione massima dello stack di chiamate . Per i moderni browser desktop basati su Chromium ciò significa che quando si tratta di trovare min / max con applyo diffondere, praticamente la dimensione massima per i numeri solo array è ~ 120000 . Al di sopra di questo, ci sarà un overflow dello stack e verrà generato il seguente errore:

RangeError: dimensione massima dello stack di chiamate superata

Con lo script seguente (basato su questo post del blog ), rilevando tale errore puoi calcolare il limite per il tuo ambiente specifico.

Avvertimento! L'esecuzione di questo script richiede tempo e, a seconda delle prestazioni del sistema, potrebbe rallentare o bloccare il browser / sistema!

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

Prestazioni su array di grandi dimensioni

Sulla base del test nel commento di EscapeNetscape ho creato alcuni parametri di riferimento che testano 5 metodi diversi su un array solo di numeri casuali con 100000 articoli .

Nel 2019, i risultati mostrano che il loop standard (che BTW non ha limiti di dimensione) è il più veloce ovunque. applye la diffusione lo segue da vicino, quindi molto più tardi la soluzione ibrida di MDN e quindi reducela più lenta.

Quasi tutti i test hanno dato gli stessi risultati, tranne uno in cui la diffusione è risultata essere la più lenta.

Se si aumenta l'array per avere 1 milione di elementi, le cose iniziano a rompersi e si rimane con il loop standard come soluzione rapida e reducecome più lenta.

Benchmark JSPerf

Benchmark JSBen

Benchmark JSBench.me

Codice sorgente benchmark

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

Se sei paranoico come me sull'utilizzo Math.max.apply(che potrebbe causare errori quando vengono dati array di grandi dimensioni secondo MDN ), prova questo:

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

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

Le funzioni anonime sono purtroppo necessarie (invece di usare Math.max.bind(Math)perché reducenon solo passa ae balla sua funzione, ma anche ie un riferimento all'array stesso, quindi dobbiamo assicurarci di non provare a richiamare anche maxquelle.

.apply viene spesso utilizzato quando si intende invocare una funzione variadica con un elenco di valori argomento, ad es

La Math.max([value1[,value2, ...]])funzione restituisce il massimo di zero o più numeri.

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

Il Math.max()metodo non consente di passare in un array. Se hai un elenco di valori di cui hai bisogno per ottenere il massimo, normalmente chiameresti questa funzione usando Function.prototype.apply () , ad es.

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

Tuttavia, a partire da ECMAScript 6 è possibile utilizzare l' operatore spread :

L'operatore spread consente di espandere un'espressione in punti in cui sono previsti più argomenti (per chiamate di funzione) o più elementi (per valori letterali di array).

Utilizzando l'operatore spread, quanto sopra può essere riscritto come tale:

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

Quando si chiama una funzione utilizzando l'operatore variadic, è anche possibile aggiungere valori aggiuntivi, ad es

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

Bonus:

Operatore di diffusione consente di utilizzare la sintassi letterale array per creare nuovi array in situazioni in cui in ES5 si avrebbe bisogno di ripiegare in codice imperativo, utilizzando una combinazione di push, spliceecc

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

Due modi sono più brevi e facili:

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

Modo 1 :

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

Modo 2 :

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

Lo fai estendendo il tipo di array:

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

Potenziato da qui (di John Resig)

Una soluzione semplice per trovare il valore minimo su uno Arraydegli elementi è utilizzare la Arrayfunzione prototipo reduce:

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

o usando la funzione Math.Min () integrata di JavaScript (grazie a @Tenflex):

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

Questo imposta minsu A[0]e quindi verifica A[1]...A[n]se è strettamente inferiore alla corrente min. Se A[i] < minquindi minviene aggiornato a A[i]. Quando tutti gli elementi dell'array sono stati elaborati, minviene restituito come risultato.

EDIT : include posizione di valore minimo:

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 }

Altri hanno già fornito alcune soluzioni in cui aumentano Array.prototype. Tutto ciò che voglio in questa risposta è chiarire se dovrebbe essere Math.min.apply( Math, array )o Math.min.apply( null, array ). Quindi quale contesto dovrebbe essere usato Matho null?

Quando si passa nullcome contesto a apply, il contesto verrà automaticamente impostato sull'oggetto globale (l' windowoggetto nel caso dei browser). Passare l' Mathoggetto come contesto sarebbe la soluzione corretta, ma non danneggerà nullneanche il passaggio . Ecco un esempio quando nullpotrebbe causare problemi, quando si decora la Math.maxfunzione:

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

Quanto sopra genererà un'eccezione perché this.fooverrà valutata come window.foo, ovvero undefined. Se sostituiamo nullcon Math, le cose funzioneranno come previsto e la stringa "pippo" verrà stampato sullo schermo (Ho provato questo utilizzando Mozilla Rhino ).

Puoi praticamente supporre che nessuno abbia decorato Math.maxcosì, il passaggio nullfunzionerà senza problemi.

Un altro modo per farlo:

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

Uso:

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

Metodi alternativi

I metodi Math.mine Math.maxsono entrambe operazioni ricorsive che vengono aggiunte allo stack di chiamate del motore JS e molto probabilmente si arrestano in modo anomalo per un array che contiene un numero elevato di elementi
(più di ~ 10⁷ elementi, dipende dal browser dell'utente).

Math.max (... Array (1000000) .keys ());

Errore intervallo non rilevato: dimensione massima dello stack di chiamate superata

Invece, usa qualcosa del genere:

arr.reduce((max, val) => max > val ? max : val, arr[0])

O con un tempo di esecuzione migliore:

function maxValue(arr) {
  let max = arr[0];

  for (let val of arr) {
    if (val > max) {
      max = val;
    }
  }
  return max;
}

O per ottenere sia Min che 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] });
}

O con un runtime ancora migliore *:

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

* Testato con 1.000.000 di articoli:
solo per riferimento, il tempo di esecuzione della 1a funzione (sulla mia macchina) era di 15,84 ms contro la 2a funzione con solo 4,32 ms.

Questo può soddisfare i tuoi scopi.

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

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

questo ha funzionato per me.

Sono sorpreso che nessuno abbia menzionato la funzione di riduzione.

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]

Per array di grandi dimensioni (~ 10⁷ elementi) Math.mine Math.maxgenera un RangeError (dimensione massima dello stack di chiamate superata) in node.js.

Per array di grandi dimensioni, una soluzione rapida e sporca è:

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

Ho avuto lo stesso problema, avevo bisogno di ottenere i valori minimo e massimo di un array e, con mia sorpresa, non c'erano funzioni incorporate per gli array. Dopo aver letto molto, ho deciso di provare personalmente le "prime 3" soluzioni:

1. soluzione discreta: un ciclo FOR per verificare ogni elemento dell'array rispetto al valore massimo e / o minimo corrente;
2. Soluzione APPLY: invio dell'array alle funzioni interne di Math.max e / o Math.min mediante apply (null, array);
3. Soluzione REDUCE: ricorrere a un controllo su ogni elemento dell'array usando la funzione di riduzione ().

Il codice di test era questo:

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

L'array A è stato riempito con 100.000 numeri interi casuali, ogni funzione è stata eseguita 10.000 volte su Mozilla Firefox 28.0 su un desktop Intel Pentium 4 2.99GHz con Windows Vista. I tempi sono in secondi, recuperati dalla funzione performance.now (). I risultati furono questi, con 3 cifre frazionarie e deviazione standard:

1. Soluzione discreta: media = 0,161 s, sd = 0,078
2. APPLICARE la soluzione: media = 3.571s, sd = 0.487
3. Ridurre la soluzione: media = 0,350 s, sd = 0,044

La soluzione REDUCE era più lenta del 117% rispetto alla soluzione discreta. La soluzione APPLY era la peggiore, il 2,118% più lenta della soluzione discreta. Inoltre, come osservato da Peter, non funziona per array di grandi dimensioni (circa più di 1.000.000 di elementi).

Inoltre, per completare i test, ho testato questo codice esteso esteso:

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

Il tempismo: media = 0,218 s, sd = 0,094

Pertanto, è più lento del 35% rispetto alla semplice soluzione discreta, ma recupera contemporaneamente i valori massimo e minimo (qualsiasi altra soluzione richiederebbe almeno il doppio di quella per recuperarli). Una volta che l'OP aveva bisogno di entrambi i valori, la soluzione discreta sarebbe stata la scelta migliore (anche se due funzioni separate, una per il calcolo del massimo e un'altra per il calcolo del minimo, avrebbero sovraperformato la seconda migliore, la soluzione REDUCE).

È possibile utilizzare la seguente funzione in qualsiasi punto del progetto:

function getMin(array){
    return Math.min.apply(Math,array);
}

function getMax(array){
    return Math.max.apply(Math,array);
}

E quindi puoi chiamare le funzioni passando l'array:

var myArray = [1,2,3,4,5,6,7];
var maximo = getMax(myArray); //return the highest number

Il seguente codice funziona per me:

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

Scorri, tenendo traccia di ciò che procedi.

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

Ciò lascerà null min / max se non ci sono elementi nell'array. Imposta min e max in un passaggio se l'array ha degli elementi.

È inoltre possibile estendere la matrice con un rangemetodo utilizzando quanto sopra per consentire il riutilizzo e migliorare la leggibilità. Guarda un violino funzionante su 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 }
};

Usato come

var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];

var range = arr.range();

console.log(range.min);
console.log(range.max);

Ho pensato di condividere la mia soluzione semplice e di facile comprensione.

Per il minimo:

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

E per il massimo:

var arr = [3, 4, 12, 1, 0, 5];
var max = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] > max) {
    max = arr[k];
  }
}
console.log("Max is: " + max);

Roba semplice, davvero.

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

Ecco un modo per ottenere il valore massimo da una matrice di oggetti. Crea una copia (con slice), quindi ordina la copia in ordine decrescente e prendi il primo oggetto.

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; 

Utilizzando Math.max()oMath.min()

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

La seguente funzione utilizza Function.prototype.apply()per trovare l'elemento massimo in un array numerico. getMaxOfArray([1, 2, 3])è equivalente a Math.max(1, 2, 3), ma è possibile utilizzarlo getMaxOfArray()su array costruiti a livello di programmazione di qualsiasi dimensione.

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

O con il nuovo operatore di diffusione, ottenere il massimo da un array diventa molto più semplice.

var arr = [1, 2, 3];
var max = Math.max(...arr); // 3
var min = Math.min(...arr); // 1

Oltre a utilizzare la funzione matematica max e min, un'altra funzione da utilizzare è la funzione integrata di sort (): eccoci

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

La soluzione di ChaosPandion funziona se stai usando il protoipo. In caso contrario, considerare questo:

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

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

Quanto sopra restituirà NaN se un valore di array non è un numero intero, quindi è necessario creare alcune funzionalità per evitarlo. Altrimenti funzionerà.

Se usi la libreria sugar.js , puoi scrivere arr.min () e arr.max () come suggerisci. È inoltre possibile ottenere valori min e max da matrici non numeriche.

min (map, all = false) Restituisce l'elemento nella matrice con il valore più basso. map può essere una funzione che mappa il valore da verificare o una stringa che funge da collegamento. Se tutto è vero, restituirà tutti i valori minimi in un array.

max (map, all = false) Restituisce l'elemento nella matrice con il valore più grande. map può essere una funzione che mappa il valore da verificare o una stringa che funge da collegamento. Se tutto è vero, restituirà tutti i valori massimi in un array.

Esempi:

[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"]

Le librerie come Lo-Dash e underscore.js offrono anche potenti funzioni min e max simili:

Esempio da 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 }

let arr = [2,5,3,5,6,7,1];

let max = Math.max(...arr); // 7
let min = Math.min(...arr); // 1

Provare

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

console.log('Max', max(arr));
console.log('Min', min(arr))

Per Math.min / max (+ apply) viene visualizzato l'errore:

Dimensione massima dello stack di chiamate superata (Chrome 74.0.3729.131)

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

// Exception: Maximum call stack size exceeded

try {
  let max1= Math.max(...arr);          
} catch(e) { console.error('Math.max :', e.message) }

try {
  let max2= Math.max.apply(null, arr); 
} catch(e) { console.error('Math.max.apply :', e.message) }


// same for min