Comment puis-je trouver le plus grand nombre contenu dans un tableau JavaScript?

J'ai un simple objet JavaScript Array contenant quelques chiffres.

[267, 306, 108]

Y a-t-il une fonction qui trouverait le plus grand nombre dans ce tableau?

Resig à la rescousse:

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

avertissement : puisque le nombre maximum d'arguments est aussi bas que 65535 sur certaines machines virtuelles , utilisez une boucle for si vous n'êtes pas certain que le tableau est si petit.

Vous pouvez utiliser la fonction apply, pour appeler Math.max :

var array = [267, 306, 108];
var largest = Math.max.apply(Math, array); // 306

Comment ça fonctionne?

La demande fonction est utilisée pour appeler une autre fonction, avec un contexte et des arguments donnés, fournis sous forme de tableau. Les fonctions min et max peuvent prendre un nombre arbitraire d'arguments d'entrée: Math.max (val1, val2, ..., valN)

Donc, si nous appelons:

Math.min.apply(Math, [1,2,3,4]);

La fonction d'application exécutera:

Math.min(1,2,3,4);

Notez que le premier paramètre, le contexte, n'est pas important pour ces fonctions car elles sont statiques, elles fonctionneront indépendamment de ce qui est passé en tant que contexte.

La syntaxe la plus simple, avec le nouvel opérateur d'étalement :

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

Source: Mozilla MDN

Je ne suis pas un expert JS, mais je voulais voir comment ces méthodes s'empilent, donc c'était une bonne pratique pour moi. Je ne sais pas si c'est techniquement la bonne façon de tester ces performances, mais je les ai juste exécutées l'une après l'autre, comme vous pouvez le voir dans mon code.

Le tri et l'obtention de la valeur 0 est de loin la pire méthode (et cela modifie l'ordre de votre tableau, ce qui n'est peut-être pas souhaitable). Pour les autres, la différence est négligeable sauf si vous parlez de millions d'indices.

Résultats moyens de cinq exécutions avec un tableau de 100 000 indices de nombres aléatoires:

• réduire a pris 4,0392 ms pour fonctionner
• Math.max.apply a mis 3,3742 ms pour s'exécuter
• le tri et l'obtention de la valeur 0 ont pris 67,4724 ms pour s'exécuter
• Math.max dans Reduce () a pris 6,5804 ms pour s'exécuter
• la fonction findmax personnalisée a pris 1,6102 ms pour s'exécuter

var performance = window.performance

function findmax(array)
{
  var max = 0,
      a = array.length,
      counter

  for (counter=0;counter<a;counter++)
  {
      if (array[counter] > max)
      {
          max = array[counter]
      }
  }
  return max
}

function findBiggestNumber(num) {
  var counts = []
  var i
  for (i = 0; i < num; i++) {
    counts.push(Math.random())
  }

  var a, b

  a = performance.now()
  var biggest = counts.reduce(function(highest, count){
        return highest > count ? highest : count
      }, 0)
  b = performance.now()
  console.log('reduce took ' + (b - a) + ' ms to run')

  a = performance.now()
  var biggest2 = Math.max.apply(Math, counts)
  b = performance.now()
  console.log('Math.max.apply took ' + (b - a) + ' ms to run')

  a = performance.now()
  var biggest3 = counts.sort(function(a,b){return b-a;})[0]
  b = performance.now()
  console.log('sorting and getting the 0th value took ' + (b - a) + ' ms to run')

  a = performance.now()
  var biggest4 = counts.reduce(function(highest, count){
        return Math.max(highest,count)
      }, 0)
  b = performance.now()
  console.log('Math.max within reduce() took ' + (b - a) + ' ms to run')

  a = performance.now()
  var biggest5 = findmax(counts)
  b = performance.now()
  console.log('custom findmax function took ' + (b - a) + ' ms to run')
  console.log(biggest + '-' + biggest2 + '-' + biggest3 + '-' + biggest4 + '-' + biggest5)

}

findBiggestNumber(1E5)

J'ai trouvé que pour les tableaux plus gros (~ 100k éléments), il est en fait payant de simplement itérer le tableau avec une humble forboucle, en effectuant environ 30% de mieux que Math.max.apply():

function mymax(a)
{
    var m = -Infinity, i = 0, n = a.length;

    for (; i != n; ++i) {
        if (a[i] > m) {
            m = a[i];
        }
    }

    return m;
}

Résultats de référence

Vous pouvez trier le tableau par ordre décroissant et obtenir le premier élément:

[267, 306, 108].sort(function(a,b){return b-a;})[0]

Que dis-tu de ça:

var arr = [1,2,3,4];

var largest = arr.reduce(function(x,y){
       return (x > y) ? x : y;
});

console.log(largest);

que diriez-vous d'utiliser Array.reduce ?

[0,1,2,3,4].reduce(function(previousValue, currentValue){
  return Math.max(previousValue,currentValue);
});

Presque toutes les réponses utilisent Math.max.apply()ce qui est agréable et dandy mais a des limites.

Les arguments de fonction sont placés sur une pile qui a un inconvénient - une limite. Donc, si votre tableau est plus grand que la limite, il échouera avecRangeError: Maximum call stack size exceeded.

Pour trouver une taille de pile d'appels, j'ai utilisé ce code:

var ar = [];
for (var i = 1; i < 100*99999; i++) {
  ar.push(1);
  try {
    var max = Math.max.apply(Math, ar);
  } catch(e) {
    console.log('Limit reached: '+i+' error is: '+e);
    break;
  }
}

Il s'est avéré être le plus grand sur FireFox sur ma machine - 591519 . Cela signifie que si votre tableau contient plus de 591519 éléments, Math.max.apply()cela entraînera RangeError .

La meilleure solution pour ce problème est la méthode itérative (crédit: https://developer.mozilla.org/ ):

max = -Infinity, min = +Infinity;

for (var i = 0; i < numbers.length; i++) {
  if (numbers[i] > max)
    max = numbers[i];
  if (numbers[i] < min)
    min = numbers[i];
}

J'ai écrit sur cette question sur mon blog ici .

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

const inputArray = [ 1, 3, 4, 9, 16, 2, 20, 18];
const maxNumber = Math.max(...inputArray);
console.log(maxNumber);

Trouver la valeur maximale et minimale de manière simple et manuelle. Ce code est beaucoup plus rapide que Math.max.apply; J'ai essayé jusqu'à 1000k nombres dans le tableau.

function findmax(array)
{
    var max = 0;
    var a = array.length;
    for (counter=0;counter<a;counter++)
    {
        if (array[counter] > max)
        {
            max = array[counter];
        }
    }
    return max;
}

function findmin(array)
{
    var min = array[0];
    var a = array.length;
    for (counter=0;counter<a;counter++)
    {
        if (array[counter] < min)
        {
            min = array[counter];
        }
    }
    return min;
}

Pour trouver le plus grand nombre dans un tableau que vous avez juste besoin d'utiliser Math.max(...arrayName);, cela fonctionne comme ceci:

let myArr = [1, 2, 3, 4, 5, 6];
console.log(Math.max(...myArr));

Pour en savoir plus sur Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Oui bien sûr existent: Math.max.apply(null,[23,45,67,-45]) et le résultat revient 67;

Doublure simple

[].sort().pop()

Ne pas oublier que l'emballage peut être fait avec Function.prototype.bind, vous donnant un « tout-native » fonction .

var aMax = Math.max.apply.bind(Math.max, Math);
aMax([1, 2, 3, 4, 5]); // 5

Vous pouvez également étendre Arraycette fonction et l'intégrer à chaque tableau.

Array.prototype.max = function(){return Math.max.apply( Math, this )};
myArray = [1,2,3];

console.log( myArray.max() );

Vous pouvez également utiliser forEach :

var maximum = Number.MIN_SAFE_INTEGER;

var array = [-3, -2, 217, 9, -8, 46];
array.forEach(function(value){
  if(value > maximum) {
    maximum = value;
  }
});

console.log(maximum); // 217

Utiliser - Array.prototype.reduce()c'est cool!

[267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val)

où acc = accumulateur et val = valeur actuelle ;

var a = [267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val);

console.log(a);

Vous pouvez essayer ça,

var arr = [267,306,108];
var largestNum = 0;
for(i=0;i<arr.length;i++) {
   if(arr[i]>largest){
    var largest = arr[i];
   }
}
console.log(largest);

Je viens de commencer avec JS mais je pense que cette méthode serait bien:

var array = [34, 23, 57, 983, 198];<br>
var score = 0;

for(var i = 0; i = array.length; i++) {
  if(array[ i ] > score) {
    score = array[i];
  }
}

Trouver le plus grand nombre dans un tableau multidimensionnel

var max = []; 

for(var i=0; arr.length>i; i++ ){

   var arra = arr[i];
   var largest = Math.max.apply(Math, arra);
   max.push(largest);

   }
return max;

Lance ça:

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

Et maintenant essayez les [3,10,2].max()retours10

Rechercher les valeurs Max et Min à l'aide du tri à bulles

    var arr = [267, 306, 108];

    for(i=0, k=0; i<arr.length; i++) {
      for(j=0; j<i; j++) {
        if(arr[i]>arr[j]) {
          k = arr[i];
          arr[i] = arr[j];
          arr[j] = k;
        }
      }
    }
    console.log('largest Number: '+ arr[0]);
    console.log('Smallest Number: '+ arr[arr.length-1]);

Essaye ça

function largestNum(arr) {
  var currentLongest = arr[0]

  for (var i=0; i< arr.length; i++){
    if (arr[i] > currentLongest){
      currentLongest = arr[i]
    }
  }

  return currentLongest
}

Selon le commentaire de @ Quasimondo , qui semble avoir été largement manqué, ce qui suit semble avoir les meilleures performances comme indiqué ici: https://jsperf.com/finding-maximum-element-in-an-array . Notez que tandis que pour le tableau dans la question, les performances peuvent ne pas avoir un effet significatif, pour les tableaux de grande taille, les performances deviennent plus importantes, et encore une fois, comme indiqué, l' utilisation Math.max()ne fonctionne même pas si la longueur du tableau est supérieure à 65 535. Voir également cette réponse .

function largestNum(arr) {
    var d = data;
    var m = d[d.length - 1];
    for (var i = d.length - 1; --i > -1;) {
      if (d[i] > m) m = d[i];
    }
    return m;
}

Une approche récursive sur la façon de le faire en utilisant des opérateurs ternaires

const findMax = (arr, max, i) => arr.length === i ? max :
  findMax(arr, arr[i] > max ? arr[i] : max, ++i)

const arr = [5, 34, 2, 1, 6, 7, 9, 3];
const max = findMax(arr, arr[0], 0)
console.log(max);

for/ofSolution à une boucle:

const numbers = [2, 4, 6, 8, 80, 56, 10];


const findMax = (...numbers) => {
  let currentMax = numbers[0]; // 2

  for (const number of numbers) {
    if (number > currentMax) {
      console.log(number, currentMax);
      currentMax = number;
    }
  }
  console.log('Largest ', currentMax);
  return currentMax;
};

findMax(...numbers);