Bagaimana saya bisa menemukan jumlah terbesar yang terkandung dalam array JavaScript?

Saya memiliki objek JavaScript Array sederhana yang berisi beberapa angka.

[267, 306, 108]

Apakah ada fungsi yang akan menemukan angka terbesar dalam array ini?

Resig untuk menyelamatkan:

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

Peringatan : karena jumlah maksimum argumen serendah 65535 pada beberapa VM , gunakan for for loop jika Anda tidak yakin arraynya sekecil itu.

Anda dapat menggunakan fungsi terapkan, untuk memanggil Math.max :

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

Bagaimana itu bekerja?

Fungsi terapkan digunakan untuk memanggil fungsi lain, dengan konteks dan argumen yang diberikan, disediakan sebagai array. Fungsi min dan maks dapat mengambil sejumlah argumen input yang berubah-ubah: Math.max (val1, val2, ..., valN)

Jadi, jika kita memanggil:

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

Fungsi yang berlaku akan menjalankan:

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

Perhatikan bahwa parameter pertama, konteksnya, tidak penting untuk fungsi-fungsi ini karena mereka statis, mereka akan bekerja terlepas dari apa yang dilewatkan sebagai konteks.

Sintaks termudah, dengan operator spread baru :

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

Sumber: Mozilla MDN

Saya bukan ahli JS, tetapi saya ingin melihat bagaimana metode ini menumpuk, jadi ini adalah praktik yang baik bagi saya. Saya tidak tahu apakah ini secara teknis cara yang tepat untuk menguji kinerja ini, tapi saya hanya menjalankannya satu per satu, seperti yang Anda lihat dalam kode saya.

Menyortir dan mendapatkan nilai 0 sejauh ini merupakan metode terburuk (dan itu mengubah urutan array Anda, yang mungkin tidak diinginkan). Bagi yang lain, perbedaannya dapat diabaikan kecuali Anda berbicara jutaan indeks.

Hasil rata-rata dari lima proses dengan array angka indeks 100.000 acak:

• mengurangi mengambil 4.0392ms untuk dijalankan
• Math.max.apply membutuhkan 3,3742ms untuk dijalankan
• menyortir dan mendapatkan nilai 0 butuh 67,4724 ms untuk dijalankan
• Math.max dalam pengurangan () membutuhkan 6.5804ms untuk dijalankan
• fungsi findmax khusus membutuhkan 1,6102ms untuk dijalankan

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)

Saya telah menemukan bahwa untuk array yang lebih besar (~ elemen 100k), sebenarnya membayar untuk hanya mengulangi array dengan forloop sederhana , berkinerja ~ 30% lebih baik daripada 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;
}

Hasil benchmark

Anda bisa mengurutkan array dalam urutan menurun dan mendapatkan item pertama:

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

Bagaimana dengan ini:

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

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

console.log(largest);

bagaimana dengan menggunakan Array.reduce ?

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

Hampir semua jawaban menggunakan Math.max.apply()yang bagus dan keren tetapi memiliki keterbatasan.

Argumen fungsi ditempatkan pada tumpukan yang memiliki sisi negatif - batas. Jadi jika array Anda lebih besar dari batas itu akan gagalRangeError: Maximum call stack size exceeded.

Untuk menemukan ukuran tumpukan panggilan saya menggunakan kode ini:

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

Itu terbukti menjadi yang terbesar di FireFox di mesin saya - 591519 . Ini berarti bahwa jika array Anda berisi lebih dari 5.915.19 item, Math.max.apply()akan menghasilkan RangeError .

Solusi terbaik untuk masalah ini adalah cara berulang (kredit: 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];
}

Saya telah menulis tentang pertanyaan ini di blog saya di sini .

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

Menemukan nilai maks dan minimum dengan cara mudah dan manual. Kode ini jauh lebih cepat daripada Math.max.apply; Saya telah mencoba hingga 1000 ribu angka dalam array.

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

Untuk menemukan angka terbesar dalam array yang hanya perlu Anda gunakan Math.max(...arrayName);, ini berfungsi seperti ini:

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

Untuk mempelajari lebih lanjut tentang Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Ya tentu saja ada: Math.max.apply(null,[23,45,67,-45]) dan hasilnya kembali 67;

Sederhana satu liner

[].sort().pop()

Jangan lupa bahwa membungkus dapat dilakukan dengan Function.prototype.bind, memberikan Anda "semua-asli" fungsi .

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

Anda juga dapat memperluas Arrayuntuk memiliki fungsi ini dan menjadikannya bagian dari setiap array.

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

console.log( myArray.max() );

Anda juga dapat menggunakan 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

Menggunakan - Array.prototype.reduce()keren!

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

di mana acc = akumulator dan val = nilai saat ini ;

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

console.log(a);

Anda dapat mencoba ini,

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

Saya baru saja mulai dengan JS tetapi saya pikir metode ini akan bagus:

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

Temukan angka terbesar dalam array multidimensi

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;

Jalankan ini:

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

Dan sekarang coba [3,10,2].max()kembali10

Temukan nilai Max dan Min menggunakan 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]);

Coba ini

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

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

  return currentLongest
}

Sesuai komentar @ Quasimondo , yang tampaknya sebagian besar telah dilewatkan, di bawah ini tampaknya memiliki kinerja terbaik seperti yang ditunjukkan di sini: https://jsperf.com/finding-maximum-element-in-an-array . Perhatikan bahwa sementara untuk array dalam pertanyaan, kinerja mungkin tidak memiliki efek yang signifikan, untuk kinerja array besar menjadi lebih penting, dan sekali lagi seperti yang dicatat menggunakan Math.max()bahkan tidak berfungsi jika panjang array lebih dari 65.535. Lihat juga jawaban ini .

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

Pendekatan rekursif tentang cara melakukannya menggunakan operator ternary

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

Satu for/ofsolusi loop:

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