Bagaimana saya bisa dengan mudah mendapatkan elemen min atau max dari JavaScript Array?

Contoh Psuedocode:

let array = [100, 0, 50]

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

Bagaimana dengan menambah objek Array bawaan untuk menggunakan Math.max/ Math.minsebagai gantinya:

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

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

Ini JSFiddle .

Menambah built-in dapat menyebabkan tabrakan dengan perpustakaan lain (beberapa lihat), sehingga Anda mungkin lebih nyaman dengan hanya apply'ing Math.xxx()ke array Anda secara langsung:

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

Sebagai alternatif, dengan asumsi browser Anda mendukung ECMAScript 6, Anda dapat menggunakan operator spread yang fungsinya mirip dengan applymetode ini:

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

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

Untuk diskusi lengkap, lihat: http://aaroncrane.co.uk/2008/11/javascript_max_api/

Untuk array besar (~ 10⁷ elemen), Math.mindan Math.maxkeduanya menghasilkan kesalahan berikut di Node.js.

RangeError: Ukuran tumpukan panggilan maksimum terlampaui

Solusi yang lebih kuat adalah dengan tidak menambahkan setiap elemen ke tumpukan panggilan, tetapi untuk meneruskan array:

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

Jika Anda khawatir tentang kecepatan, kode berikut ~ 3 kali lebih cepat Math.max.applydari pada komputer saya. Lihat 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;
};

Jika array Anda mengandung string, bukan angka, Anda juga perlu memaksa mereka menjadi angka. Kode di bawah ini melakukan itu, tetapi memperlambat kode ~ 10 kali pada mesin saya. Lihat 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;
};

Menggunakan spread operator (ES6)

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

Solusi MDN

Dokumen MDN resmi padaMath.max() sudah mencakup masalah ini:

Fungsi berikut menggunakan Function.prototype.apply () untuk menemukan elemen maksimum dalam array numerik. getMaxOfArray([1, 2, 3])setara dengan Math.max(1, 2, 3), tetapi Anda dapat menggunakan getMaxOfArray()pada array yang dibangun secara terprogram dari berbagai ukuran.

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

Atau dengan operator spread baru , mendapatkan array maksimum menjadi jauh lebih mudah.

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

Ukuran maksimum array

Menurut MDN yang applydan penyebaran solusi memiliki keterbatasan dari 65.536 yang berasal dari batas jumlah maksimum argumen:

Namun berhati-hatilah: dalam menggunakan menerapkan cara ini, Anda berisiko melampaui batas panjang argumen mesin JavaScript. Konsekuensi dari penerapan fungsi dengan terlalu banyak argumen (pikirkan lebih dari puluhan ribu argumen) bervariasi di seluruh mesin ( JavaScriptCore memiliki batas argumen hard-kode 65536 ), karena batas (memang bahkan sifat setiap tumpukan yang terlalu besar) perilaku) tidak ditentukan. Beberapa mesin akan mengeluarkan pengecualian. Lebih parah lagi, orang lain akan secara sewenang-wenang membatasi jumlah argumen yang sebenarnya diteruskan ke fungsi yang diterapkan. Untuk menggambarkan kasus terakhir ini: jika mesin seperti itu memiliki batas empat argumen (batas sebenarnya tentu saja jauh lebih tinggi), itu akan seolah-olah argumen 5, 6, 2, 3 telah dilewati untuk diterapkan dalam contoh di atas, daripada array lengkap.

Mereka bahkan menyediakan solusi hybrid yang tidak benar-benar memiliki kinerja yang baik dibandingkan dengan solusi lain. Lihat tes kinerja di bawah ini untuk informasi lebih lanjut.

Pada 2019 batas sebenarnya adalah ukuran maksimum tumpukan panggilan . Untuk browser desktop berbasis Chromium modern ini berarti bahwa ketika datang untuk mencari min / max dengan applyatau menyebar, praktis ukuran maksimum untuk angka array hanya ~ 120000 . Di atas ini, akan ada stack overflow dan kesalahan berikut akan dilemparkan:

RangeError: Ukuran tumpukan panggilan maksimum terlampaui

Dengan skrip di bawah ini (berdasarkan posting blog ini ), dengan menangkap kesalahan itu Anda dapat menghitung batas untuk lingkungan spesifik Anda.

Peringatan! Menjalankan skrip ini membutuhkan waktu dan tergantung pada kinerja sistem Anda, mungkin memperlambat atau merusak browser / sistem Anda!

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

Performa pada array besar

Berdasarkan pengujian pada komentar EscapeNetscape saya membuat beberapa tolok ukur yang menguji 5 metode berbeda pada array angka acak saja dengan 100000 item .

Pada 2019, hasilnya menunjukkan bahwa loop standar (yang BTW tidak memiliki batasan ukuran) adalah yang tercepat di mana-mana. applydan penyebaran datang setelah itu, kemudian solusi hybrid MDN kemudian reducesebagai yang paling lambat.

Hampir semua tes memberikan hasil yang sama, kecuali untuk tes yang penyebarannya paling lambat.

Jika Anda meningkatkan array Anda untuk memiliki 1 juta item, hal-hal mulai rusak dan Anda dibiarkan dengan loop standar sebagai solusi cepat dan reducelebih lambat.

Tolok ukur JSPerf

Tolok ukur JSBen

Tolok ukur JSBench.me

Kode sumber patokan

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

Jika Anda paranoid seperti saya tentang penggunaan Math.max.apply(yang dapat menyebabkan kesalahan saat diberi array besar sesuai dengan MDN ), coba ini:

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

Atau, dalam ES6:

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

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

Sayangnya, fungsi anonim diperlukan (alih-alih menggunakan Math.max.bind(Math)karena reducetidak hanya meneruskan adan bke fungsinya, tetapi juga idan referensi ke array itu sendiri, jadi kami harus memastikan kami tidak mencoba memanggilnya maxjuga.

.apply sering digunakan ketika tujuannya adalah untuk memanggil fungsi variad dengan daftar nilai argumen, misalnya

The Math.max([value1[,value2, ...]])fungsi mengembalikan terbesar dari nol atau lebih nomor.

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

The Math.max()Metode tidak memungkinkan Anda untuk lulus dalam array. Jika Anda memiliki daftar nilai yang Anda butuhkan untuk mendapatkan yang terbesar, Anda biasanya akan memanggil fungsi ini menggunakan Function.prototype.apply () , misalnya

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

Namun, pada ECMAScript 6 Anda dapat menggunakan operator spread :

Operator spread memungkinkan ekspresi diperluas di tempat-tempat di mana banyak argumen (untuk panggilan fungsi) atau beberapa elemen (untuk liter array) diharapkan.

Menggunakan operator spread, yang di atas dapat ditulis ulang seperti:

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

Saat memanggil fungsi menggunakan operator variadic, Anda bahkan dapat menambahkan nilai tambahan, mis

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

Bonus:

Operator spread memungkinkan Anda untuk menggunakan array literal sintaks untuk membuat array baru dalam situasi di mana di ES5 Anda akan perlu untuk jatuh kembali ke kode penting, menggunakan kombinasi push, splicedll

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

Dua cara lebih pendek dan mudah:

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

Cara 1 :

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

Cara 2 :

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

Anda melakukannya dengan memperluas tipe Array:

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

Didorong dari sini (oleh John Resig)

Solusi sederhana untuk menemukan nilai minimum atas Arrayelemen adalah dengan menggunakan Arrayfungsi prototipe reduce:

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

atau menggunakan fungsi Math.Min () bawaan JavaScript (terima kasih @Tenflex):

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

Ini diatur minke A[0], dan kemudian memeriksa A[1]...A[n]apakah itu benar-benar kurang dari saat ini min. Jika A[i] < minkemudian mindiperbarui ke A[i]. Ketika semua elemen array telah diproses, mindikembalikan sebagai hasilnya.

EDIT : Sertakan posisi nilai minimum:

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 }

Yang lain telah memberikan beberapa solusi yang mereka tambahkan Array.prototype. Yang saya inginkan dalam jawaban ini adalah untuk menjelaskan apakah seharusnya Math.min.apply( Math, array )atau tidak Math.min.apply( null, array ). Jadi konteks apa yang harus digunakan, Mathatau null?

Ketika lewat nullsebagai konteks apply, maka konteksnya akan default ke objek global ( windowobjek dalam hal browser). Melewati Mathobjek sebagai konteks akan menjadi solusi yang tepat, tetapi tidak ada salahnya lewat nulljuga. Berikut ini contoh saat nulldapat menyebabkan masalah, saat mendekorasi Math.maxfungsi:

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

Di atas akan membuang pengecualian karena this.fooakan dievaluasi sebagai window.foo, yaitu undefined. Jika kita ganti nulldengan Math, semuanya akan berfungsi seperti yang diharapkan dan string "foo" akan dicetak ke layar (saya menguji ini menggunakan Mozilla Rhino ).

Anda dapat dengan mudah berasumsi bahwa tidak ada seorang pun yang didekorasi Math.maxdemikian, passing nullakan bekerja tanpa masalah.

Satu lagi cara untuk melakukannya:

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

Pemakaian:

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

Metode Alternatif

Metode Math.mindan Math.maxkeduanya adalah operasi rekursif yang ditambahkan ke tumpukan panggilan mesin JS, dan kemungkinan besar crash untuk array yang berisi sejumlah besar item
(lebih dari ~ 10⁷ item, tergantung pada browser pengguna).

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

Uncaught RangeError: Ukuran stack panggilan maksimum terlampaui

Sebagai gantinya, gunakan sesuatu seperti:

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

Atau dengan run-time yang lebih baik:

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

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

Atau untuk mendapatkan Min dan Max:

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

Atau dengan run-time * yang lebih baik:

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

* Diuji dengan 1.000.000 item:
Hanya untuk referensi, fungsi run-time 1 (pada mesin saya) adalah 15,84 ms vs fungsi 2 dengan hanya 4,32 ms.

Ini mungkin sesuai dengan tujuan Anda.

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

ini bekerja untuk saya.

Saya kaget tidak salah menyebut dan mengurangi fungsinya.

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]

Untuk array besar (~ 10⁷ elemen), Math.mindan Math.maxmenghasilkan RangeError (ukuran stack panggilan maksimum terlampaui) di node.js.

Untuk array besar, solusi cepat & kotor adalah:

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

Saya memiliki masalah yang sama, saya perlu mendapatkan nilai minimum dan maksimum dari sebuah array dan, yang mengejutkan saya, tidak ada fungsi built-in untuk array. Setelah banyak membaca, saya memutuskan untuk menguji sendiri solusi "3 teratas":

1. solusi diskrit: loop UNTUK untuk memeriksa setiap elemen array terhadap nilai maks dan / atau min saat ini;
2. BERLAKU solusi: mengirim array ke fungsi internal Math.max dan / atau Math.min menggunakan apply (null, array);
3. Solusi REDUCE: berulang cek terhadap setiap elemen array menggunakan mengurangi (fungsi).

Kode tes adalah ini:

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

Array A diisi dengan 100.000 angka integer acak, setiap fungsi dijalankan 10.000 kali pada Mozilla Firefox 28.0 pada desktop intel Pentium 4 2.99GHz dengan Windows Vista. Waktu dalam detik, diambil oleh fungsi performance.now (). Hasilnya adalah ini, dengan 3 digit fraksional dan deviasi standar:

1. Solusi diskrit: rata-rata = 0,161d, sd = 0,078
2. BERLAKU solusi: berarti = 3.571, sd = 0.487
3. Solusi REDUCE: mean = 0,350s, sd = 0,044

Solusi REDUCE lebih lambat 117% dari solusi diskrit. Solusi BERLAKU lebih buruk, 2.118% lebih lambat dari solusi diskrit. Selain itu, seperti yang diamati Peter, itu tidak berfungsi untuk array besar (sekitar lebih dari 1.000.000 elemen).

Juga, untuk menyelesaikan tes, saya menguji kode terpisah yang diperluas ini:

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

Waktunya: mean = 0,218s, sd = 0,094

Jadi, 35% lebih lambat dari solusi diskrit sederhana, tetapi ia mengambil nilai maksimum dan minimum sekaligus (solusi lain akan membutuhkan setidaknya dua kali lipat untuk mengambilnya). Setelah OP membutuhkan kedua nilai tersebut, solusi diskrit akan menjadi pilihan terbaik (meskipun dua fungsi terpisah, satu untuk menghitung maksimum dan satu lagi untuk menghitung minimum, mereka akan mengungguli yang terbaik kedua, solusi REDUCE).

Anda dapat menggunakan fungsi berikut di mana saja di proyek Anda:

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

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

Dan kemudian Anda bisa memanggil fungsi yang melewati array:

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

Kode berikut ini berfungsi untuk saya:

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

Iterasi melalui, melacak saat Anda pergi.

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

Ini akan meninggalkan min / max null jika tidak ada elemen dalam array. Akan menetapkan min dan maks dalam satu lintasan jika array memiliki elemen apa pun.

Anda juga dapat memperluas Array dengan rangemetode menggunakan di atas untuk memungkinkan penggunaan kembali dan meningkatkan keterbacaan. Lihat biola yang berfungsi di 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 }
};

Digunakan sebagai

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

var range = arr.range();

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

Saya pikir saya akan membagikan solusi saya yang sederhana dan mudah dipahami.

Untuk min:

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

Dan untuk maks:

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

Hal-hal sederhana, sungguh.

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

Inilah salah satu cara untuk mendapatkan nilai maksimal dari berbagai objek. Buat salinan (dengan irisan), lalu urutkan salinan dalam urutan menurun dan ambil item pertama.

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; 

Menggunakan Math.max()atauMath.min()

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

Fungsi berikut digunakan Function.prototype.apply()untuk menemukan elemen maksimum dalam array numerik. getMaxOfArray([1, 2, 3])setara dengan Math.max(1, 2, 3), tetapi Anda dapat menggunakan getMaxOfArray()pada array yang dibangun secara terprogram dari berbagai ukuran.

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

Atau dengan operator spread baru, mendapatkan array maksimum menjadi jauh lebih mudah.

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

Selain menggunakan fungsi matematika maks dan min, fungsi lain yang digunakan adalah fungsi bawaan sortir (): ayo kita mulai

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

Solusi ChaosPandion berfungsi jika Anda menggunakan protoype. Jika tidak, pertimbangkan ini:

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

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

Di atas akan mengembalikan NaN jika nilai array bukan bilangan bulat sehingga Anda harus membangun beberapa fungsi untuk menghindarinya. Kalau tidak, ini akan berhasil.

Jika Anda menggunakan library sugar.js , Anda dapat menulis arr.min () dan arr.max () seperti yang Anda sarankan. Anda juga bisa mendapatkan nilai min dan maks dari array non-numerik.

min (peta, semua = false) Mengembalikan elemen dalam array dengan nilai terendah. map bisa berupa fungsi yang memetakan nilai yang akan diperiksa atau string yang bertindak sebagai jalan pintas. Jika semuanya benar, akan mengembalikan semua nilai min dalam array.

maks (peta, semua = false) Mengembalikan elemen dalam array dengan nilai terbesar. map bisa berupa fungsi yang memetakan nilai yang akan diperiksa atau string yang bertindak sebagai jalan pintas. Jika semuanya benar, akan mengembalikan semua nilai maks dalam array.

Contoh:

[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"]

Perpustakaan seperti Lo-Dash dan underscore.js juga menyediakan fungsi min dan maks yang kuat serupa:

Contoh dari Lo-Dash:

_.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

Mencoba

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

Untuk Math.min / maks (+ terapkan) kami mendapatkan kesalahan:

Ukuran tumpukan panggilan maksimum terlampaui (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