Obtenir la plus petite valeur du tableau en Javascript?

Le code le plus expressif pour trouver la valeur minimale est probablement rest parameters :

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

Les paramètres Rest sont essentiellement un raccourci pratique pour Function.prototype.apply lorsque vous n'avez pas besoin de changer le contexte de la fonction:

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

C'est aussi un excellent cas d'utilisation de Array.prototype.reduce:

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

, Il peut être tentant de passer Math.min directement à reduce, cependant la rappel reçoit des paramètres supplémentaires:

callback (accumulator, currentValue, currentIndex, array)

, Dans ce cas particulier, il peut être un peu verbeux. reduce est particulièrement utile lorsque vous avez une collection de données complexes que vous souhaitez agréger en une seule valeur:

const arr = [{name: 'Location 1', distance: 14}, {name: 'Location 2', distance: 58}, {name: 'Location 3', distance: 20}, {name: 'Location 4', distance: 77}, {name: 'Location 5', distance: 66}, {name: 'Location 6', distance: 82}, {name: 'Location 7', distance: 42}, {name: 'Location 8', distance: 67}, {name: 'Location 9', distance: 42}, {name: 'Location 10', distance: 4}]
const closest = arr.reduce(
  (acc, loc) =>
    acc.distance < loc.distance
      ? acc
      : loc
)
console.log(closest)

Et bien sûr, vous pouvez toujours utiliser l'itération classique:

var arr,
  i,
  l,
  min

arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
min = Number.POSITIVE_INFINITY
for (i = 0, l = arr.length; i < l; i++) {
  min = Math.min(min, arr[i])
}
console.log(min)

...mais même l'itération classique peut obtenir une cure de jouvence moderne:

const arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
let min = Number.POSITIVE_INFINITY
for (const value of arr) {
  min = Math.min(min, value)
}
console.log(min)

Je trouve que le moyen le plus simple de retourner la plus petite valeur d'un tableau est d'utiliser L'opérateur Spread en mathématiques.fonction min ().

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

La page sur MDN aide à mieux la comprendre: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min

Un peu plus: Cela fonctionne également sur les mathématiques.max () fonction

Retourner Les Mathématiques.Max(...justPrices); //retourne 9.9 sur l'exemple donné.

Espérons que cela aide!

Update: Utilisez la réponse de Darin / John Resig, gardez juste à l'esprit que vous n'avez pas besoin de spécifier thisArg pour min, donc Math.min.apply(null, arr) fonctionnera très bien.

Ou vous pouvez simplement trier le tableau et obtenir la valeur # 1: [2,6,7,4,1].sort()[0]

[!] Mais sans fournir la fonction de tri des numéros personnalisés, cela ne fonctionnera que dans un cas très limité: nombres positifs inférieurs à 10 . Voyez comment ça casserait:

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]

Et tableau est modifié en place-, ce qui pourrait ne pas être ce que vous voulez.

, Imaginez que vous avez ce tableau:

var arr = [1, 2, 3];

ES6 façon:

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

ES5 façon:

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

Si vous utilisez D3.js, il y a une fonction pratique qui fait la même chose, mais ignorera undefined valeurs et vérifiera également l'ordre naturel:

D3.max (tableau [, accesseur])

Renvoie la valeur maximale dans le tableau donné en utilisant l'ordre naturel. Si le tableau est vide, renvoie undefined. Une fonction d'accesseur en option peut être spécifié, ce qui est équivalent à un tableau appelant.carte(accesseur) avant de calculer la valeur maximale.

Contrairement aux mathématiques intégrées.max, cette méthode ignore les valeurs non définies; ceci est utile pour ignorer les données manquantes. En outre, les éléments sont comparé en utilisant l'ordre naturel plutôt que l'ordre numérique. Exemple, le maximum des chaînes ["20", "3"] est "3", tandis que le maximum de les nombres [20, 3] est 20.

Et c'est le code source pour 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 est la voie du futur.

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

Je préfère ce formulaire car il est facilement généralisé pour d'autres cas d'utilisation

Peut-être un moyen plus facile?

Disons que justPrices est mélangé en termes de valeur, donc vous ne savez pas où est la plus petite valeur.

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

Utiliser le tri.

justPrices.sort();

Il les mettrait alors en ordre pour vous. (Peut également être fait par ordre alphabétique.) Le tableau serait alors placé dans l'ordre croissant.

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

Vous pouvez ensuite facilement saisir par le premier index.

justPrices[0]

Je trouve que c'est un peu plus utile que ce qui est proposé ci-dessus parce que si vous avez besoin des 3 numéros les plus bas comme un exemple? Vous pouvez également changer l'ordre dans lequel ils sont disposés, plus d'informations à 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]<minvalue)
    {
        minvalue = array[i];
    }

}
  console.log(minvalue);

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

Si vous utilisez Underscore ou Lodash, vous pouvez obtenir la valeur minimale en utilisant ce type de pipeline fonctionnel simple

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

Vous avez également la fonction .min

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

Je pense avoir une solution facile à comprendre pour cela, en utilisant uniquement les bases de 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 variable smallestNumber est définie sur le premier élément de justPrices, et la boucle for boucle le tableau (je suppose juste que vous savez comment fonctionne une boucle for; sinon, recherchez-la). Si un élément du tableau est plus petit que le courant smallestNumber (qui est d'abord le premier élément), il remplacera sa valeur. Lorsque le tableau entier est passé par la boucle, smallestNumber contiendra le plus petit nombre dans le tableau.