Bir JavaScript dizisinde bulunan en büyük sayıyı nasıl bulabilirim?

Birkaç sayı içeren basit bir JavaScript dizi nesnesi var.

[267, 306, 108]

Bu dizideki en büyük sayıyı bulabilecek bir işlev var mı?

Kurtarmaya Resig:

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

Uyarı : bazı VM'lerde maksimum bağımsız değişken sayısı 65535 kadar düşük olduğundan, dizinin bu kadar küçük olduğundan emin değilseniz bir for döngüsü kullanın.

Math.max öğesini çağırmak için uygula işlevini kullanabilirsiniz :

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

Nasıl çalışır?

Uygulama fonksiyonu bir dizi olarak sağlanan belirli bir bağlamda ve bağımsız değişkenler, ile, başka bir işlevi çağırmak için kullanılır. Min ve max işlevleri isteğe bağlı sayıda giriş argümanı alabilir: Math.max (val1, val2, ..., valN)

Yani, eğer ararsak:

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

Uygula işlevi aşağıdakileri yürütür:

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

İlk parametrenin, bağlamın, statik oldukları için bu işlevler için önemli olmadığını, bağlam olarak geçirilenlerden bağımsız olarak çalışacaklarını unutmayın.

Yeni forma operatörü ile en kolay sözdizimi :

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

Kaynak: Mozilla MDN

Ben JS uzmanı değilim, ama bu yöntemlerin nasıl biriktiğini görmek istedim, bu yüzden bu benim için iyi bir uygulama oldu. Bu teknik performans bunları test etmek için doğru yolu olup olmadığını bilmiyorum, ama kodumda görebileceğiniz gibi, onları birbiri ardına koştum.

0'ıncı değeri sıralamak ve elde etmek en kötü yöntemdir (ve dizinizin sırasını değiştirir, bu istenilemez). Milyonlarca endeksten bahsetmediğiniz sürece diğerleri için fark göz ardı edilebilir.

100.000 dizinli rastgele sayılar dizisiyle beş çalışmanın ortalama sonuçları:

• reduce çalıştırmak için 4.0392ms aldı
• Math.max.apply aldı 3.3742ms çalıştırmak için
• sıralama ve 0 değerini alma çalıştırmak için 67.4724ms aldı
• Math.max içinde reduce () çalıştırmak için 6.5804ms aldı
• özel findmax fonksiyon aldı 1.6102ms çalıştırmak için

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)

Ben daha büyük diziler (~ 100k elemanları) için, aslında for~% 30 daha iyi performans mütevazi bir döngü ile dizi yineleme için öder 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;
}

Deney sonuçları

Diziyi azalan sırada sıralayabilir ve ilk öğeyi alabilirsiniz:

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

Buna ne dersin:

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

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

console.log(largest);

Array.reduce kullanmaya ne dersiniz ?

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

Hemen hemen tüm cevaplar Math.max.apply()güzel ve züppe ama sınırlamaları olan kullanın.

İşlev argümanları, bir dezavantajı olan bir sınıra yerleştirilir. Yani diziniz sınırdan büyükse başarısız olurRangeError: Maximum call stack size exceeded.

Bir çağrı yığını boyutu bulmak için bu kodu kullandım:

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

Makinemdeki FireFox üzerinde en büyük olduğu kanıtlandı - 591519 . Bu, diziniz 591519'dan fazla öğe içeriyorsa RangeError ileMath.max.apply() sonuçlanacağı anlamına gelir .

Bu sorun için en iyi çözüm yinelemeli yöntemdir (kredi: 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];
}

Bu soru hakkında buradaki blogumda yazdım .

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

Maksimum ve minimum değerleri kolay ve manuel olarak bulmak. Bu kod daha hızlıdır Math.max.apply; Dizide 1000 bine kadar sayıyı denedim.

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

Kullanmanız gereken bir dizideki en büyük sayıyı bulmak için Math.max(...arrayName);şu şekilde çalışır:

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

Hakkında daha fazla bilgi edinmek için Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Evet elbette var: Math.max.apply(null,[23,45,67,-45]) sonuç geri dönüyor 67;

Basit bir astar

[].sort().pop()

Function.prototype.bindSargının size "tamamen doğal" bir işlev vererek yapılabileceğini unutmayın .

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

Ayrıca Arraybu işleve sahip olmak ve her dizinin bir parçası yapmak için genişletebilirsiniz .

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

console.log( myArray.max() );

ForEach için de kullanabilirsiniz :

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

- kullanmak Array.prototype.reduce()harika!

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

burada acc = akümülatör ve val = akım değeri ;

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

console.log(a);

Bunu deneyebilirsin,

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

JS ile yeni başladım ama bu yöntemin iyi olacağını düşünüyorum:

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

Çok boyutlu bir dizideki en büyük sayıyı bulma

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;

Bunu çalıştırın:

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

Ve şimdi [3,10,2].max()geri dönüşleri deneyin10

Bubble Sort kullanarak Maks ve Min değerini bulun

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

Bunu dene

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

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

  return currentLongest
}

@ Quasimondo'nun büyük ölçüde kaçırılmış gibi görünen yorumuna göre , aşağıda gösterildiği gibi en iyi performansa sahip gibi görünüyor: https://jsperf.com/finding-maximum-element-in-an-array . Not Söz konusu dizi için, performans önemli bir etkiye sahip olmayabilir iken, büyük diziler için performans daha önemli ve tekrar olur olarak kaydetti kullanılarak Math.max()dizi uzunluk da fazla 65535 Bkz ise yaptığı bile işi bu cevap .

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

Üçlü operatörler kullanarak nasıl yapılacağı konusunda özyinelemeli bir yaklaşım

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

Bir for/ofdöngü çözümü:

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