Làm cách nào tôi có thể tìm thấy số lớn nhất có trong một mảng JavaScript?

Tôi có một đối tượng JavaScript Array đơn giản chứa một vài số.

[267, 306, 108]

Có một chức năng sẽ tìm thấy số lượng lớn nhất trong mảng này?

Resig để giải cứu:

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

Cảnh báo : vì số lượng đối số tối đa thấp nhất là 65535 trên một số máy ảo , hãy sử dụng vòng lặp for nếu bạn không chắc chắn mảng đó nhỏ.

Bạn có thể sử dụng hàm áp dụng, để gọi Math.max :

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

Làm thế nào nó hoạt động?

Hàm áp dụng được sử dụng để gọi một hàm khác, với ngữ cảnh và đối số đã cho, được cung cấp dưới dạng một mảng. Các hàm tối thiểu và tối đa có thể lấy một số lượng đối số đầu vào tùy ý: Math.max (val1, val2, ..., valN)

Vì vậy, nếu chúng ta gọi:

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

Hàm áp dụng sẽ thực thi:

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

Lưu ý rằng tham số đầu tiên, bối cảnh, không quan trọng đối với các hàm này vì chúng là tĩnh, chúng sẽ hoạt động bất kể những gì được truyền dưới dạng bối cảnh.

Cú pháp dễ nhất, với toán tử trải rộng mới :

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

Nguồn: Mozilla MDN

Tôi không phải là chuyên gia về JS, nhưng tôi muốn xem các phương thức này xếp chồng lên nhau như thế nào, vì vậy đây là cách thực hành tốt cho tôi. Tôi không biết liệu đây có phải là cách đúng đắn để kiểm tra hiệu năng hay không, nhưng tôi chỉ chạy chúng ngay sau đó, như bạn có thể thấy trong mã của mình.

Sắp xếp và nhận giá trị 0 là phương pháp tồi tệ nhất (và nó sửa đổi thứ tự của mảng của bạn, điều này có thể không được mong muốn). Đối với những người khác, sự khác biệt là không đáng kể trừ khi bạn nói hàng triệu chỉ số.

Kết quả trung bình của năm lần chạy với một dãy số ngẫu nhiên 100.000 chỉ số:

• giảm mất 4.092ms để chạy
• Math.max.apply mất 3,3742ms để chạy
• sắp xếp và nhận giá trị thứ 0 mất 67,4724ms để chạy
• Math.max trong vòng giảm () mất 6,5804ms để chạy
• chức năng findmax tùy chỉnh mất 1.6102ms để chạy

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)

Tôi đã thấy rằng đối với các mảng lớn hơn (~ 100 nghìn phần tử), nó thực sự trả tiền để đơn giản lặp lại mảng với một forvòng lặp khiêm tốn , thực hiện tốt hơn ~ 30% so với 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;
}

Kết quả điểm chuẩn

Bạn có thể sắp xếp mảng theo thứ tự giảm dần và nhận mục đầu tiên:

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

Còn cái này thì sao:

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

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

console.log(largest);

Làm thế nào về việc sử dụng Array.reduce ?

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

Hầu như tất cả các câu trả lời sử dụng Math.max.apply()là tốt và đẹp nhưng có những hạn chế.

Các đối số chức năng được đặt trên ngăn xếp có nhược điểm - giới hạn. Vì vậy, nếu mảng của bạn lớn hơn giới hạn, nó sẽ thất bại vớiRangeError: Maximum call stack size exceeded.

Để tìm kích thước ngăn xếp cuộc gọi, tôi đã sử dụng mã này:

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

Nó được chứng minh là lớn nhất trên FireFox trên máy của tôi - 591519 . Điều này có nghĩa là nếu mảng của bạn chứa hơn 591519 mục, Math.max.apply()sẽ dẫn đến RangeError .

Giải pháp tốt nhất cho vấn đề này là cách lặp (tín dụng: 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];
}

Tôi đã viết về câu hỏi này trên blog của tôi ở đây .

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

Tìm giá trị tối đa và tối thiểu một cách dễ dàng và thủ công. Mã này nhanh hơn nhiều Math.max.apply; Tôi đã thử tới 1000k số trong mảng.

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

Để tìm số lớn nhất trong một mảng bạn chỉ cần sử dụng Math.max(...arrayName);, nó hoạt động như thế này:

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

Để tìm hiểu thêm về Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Có tất nhiên tồn tại: Math.max.apply(null,[23,45,67,-45]) và kết quả trả về 67;

Đơn giản một lót

[].sort().pop()

Đừng quên rằng gói có thể được thực hiện với Function.prototype.bind, cung cấp cho bạn một chức năng "tất cả bản địa" .

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

Bạn cũng có thể mở rộng Arrayđể có chức năng này và biến nó thành một phần của mỗi mảng.

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

console.log( myArray.max() );

Bạn cũng có thể sử dụng 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

Sử dụng - Array.prototype.reduce()thật tuyệt!

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

trong đó acc = ắc quy và val = giá trị hiện tại ;

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

console.log(a);

Bạn có thể thử điều này,

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

Tôi mới bắt đầu với JS nhưng tôi nghĩ phương pháp này sẽ tốt:

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

Tìm số lớn nhất trong một mảng nhiều chiều

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;

Chạy cái này:

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

Và bây giờ hãy thử [3,10,2].max()trả lại10

Tìm giá trị Max và Min bằng cách sử dụng 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]);

Thử cái này

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

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

  return currentLongest
}

Theo nhận xét của @ Quasimondo , dường như đã bị bỏ lỡ phần lớn, bên dưới dường như có hiệu suất tốt nhất như được hiển thị ở đây: https://jsperf.com/finding-maximum-element-in-an-array . Lưu ý rằng trong khi đối với mảng trong câu hỏi, hiệu suất có thể không có ảnh hưởng đáng kể, đối với hiệu suất mảng lớn trở nên quan trọng hơn và một lần nữa như đã lưu ý khi sử dụng Math.max()thậm chí không hoạt động nếu độ dài mảng lớn hơn 65535. Xem thêm câu trả lời này .

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

Một cách tiếp cận đệ quy về cách thực hiện bằng cách sử dụng các toán tử 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);

for/ofGiải pháp một vòng lặp:

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