web-dev-qa-db-fra.com

Obtenir la plus petite valeur de array en Javascript?

Le tableau justPrices a des valeurs telles que:

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

Comment est-ce que je retourne la plus petite valeur du tableau?

javascriptarraysmin
48
lisovaccaro

Jon Resig a illustré dans cet article comment y parvenir en étendant le prototype Array et en invoquant la méthode sous-jacente Math.min qui ne prend malheureusement pas un tableau mais un nombre variable d'arguments

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

et alors:

var minimum = Array.min(array);
78
Darin Dimitrov

Le code le plus expressif pour trouver la valeur minimale est probablement paramètres de repos :

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

Les paramètres de repos sont 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 également un excellent cas d'utilisation pour 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, mais le rappel reçoit des paramètres supplémentaires:

callback (accumulator, currentValue, currentIndex, array)

Dans ce cas particulier, cela peut être un peu verbeux. reduce est particulièrement utile lorsque vous souhaitez agréger une collection de données complexes 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 une itération classique peut faire peau neuve:

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)

58
zzzzBov

Je trouve que le moyen le plus simple de renvoyer la plus petite valeur d'un tableau consiste à utiliser la fonction Spread Operator sur Math.min ().

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

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

Un petit extra: Cela fonctionne aussi sur la fonction Math.max ()

return Math.max (... justPrices); // renvoie 9.9 sur l'exemple donné.

J'espère que cela t'aides!

33
tdowek1

Mise à jour: utilisez la réponse de Darin's/John Resig, n'oubliez pas que vous n'avez pas besoin de spécifier thisArg pour min, donc Math.min.apply(null, arr) fonctionnera correctement.

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

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

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, également, tableau est modifié sur place , ce qui peut ne pas être ce que vous voulez. 

13
c69

Imaginez que vous avez ce tableau:

var arr = [1, 2, 3];

Façon ES6: 

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

Manière ES5: 

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

Si vous utilisez D3.js, il existe une fonction pratique qui fait de même, mais ignore les valeurs undefined et vérifie également l'ordre naturel:

d3.max (array [ accessor])

Retourne la valeur maximale dans le tableau donné en utilisant l'ordre naturel. Si le tableau est vide, renvoie non défini. Une fonction d'accesseur optionnelle peut être spécifié, ce qui équivaut à l'appel de array.map (accessor) avant de calculer la valeur maximale.

Contrairement à Math.max intégré, cette méthode ignore les valeurs indéfinies; c'est utile pour ignorer les données manquantes. De plus, les éléments sont comparé en utilisant l'ordre naturel plutôt que l'ordre numérique. Par exemple, le maximum des chaînes [“20”, “3”] est “3”, tandis que le maximum de les nombres [20, 3] sont 20.

Et voici le code source de 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;
}
6
Alireza

ES6 est la voie de l'avenir.

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

5
Aaron Joel Kison

Peut-être un moyen plus facile?

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

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

Utilisez le tri.

justPrices.sort();

Cela les mettrait ensuite en ordre pour vous. (Peut aussi être fait par ordre alphabétique.) Le tableau serait alors mis en ordre croissant.

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

Vous pouvez alors facilement saisir par le premier index.

justPrices[0]

Je trouve cela un peu plus utile que ce qui est proposé ci-dessus, car que se passe-t-il si vous avez besoin des 3 chiffres les plus bas comme exemple? Vous pouvez également changer l'ordre dans lequel ils sont arrangés, plus d'infos sur http://www.w3schools.com/jsref/jsref_sort.asp

2
Akexis
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);
2
suraj

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

1
user123456789

Je pense avoir une solution facile à comprendre, 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 dans le tableau (je suppose simplement que vous savez comment une boucle for fonctionne; sinon, recherchez-la). Si un élément du tableau est plus petit que la smallestNumber actuelle (qui est d'abord le premier élément), il remplacera sa valeur. Lorsque tout le tableau est passé par la boucle, smallestNumber contiendra le plus petit nombre du tableau.

0
Sara

Si vous utilisez Underscore ou Lodash, vous pouvez obtenir une 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
0
svarog

Voici le code qui détectera la valeur la plus basse dans un tableau de nombres.

//function for finding smallest value in an array
function arrayMin(array){
    var min = array[0];
    for(var i = 0; i < array.length; i++){
        if(min < array[i]){
            min = min;
        }else if (min > array[i]){
            min = array[i + 1];
        }else if (min == array[i]){
            min = min;
        }
    }
    return min;
};

appelez ça comme ça:

var fooArray = [1,10,5,2];
var foo = arrayMin(fooArray);

(Il suffit de remplacer le deuxième résultat else if par min = min par min = array[i] Si vous souhaitez que les nombres qui atteignent la plus petite valeur remplacent le nombre d'origine.)

0
Darrow Hartman