Jak mogę znaleźć największą liczbę zawartą w tablicy JavaScript?

Mam prosty obiekt JavaScript Array zawierający kilka liczb.

[267, 306, 108]

Czy istnieje funkcja, która znalazłaby największą liczbę w tej tablicy?

Resig na ratunek:

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

Ostrzeżenie : ponieważ maksymalna liczba argumentów jest tak mała jak 65535 na niektórych maszynach wirtualnych , użyj pętli for, jeśli nie masz pewności, że tablica jest tak mała.

Możesz użyć funkcji Apply , aby wywołać Math.max :

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

Jak to działa?

zastosowanie służy do wywoływania innej funkcji z danym kontekstem i argumentami podanymi w postaci tablicy. Funkcje min i max mogą przyjmować dowolną liczbę argumentów wejściowych: Math.max (val1, val2, ..., valN)

Więc jeśli zadzwonimy:

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

Funkcja Apply wykona:

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

Zauważ, że pierwszy parametr, kontekst, nie jest ważny dla tych funkcji, ponieważ są one statyczne, będą działać niezależnie od tego, co zostanie przekazane jako kontekst.

Najłatwiejsza składnia z nowym operatorem rozkładania :

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

Źródło: Mozilla MDN

Nie jestem ekspertem od JS, ale chciałem zobaczyć, jak te metody się nakładają, więc była to dla mnie dobra praktyka. Nie wiem, czy jest to technicznie właściwy sposób na przetestowanie ich wydajności, ale po prostu uruchomiłem je jeden po drugim, jak widać w moim kodzie.

Sortowanie i uzyskiwanie wartości 0 jest zdecydowanie najgorszą metodą (i modyfikuje kolejność tablicy, co może nie być pożądane). Dla pozostałych różnica jest znikoma, chyba że mówimy o milionach wskaźników.

Średnie wyniki pięciu przebiegów z tablicą liczb losowych o wartości 100 000 indeksów:

• zmniejszyć miały 4.0392ms uruchomić
• Math.max.apply wziął 3.3742ms uruchomić
• Sortowanie i uzyskiwanie wartość 0-cia wziął 67.4724ms uruchomić
• Uruchomienie Math.max w funkcji replace () zajęło 6.5804ms
• zwyczaj funkcja findmax wziął 1.6102ms uruchomić

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)

Przekonałem się, że w przypadku większych tablic (~ 100 000 elementów) opłaca się po prostu iterować tablicę skromną forpętlą, osiągając ~ 30% lepiej niż 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;
}

Wyniki testu

Możesz posortować tablicę w kolejności malejącej i uzyskać pierwszy element:

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

Co powiesz na to:

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

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

console.log(largest);

co powiesz na użycie Array.reduce ?

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

Wykorzystują prawie wszystkie odpowiedzi Math.max.apply() co jest miłe i eleganckie, ale ma ograniczenia.

Argumenty funkcji są umieszczane na stosie, który ma wadę - limit. Więc jeśli twoja tablica jest większa niż limit, nie powiedzie sięRangeError: Maximum call stack size exceeded.

Aby znaleźć rozmiar stosu wywołań, użyłem tego kodu:

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

Okazało się, że jest największy w FireFoxie na moim komputerze - 591519 . Oznacza to, że jeśli tablica zawiera więcej niż 591519 elementów, Math.max.apply()wystąpi błąd RangeError .

Najlepszym rozwiązaniem tego problemu jest sposób iteracyjny (kredyt: 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];
}

O tym pytaniu pisałem tutaj na moim blogu .

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

Znalezienie wartości maksymalnej i minimalnej jest łatwe i ręczne. Ten kod jest znacznie szybszy niż Math.max.apply; Próbowałem do 1000 000 numerów w tablicy.

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

Aby znaleźć największą liczbę w tablicy, której potrzebujesz tylko użyć Math.max(...arrayName);, działa to tak:

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

Aby dowiedzieć się więcej na temat Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Tak, oczywiście, istnieją: Math.max.apply(null,[23,45,67,-45]) i wynik zwraca 67;

Prosta jedna wkładka

[].sort().pop()

Nie zapomnij, że można zrobić okład z Function.prototype.bind, co daje „all-native” funkcji .

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

Możesz także rozszerzyć Arraytę funkcję i uczynić ją częścią każdej tablicy.

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

console.log( myArray.max() );

Możesz także użyć 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

Korzystanie - Array.prototype.reduce()jest fajne!

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

gdzie acc = akumulator i val = aktualna wartość ;

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

console.log(a);

Możesz spróbować

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

Właśnie zacząłem od JS, ale myślę, że ta metoda byłaby dobra:

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

Znajdź największą liczbę w tablicy wielowymiarowej

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;

Uruchom to:

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

A teraz spróbuj [3,10,2].max()wrócić10

Znajdź wartość Max i Min za pomocą Bubble Sort

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

Spróbuj tego

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

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

  return currentLongest
}

Zgodnie z komentarzem @ Quasimondo , który wydaje się być w dużej mierze pominięty, poniższe wyniki wydają się mieć najlepszą wydajność, jak pokazano tutaj: https://jsperf.com/finding-maximum-element-in-an-array . Należy zauważyć, że chociaż dla tablicy w pytaniu wydajność może nie mieć znaczącego wpływu, w przypadku dużych tablic wydajność staje się ważniejsza, i ponownie, jak zauważono, użycie Math.max()nawet nie działa, jeśli długość tablicy jest większa niż 65535. Zobacz także tę odpowiedź .

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

Podejście rekurencyjne, jak to zrobić przy użyciu operatorów trójskładnikowych

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/ofRozwiązanie z jedną pętlą:

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