Bir JavaScript Dizisinin min veya maks öğesini nasıl kolayca edinebilirim?

Örnek Psuedocode:

let array = [100, 0, 50]

array.min() //=> 0
array.max() //=> 100

Nasıl artırmada yaklaşık yerleşik kullanmak Dizi nesne Math.max/ Math.minyerine:

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

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

İşte bir JSFiddle .

Yerleşikleri genişletmek, diğer kütüphanelerle çarpışmalara neden olabilir (bazıları bkz.), Bu nedenle doğrudan dizinize applygitme konusunda daha rahat olabilirsiniz Math.xxx():

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

Alternatif olarak, tarayıcınızın ECMAScript 6'yı desteklediğini varsayarsak , yönteme benzer şekilde çalışan forma operatörünü kullanabilirsiniz apply:

var min = Math.min( ...arr ),
    max = Math.max( ...arr );

var max_of_array = Math.max.apply(Math, array);

Tam bir tartışma için bkz. Http://aaroncrane.co.uk/2008/11/javascript_max_api/

Büyük diziler için (~ 10⁷ elemanlar) Math.minve Math.maxher ikisi de Node.js'de aşağıdaki hatayı üretir.

RangeError: Maksimum çağrı yığını boyutu aşıldı

Daha sağlam bir çözüm, her öğeyi çağrı yığınına eklemek değil, bunun yerine bir dizi iletmektir:

function arrayMin(arr) {
  return arr.reduce(function (p, v) {
    return ( p < v ? p : v );
  });
}

function arrayMax(arr) {
  return arr.reduce(function (p, v) {
    return ( p > v ? p : v );
  });
}

Hız konusunda endişeleriniz varsa, aşağıdaki kod Math.max.applybilgisayarımda ~ 3 kat daha hızlıdır . Bkz. Http://jsperf.com/min-and-max-in-array/2 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (arr[len] < min) {
      min = arr[len];
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (arr[len] > max) {
      max = arr[len];
    }
  }
  return max;
};

Dizileriniz sayılar yerine dizeler içeriyorsa, sayılara da zorlamanız gerekir. Aşağıdaki kod bunu yapar, ancak makinemde kodu ~ 10 kez yavaşlatır. Bkz. Http://jsperf.com/min-and-max-in-array/3 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (Number(arr[len]) < min) {
      min = Number(arr[len]);
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (Number(arr[len]) > max) {
      max = Number(arr[len]);
    }
  }
  return max;
};

Forma operatörünü (ES6) kullanma

Math.max(...array);  // the same with "min" => Math.min(...array);

const array = [10, 2, 33, 4, 5];

console.log(
  Math.max(...array)
)

tl; Dr.

// For regular arrays:
var max = Math.max(...arrayOfNumbers);

// For arrays with tens of thousands of items:
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

MDN çözümü

Üzerindeki resmi MDN belgeleriMath.max() zaten bu sorunu kapsamaktadır:

Aşağıdaki işlev, sayısal bir dizideki maksimum öğeyi bulmak için Function.prototype.apply () öğesini kullanır . getMaxOfArray([1, 2, 3])eşdeğerdir Math.max(1, 2, 3), ancak getMaxOfArray()herhangi bir boyuttaki programlı olarak oluşturulmuş dizilerde kullanabilirsiniz .

function getMaxOfArray(numArray) {
    return Math.max.apply(null, numArray);
}

Ya da yeni forma operatörü ile bir dizinin maksimumu elde etmek çok daha kolay hale gelir.

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

Bir dizinin maksimum boyutu

MDN'yi göreapply ve yayılma çözümleri vardı argümanlar maksimum sayıda sınırının geldi 65536 bir sınırlama:

Ancak dikkat: Uygulamayı bu şekilde kullanırken, JavaScript motorunun bağımsız değişken uzunluk sınırını aşma riskiniz vardır. Çok fazla bağımsız değişkeni olan bir işlevi uygulamanın sonuçları (on binlerce argümandan fazla düşünün) motorlar arasında farklılık gösterir ( JavaScriptCore'un sabit kodlu argüman sınırı 65536'dır ), çünkü sınır (hatta aşırı büyük yığınların doğası bile) davranış) belirtilmemiş. Bazı motorlar bir istisna atar. Daha korkutucu bir şekilde, diğerleri keyfi olarak uygulanan işleve iletilen argüman sayısını sınırlandıracaktır. Bu son durumu göstermek için: eğer böyle bir motor dört argüman sınırına sahip olsaydı (gerçek sınırlar elbette önemli ölçüde daha yüksekse), yukarıdaki örneklerde uygulanacak 5, 6, 2, 3 argümanlarının geçirilmiş olması gibi olurdu, tam dizi yerine.

Hatta diğer çözümlere kıyasla gerçekten iyi bir performansa sahip olmayan hibrit bir çözüm sunarlar. Daha fazla bilgi için aşağıdaki performans testine bakın.

2019'da gerçek sınır, çağrı yığınının maksimum boyutudur . Modern Chromium tabanlı masaüstü tarayıcıları için bu, min / maks ile applyveya yayılarak bulma söz konusu olduğunda , pratik olarak yalnızca diziler için maksimum boyutun ~ 120000 olduğu anlamına gelir . Bunun üzerinde bir yığın taşması olacak ve aşağıdaki hata atılacaktır:

RangeError: Maksimum çağrı yığını boyutu aşıldı

Aşağıdaki komut dosyasıyla ( bu blog gönderisini temel alarak ), bu hatayı yakalayarak, ortamınıza özgü sınırı hesaplayabilirsiniz.

Uyarı! Bu komut dosyasını çalıştırmak zaman alır ve sisteminizin performansına bağlı olarak tarayıcınızı / sisteminizi yavaşlatabilir veya bozabilir!

let testArray = Array.from({length: 10000}, () => Math.floor(Math.random() * 2000000));
for (i = 10000; i < 1000000; ++i) {
  testArray.push(Math.floor(Math.random() * 2000000));
  try {
    Math.max.apply(null, testArray);
  } catch (e) {
    console.log(i);
    break;
  }
}

Büyük dizilerde performans

EscapeNetscape'in yorumundaki teste dayanarak, rastgele bir sayı dizisinde sadece 100000 öğe içeren 5 farklı yöntemi test eden bazı ölçütler oluşturdum .

2019'da sonuçlar, standart döngünün (BTW'nin boyut sınırlamasına sahip olmadığı) her yerde en hızlı olduğunu gösteriyor. applyve yayılma ondan sonra yakından gelir, daha sonra MDN'nin hibrit çözümü o zaman reduceen yavaş olanıdır.

Hemen hemen tüm testler aynı sonuçları verdi, ancak bir şekilde yayılmanın en yavaş olduğu bir durum hariç.

Dizinizi 1 milyon öğeye sahip olacak şekilde hızlandırırsanız, işler kırılmaya başlar ve standart döngüde hızlı bir çözüm ve reducedaha yavaş olarak kalırsınız .

JSPerf karşılaştırması

JSBen karşılaştırması

JSBench.me karşılaştırması

Karşılaştırma kaynak kodu

var testArrayLength = 100000
var testArray = Array.from({length: testArrayLength}, () => Math.floor(Math.random() * 2000000));

// ES6 spread
Math.min(...testArray);
Math.max(...testArray);

// reduce
testArray.reduce(function(a, b) {
  return Math.max(a, b);
});
testArray.reduce(function(a, b) {
  return Math.min(a, b);
});

// apply
Math.min.apply(Math, testArray);
Math.max.apply(Math, testArray);

// standard loop
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

let min = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] < min) {
    min = testArray[i];
  }
}

// MDN hibrid soltuion
// Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Using_apply_and_built-in_functions
function minOfArray(arr) {
  var min = Infinity;
  var QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
    min = Math.min(submin, min);
  }

  return min;
}

minOfArray(testArray);

function maxOfArray(arr) {
  var max = -Infinity;
  var QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submax = Math.max.apply(null, arr.slice(i, Math.max(i + QUANTUM, len)));
    max = Math.max(submax, max);
  }

  return max;
}

maxOfArray(testArray);

Benim gibi paranoyaksanız Math.max.apply( MDN'ye göre büyük diziler verildiğinde hatalara neden olabilir ), şunu deneyin:

function arrayMax(array) {
  return array.reduce(function(a, b) {
    return Math.max(a, b);
  });
}

function arrayMin(array) {
  return array.reduce(function(a, b) {
    return Math.min(a, b);
  });
}

Veya ES6'da:

function arrayMax(array) {
  return array.reduce((a, b) => Math.max(a, b));
}

function arrayMin(array) {
  return array.reduce((a, b) => Math.min(a, b));
}

Anonim işlevler maalesef gerekli (kullanmak yerine vardır Math.max.bind(Math)çünkü reducesadece geçmez ave bonun işlevine değil, aynı zamanda ibiz aramaya kalkma sağlamak zorunda ve dizinin kendisi bir referans maxsıra olanlara.

.apply genellikle amaç, argüman değerleri listesiyle birlikte değişken bir işlevi çağırmak için kullanılır;

Math.max([value1[,value2, ...]])Fonksiyon sıfır veya daha fazla sayı büyük döndürür.

Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20

Math.max()Yöntemi Bir dizide geçmesine izin vermez. En büyük değeri almanız gereken değerlerin bir listesine sahipseniz, normalde bu işlevi Function.prototype.apply () kullanarak çağırırsınız ;

Math.max.apply(null, [10, 20]); // 20
Math.max.apply(null, [-10, -20]); // -10
Math.max.apply(null, [-10, 20]); // 20

Ancak, ECMAScript 6'dan itibaren spread operatörünü kullanabilirsiniz :

Forma işleci, bir ifadenin (işlev çağrıları için) veya birden çok öğenin (dizi değişmezleri için) beklendiği yerlerde bir ifadenin genişletilmesine izin verir.

Forma operatörünü kullanarak, yukarıdaki gibi yeniden yazılabilir:

Math.max(...[10, 20]); // 20
Math.max(...[-10, -20]); // -10
Math.max(...[-10, 20]); // 20

Variadic operatörünü kullanarak bir işlevi çağırırken, ek değerler de ekleyebilirsiniz, örn.

Math.max(...[10, 20], 50); // 50
Math.max(...[-10, -20], 50); // 50

Bonus:

Yayılması operatörü bir arada kullanarak, sen ES5 size zorunlu koduna geri düşmek gerekir durumlarda yeni diziler oluşturmak için dizi değişmez sözdizimini kullanmanızı sağlar push, splicevb

let foo = ['b', 'c'];
let bar = ['a', ...foo, 'd', 'e']; // ['a', 'b', 'c', 'd', 'e']

İki yol daha kısa ve kolaydır:

let arr = [2, 6, 1, 0]

Yol 1 :

let max = Math.max.apply(null, arr)

Yol 2 :

let max = arr.reduce(function(a, b) {
    return Math.max(a, b);
});

Dizi türünü genişleterek yaparsınız:

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

Dan Boosted burada (John Resig tarafından)

Bir Arrayöğenin üzerindeki minimum değeri bulmak için basit bir çözüm , Arrayprototip işlevini kullanmaktır reduce:

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9

veya JavaScript'in yerleşik Math.Min () işlevini kullanarak (teşekkürler @Tenflex):

A.reduce((min,val) => Math.min(min,val), A[0]);

Bu kümeler miniçin A[0]daha sonra ve denetler A[1]...A[n]o kesinlikle daha az akımından daha olup olmadığı min. Eğer A[i] < minöyleyse minolarak güncellenir A[i]. Tüm dizi elemanları işlendiğinde, minsonuç olarak döndürülür.

DÜZENLEME : Minimum değerin konumunu ekleyin:

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min._min ? {_min: val, _idx: min._curr, _curr: min._curr + 1} : {_min: min._min, _idx: min._idx, _curr: min._curr + 1}, {_min: A[0], _idx: 0, _curr: 0}); // returns { _min: -9, _idx: 2, _curr: 6 }

Diğerleri zaten arttıkları bazı çözümler verdiler Array.prototype. Bu yanıt olarak bakıldığında Talep olması gerekmediğini açıklığa kavuşturmak için Math.min.apply( Math, array )veya Math.min.apply( null, array ). Peki hangi bağlam kullanılmalı, Mathya da null?

nullBağlam olarak geçerkenapply iletilirken, bağlam varsayılan olarak genel nesneye ( windowtarayıcılardaki nesne) ayarlanacaktır. Geçme Mathbağlam olarak nesneyi doğru çözüm olacaktır, ancak geçen acıtmayacak nullya. İşlevi nulldekore ederken soruna neden olabileceği bir örnek Math.max:

// decorate Math.max
(function (oldMax) {
    Math.max = function () {
        this.foo(); // call Math.foo, or at least that's what we want

        return oldMax.apply(this, arguments);
    };
})(Math.max);

Math.foo = function () {
    print("foo");
};

Array.prototype.max = function() {
  return Math.max.apply(null, this); // <-- passing null as the context
};

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

print(max);

Yukarıdaki bir istisna atar çünkü this.foo olarak değerlendirilecek window.fooolan undefined. Biz değiştirirseniz nullile Mathbeklenen ve dize "foo" ekrana basılacaktır olarak işler çalışacaktır (bu kullanılarak test Mozilla Rhino ).

Kimsenin süslemediğini varsayabilirsin Math.maxnull etmediğini , geçmenin sorunsuz çalışacağını .

Bunu yapmanın bir yolu daha:

var arrayMax = Function.prototype.apply.bind(Math.max, null);

Kullanımı:

var max = arrayMax([2, 5, 1]);

Alternatif yöntemler

Math.minVe Math.maxyöntemler hem JS motorun çağrı yığınına eklenen bu özyinelemeli işlemleri ve büyük olasılıkla çarpışma öğeleri çok sayıda içeren bir dizi için
(daha ~ 10⁷ öğeler yerine, kullanıcının tarayıcısında bağlıdır).

Math.max (... Array (1000000) .keys ());

Yakalanmamış RangeError: Maksimum çağrı yığını boyutu aşıldı

Bunun yerine, şöyle bir şey kullanın:

arr.reduce((max, val) => max > val ? max : val, arr[0])

Veya daha iyi çalışma süresiyle:

function maxValue(arr) {
  let max = arr[0];

  for (let val of arr) {
    if (val > max) {
      max = val;
    }
  }
  return max;
}

Veya hem Min hem de Maks.

function getMinMax(arr) {
  return arr.reduce(({min, max}, v) => ({
    min: min < v ? min : v,
    max: max > v ? max : v,
  }), { min: arr[0], max: arr[0] });
}

Veya daha iyi çalışma süresiyle *:

function getMinMax(arr) {
  let min = arr[0];
  let max = arr[0];
  let i = arr.length;

  while (i--) {
    min = arr[i] < min ? arr[i] : min;
    max = arr[i] > max ? arr[i] : max;
  }
  return { min, max };
}

* 1.000.000 öğe ile test edilmiştir:
Sadece bir referans için, 1. işlev çalışma süresi (makinemde) 15.84ms ve 2. işlev yerine sadece 4.32ms idi.

Bu sizin amacınıza uygun olabilir.

Array.prototype.min = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.min);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

Array.prototype.max = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.max);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

var arr = [100, 0, 50];
console.log(getMaxOfArray(arr))

bu benim için çalıştı.

Şaşırmadım ve azaltma fonksiyonu.

var arr = [1, 10, 5, 11, 2]

var b = arr.reduce(function(previous,current){ 
                      return previous > current ? previous:current
                   });

b => 11
arr => [1, 10, 5, 11, 2]

Büyük diziler için (~ 10⁷ elemanlar) Math.minveMath.max 10⁷ düğümde bir RangeError (Maksimum çağrı yığını boyutu aşıldı) üretir.

Büyük diziler için hızlı ve kirli bir çözüm:

Array.prototype.min = function() {
    var r = this[0];
    this.forEach(function(v,i,a){if (v<r) r=v;});
    return r;
};

Aynı sorunu yaşadım, bir dizinin minimum ve maksimum değerlerini elde etmek zorunda kaldım ve sürprizime göre diziler için yerleşik işlevler yoktu. Çok okuduktan sonra, "ilk 3" çözümleri kendim test etmeye karar verdim:

1. ayrık çözüm: dizinin her elemanını mevcut maks ve / veya min değerine göre kontrol etmek için bir FOR döngüsü;
2. UYGULAMA çözümü: diziyi uygula (null, dizi) kullanarak Math.max ve / veya Math.min dahili işlevlerine gönderme;
3. REDUCE çözümü: reduce (function) işlevini kullanarak dizinin her öğesine karşı bir kontrolün tekrarlanması.

Test kodu şuydu:

function GetMaxDISCRETE(A)
{   var MaxX=A[0];

    for (var X=0;X<A.length;X++)
        if (MaxX<A[X])
            MaxX=A[X];

    return MaxX;
}

function GetMaxAPPLY(A)
{   return Math.max.apply(null,A);
}

function GetMaxREDUCE(A)
{   return A.reduce(function(p,c)
    {   return p>c?p:c;
    });
}

A dizisi 100.000 rasgele tamsayı ile dolduruldu, her işlev Windows Vista ile bir Intel Pentium 4 2.99GHz masaüstünde Mozilla Firefox 28.0'da 10.000 kez yürütüldü. Süreler, performance.now () işlevi tarafından alınan saniye cinsindendir. Sonuçlar, 3 kesirli basamak ve standart sapma ile bunlardı:

1. Ayrık çözelti: ortalama = 0.161s, sd = 0.078
2. UYGULAMA çözümü: ortalama = 3.571s, sd = 0.487
3. REDÜCE çözümü: ortalama = 0.350s, sd = 0.044

REDUCE çözeltisi, ayrı çözeltiden% 117 daha yavaştı. APPLY çözeltisi, ayrı çözeltiden daha kötü,% 2,118 daha yavaştı. Ayrıca, Peter'ın gözlemlediği gibi, büyük diziler (yaklaşık 1.000.000 elementten fazla) için çalışmaz.

Ayrıca, testleri tamamlamak için bu genişletilmiş ayrık kodu test ettim:

var MaxX=A[0],MinX=A[0];

for (var X=0;X<A.length;X++)
{   if (MaxX<A[X])
        MaxX=A[X];
    if (MinX>A[X])
        MinX=A[X];
}

Zamanlama: ortalama = 0.218s, sd = 0.094

Bu nedenle, basit ayrık çözümden% 35 daha yavaştır, ancak aynı anda hem maksimum hem de minimum değerleri alır (başka herhangi bir çözüm, bunları almak için en az iki kez alır). OP her iki değere ihtiyaç duyduğunda, ayrık çözüm en iyi seçim olacaktır (biri maksimum hesaplamak için diğeri minimum hesaplamak için iki ayrı işlev olsa bile, ikinci en iyi, REDUCE çözümünden daha iyi performans gösterecektir).

Projenizde herhangi bir yerde aşağıdaki işlevi kullanabilirsiniz:

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

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

Ve sonra diziyi geçen işlevleri çağırabilirsiniz:

var myArray = [1,2,3,4,5,6,7];
var maximo = getMax(myArray); //return the highest number

Aşağıdaki kod benim için çalışıyor:

var valueList = [10,4,17,9,3];
var maxValue = valueList.reduce(function(a, b) { return Math.max(a, b); });
var minValue = valueList.reduce(function(a, b) { return Math.min(a, b); });

İlerleyin, ilerledikçe takip edin.

var min = null;
var max = null;
for (var i = 0, len = arr.length; i < len; ++i)
{
    var elem = arr[i];
    if (min === null || min > elem) min = elem;
    if (max === null || max < elem) max = elem;
}
alert( "min = " + min + ", max = " + max );

Dizide hiçbir öğe yoksa, min / max null değerini bırakır. Dizide herhangi bir öğe varsa, bir geçişte min ve maks değerini ayarlar.

Array'ı, rangeyeniden kullanılabilirliğe ve yeniden okunabilirliğe izin vermek için yukarıdakileri kullanarak bir yöntemle genişletebilirsiniz . Bir çalışma keman bakın http://jsfiddle.net/9C9fU/

Array.prototype.range = function() {

    var min = null,
        max = null,
        i, len;

    for (i = 0, len = this.length; i < len; ++i)
    {
        var elem = this[i];
        if (min === null || min > elem) min = elem;
        if (max === null || max < elem) max = elem;
    }

    return { min: min, max: max }
};

Olarak kullanılır

var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];

var range = arr.range();

console.log(range.min);
console.log(range.max);

Basit ve kolay anlaşılır çözümümü paylaşacağımı düşündüm.

Min için:

var arr = [3, 4, 12, 1, 0, 5];
var min = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] < min) {
    min = arr[k];
  }
}
console.log("Min is: " + min);

Ve maks. İçin:

var arr = [3, 4, 12, 1, 0, 5];
var max = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] > max) {
    max = arr[k];
  }
}
console.log("Max is: " + max);

Math işlev max ve min'in yanı sıra, kullanılacak başka bir işlev de sort () işlevinin yerleşik işlevidir: işte başlıyoruz

const nums = [12, 67, 58, 30].sort((x, y) => 
x -  y)
let max = nums[0]
let min = nums[nums.length -1]

Basit şeyler, gerçekten.

var arr = [10,20,30,40];
arr.max = function() { return  Math.max.apply(Math, this); }; //attach max funct
arr.min = function() { return  Math.min.apply(Math, this); }; //attach min funct

alert("min: " + arr.min() + " max: " + arr.max());

İşte bir nesne dizisinden maksimum değeri almanın bir yolu. Bir kopya oluşturun (dilim ile), ardından kopyayı azalan düzende sıralayın ve ilk öğeyi alın.

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

maxsort = myArray.slice(0).sort(function(a, b) { return b.ID - a.ID })[0].ID; 

kullanılması Math.max()veyaMath.min()

Math.max(10, 20);   //  20
Math.min(-10, -20); // -20

Aşağıdaki işlev, Function.prototype.apply()sayısal bir dizideki maksimum öğeyi bulmak için kullanılır. getMaxOfArray([1, 2, 3])eşdeğerdir Math.max(1, 2, 3), ancak getMaxOfArray()herhangi bir boyuttaki programlı olarak oluşturulmuş dizilerde kullanabilirsiniz .

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

Ya da yeni forma operatörü ile bir dizinin maksimumu elde etmek çok daha kolay hale gelir.

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

Prototip kullanıyorsanız ChaosPandion'un çözümü işe yarar. Değilse, şunu düşünün:

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

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

Bir dizi değeri bir tamsayı değilse yukarıdaki NaN döndürecektir, bu nedenle bundan kaçınmak için bazı işlevler oluşturmanız gerekir. Aksi takdirde bu işe yarayacaktır.

Sugar.js kütüphanesini kullanıyorsanız , önerdiğiniz gibi arr.min () ve arr.max () yazabilirsiniz . Sayısal olmayan dizilerden minimum ve maksimum değerler de alabilirsiniz.

min (map, all = false) Dizideki en düşük değere sahip öğeyi döndürür. map, denetlenecek değeri eşleştiren bir işlev veya kısayol olarak işlev gören bir dize olabilir. All doğruysa, bir dizideki tüm min değerlerini döndürür.

max (map, all = false) Dizideki en büyük değere sahip öğeyi döndürür. map, denetlenecek değeri eşleştiren bir işlev veya kısayol olarak işlev gören bir dize olabilir. Tümü true olursa, bir dizideki tüm maksimum değerleri döndürür.

Örnekler:

[1,2,3].min() == 1
['fee','fo','fum'].min('length') == "fo"
['fee','fo','fum'].min('length', true) == ["fo"]
['fee','fo','fum'].min(function(n) { return n.length; }); == "fo"
[{a:3,a:2}].min(function(n) { return n['a']; }) == {"a":2}
['fee','fo','fum'].max('length', true) == ["fee","fum"]

Lo-Dash ve underscore.js gibi kütüphaneler de benzer güçlü min ve maks işlevleri sağlar:

Lo-Dash'ten bir örnek:

_.max([4, 2, 8, 6]) == 8
var characters = [
  { 'name': 'barney', 'age': 36 },
  { 'name': 'fred',   'age': 40 }
];
_.max(characters, function(chr) { return chr.age; }) == { 'name': 'fred', 'age': 40 }

let arr = [2,5,3,5,6,7,1];

let max = Math.max(...arr); // 7
let min = Math.min(...arr); // 1

Deneyin

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

console.log('Max', max(arr));
console.log('Min', min(arr))

Math.min / max (+ uygulamak) için hata alırız:

Maksimum çağrı yığını boyutu aşıldı (Chrome 74.0.3729.131)

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

// Exception: Maximum call stack size exceeded

try {
  let max1= Math.max(...arr);          
} catch(e) { console.error('Math.max :', e.message) }

try {
  let max2= Math.max.apply(null, arr); 
} catch(e) { console.error('Math.max.apply :', e.message) }


// same for min