Ottieni il valore più piccolo dalla matrice in Javascript?

Array justPrices ha valori come:

[0] = 1.5 [1] = 4.5 [2] = 9.9. 

Come posso restituire il valore più piccolo nella matrice?

Jon Resig ha illustrato in questo articolo come ottenere questo risultato estendendo il prototipo di Array e invocando il sottostante metodo Math.min che sfortunatamente non richiede un array ma un numero variabile di argomenti:

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

e poi:

 var minimum = Array.min(array); 

Il codice espressivo più teso per trovare il valore minimo è probabilmente parametri di rest :

 const arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4] const min = Math.min(...arr) console.log(min) 

Trovo che il modo più semplice per restituire il valore più piccolo di un array consiste nell’utilizzare la funzione Spread Operator su Math.min ().

 return Math.min(...justPrices); //returns 1.5 on example given 

Aggiornamento: usa la risposta di Darin / John Resig, tieni a mente che non hai bisogno di specificare thisArg per min , quindi Math.min.apply(null, arr) funzionerà perfettamente.


oppure puoi semplicemente ordinare l’array e ottenere il valore # 1: [2,6,7,4,1].sort()[0]

[!] Ma senza fornire la funzione di ordinamento numerico personalizzato, questo funzionerà solo in un caso molto limitato: numeri positivi inferiori a 10 . Guarda come si romperà:

 var a = ['', -0.1, -2, -Infinity, Infinity, 0, 0.01, 2, 2.0, 2.01, 11, 1, 1e-10, NaN]; // correct: a.sort( function (a,b) { return a === b ? 0 : a < b ? -1: 1} ); //Array [NaN, -Infinity, -2, -0.1, 0, "", 1e-10, 0.01, 1, 2, 2, 2.01, 11, Infinity] // incorrect: a.sort(); //Array ["", -0.1, -2, -Infinity, 0, 0.01, 1, 11, 1e-10, 2, 2, 2.01, Infinity, NaN] 

Inoltre, la matrice viene modificata sul posto , il che potrebbe non essere quello che desideri.

Immagina di avere questo array:

 var arr = [1, 2, 3]; 

Modo ES6:

 var min = Math.min(...arr); //min=1 

Modo ES5:

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

Se usi D3.js, c’è una comoda funzione che fa lo stesso, ma ignorerà i valori non definiti e controllerà anche l’ordine naturale:

d3.max (array [, accessor])

Restituisce il valore massimo nell’array specificato utilizzando l’ordine naturale. Se la matrice è vuota, restituisce undefined. Può essere specificata una funzione accessoria opzionale, che equivale a chiamare array.map (accessor) prima di calcolare il valore massimo.

A differenza del Math.max integrato, questo metodo ignora i valori non definiti; questo è utile per ignorare i dati mancanti. Inoltre, gli elementi vengono confrontati utilizzando l’ordine naturale anziché l’ordine numerico. Ad esempio, il massimo delle stringhe [“20”, “3”] è “3”, mentre il massimo dei numeri [20, 3] è 20.

E questo è il codice sorgente per D3 v4:

 export default function(values, valueof) { var n = values.length, i = -1, value, max; if (valueof == null) { while (++i < n) { // Find the first comparable value. if ((value = values[i]) != null && value >= value) { max = value; while (++i < n) { // Compare the remaining values. if ((value = values[i]) != null && value > max) { max = value; } } } } } else { while (++i < n) { // Find the first comparable value. if ((value = valueof(values[i], i, values)) != null && value >= value) { max = value; while (++i < n) { // Compare the remaining values. if ((value = valueof(values[i], i, values)) != null && value > max) { max = value; } } } } } return max; } 

ES6 è la via del futuro.

 arr.reduce((a, b) => Math.min(a, b)); 

Preferisco questo modulo perché è facilmente generalizzabile per altri casi d’uso

Forse un modo più semplice?

Diciamo che justPrices è confuso in termini di valore, quindi non si sa dove sia il valore più piccolo.

 justPrices[0] = 4.5 justPrices[1] = 9.9 justPrices[2] = 1.5 

Usa ordinamento.

 justPrices.sort(); 

Quindi li metterebbe in ordine per te. (Può anche essere fatto in ordine alfabetico.) L’array verrà quindi messo in ordine crescente.

 justPrices[0] = 1.5 justPrices[1] = 4.5 justPrices[2] = 9.9 

Puoi quindi facilmente afferrare il primo indice.

 justPrices[0] 

Trovo che questo sia un po ‘più utile di quanto proposto sopra, e se fosse necessario avere i 3 numeri più bassi come esempio? Puoi anche cambiare l’ordine in cui sono organizzati, maggiori informazioni su http://www.w3schools.com/jsref/jsref_sort.asp

 var array =[2,3,1,9,8]; var minvalue = array[0]; for (var i = 0; i < array.length; i++) { if(array[i] 
 function smallest(){ if(arguments[0] instanceof Array) arguments = arguments[0]; return Math.min.apply( Math, arguments ); } function largest(){ if(arguments[0] instanceof Array) arguments = arguments[0]; return Math.max.apply( Math, arguments ); } var min = smallest(10, 11, 12, 13); var max = largest([10, 11, 12, 13]); console.log("Smallest: "+ min +", Largest: "+ max); 

Se stai usando Underscore o Lodash puoi ottenere il valore minimo usando questo tipo di semplice pipeline funzionale

 _.chain([7, 6, -1, 3, 2]).sortBy().first().value() // -1 

Hai anche la funzione .min

 _.min([7, 6, -1, 3, 2]) // -1 

Penso di avere una soluzione facile da capire per questo, usando solo le basi di javaScript.

 function myFunction() { var i = 0; var smallestNumber = justPrices[0]; for(i = 0; i < justPrices.length; i++) { if(justPrices[i] < smallestNumber) { smallestNumber = justPrices[i]; } } return smallestNumber; } 

La variabile justPrices è impostata sul primo elemento di justPrices e il ciclo for justPrices il loop attraverso l'array ( justPrices solo che tu sappia come funziona un ciclo for, in caso contrario, cerca in alto). Se un elemento dell'array è più piccolo del smallestNumber corrente (che in un primo momento è il primo elemento), sostituirà il suo valore. Quando l'intero array ha attraversato il ciclo, il numero più smallestNumber conterrà il numero più piccolo nell'array.