Как я могу найти наибольшее число, содержащееся в массиве JavaScript?

Ответ 1

Resig на помощь:

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

Предупреждение: поскольку на некоторых виртуальных машинах максимальное количество аргументов составляет всего 65535, используйте цикл for, если вы не уверены, что массив настолько мал.

Ответ 2

Вы можете использовать функцию apply, чтобы вызвать Math.max:

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

Как это работает?

Функция apply используется для вызова другой функции с заданным контекстом и аргументами, представленными в виде массива. Функции min и max могут принимать произвольное количество входных аргументов: Math.max(val1, val2,..., valN)

Итак, если мы вызываем:

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

Функция apply выполнит:

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

Обратите внимание, что первый параметр, контекст, не важен для этих функций, поскольку они являются статическими, они будут работать независимо от того, что передается как контекст.

Ответ 3

Самый простой синтаксис с новым оператором распространения :

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

Источник: Mozilla MDN

Ответ 4

Я обнаружил, что для больших массивов (~ 100 тыс. элементов) на самом деле стоит просто перебрать массив с помощью смиренного цикла for, выполняя ~ 30% лучше, чем 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;
}

Результаты тестов

Ответ 5

Я не эксперт JS, но я хотел посмотреть, как складываются эти методы, поэтому для меня это была хорошая практика. Я не знаю, является ли это технически правильным способом тестирования производительности, но я просто запускал их один за другим, как вы можете видеть в моем коде.

Сортировка и получение 0-го значения на сегодняшний день является наихудшим методом (и он изменяет порядок вашего массива, что может быть нежелательно). Для остальных разница незначительна, если вы не говорите миллионы индексов.

Средние результаты пяти прогонов со 100 000-индексным массивом случайных чисел:

• уменьшить занял 4.0392мс для запуска
• Math.max.apply выполнил 3.3742ms для запуска
• сортировка и получение 0-го значения взяли 67.4724ms для запуска
• Math.max внутри reduce() взял 6.5804ms для запуска
• пользовательская функция findmax взяла 1,6102ms для запуска

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)

Ответ 6

Вы можете отсортировать массив в порядке убывания и получить первый элемент:

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

Ответ 7

Как насчет этого:

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

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

console.log(largest);

Ответ 8

как насчет использования Array.reduce?

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

Ответ 9

Почти во всех ответах используется Math.max.apply() что приятно и красиво, но имеет ограничения.

Аргументы функции помещаются в стек, который имеет обратную сторону - ограничение. Поэтому, если ваш массив больше предела, он потерпит неудачу с RangeError: Maximum call stack size exceeded.

Чтобы найти размер стека вызовов, я использовал этот код:

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

Это оказалось самым большим на FireFox на моей машине - 591519. Это означает, что если ваш массив содержит более 591519 элементов, Math.max.apply() приведет к RangeError.

Лучшее решение этой проблемы - итеративный способ (кредит: 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];
}

Я написал об этом вопросе в своем блоге здесь.

Ответ 10

Нахождение максимального и минимального значения простым и ручным способом. Этот код намного быстрее, чем Math.max.apply; Я пробовал до 1000 тысяч номеров в массиве.

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

Ответ 11

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

Ответ 12

Да, конечно, существуют: Math.max.apply(null,[23,45,67,-45]) и результат return 67;

Ответ 13

Чтобы найти наибольшее число в массиве, вам просто нужно использовать Math.max(...arrayName); , это работает так:

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

Таким образом, он получает наибольшее число в массиве и выводит его на консоль. Вы ставите тройные точки, потому что без него вы в основном пишете Math.max([1, 2, 3, 4, 5, 6]); что неправильно.

Ответ 14

Не забывайте, что обертку можно сделать с помощью Function.prototype.bind, предоставляя вам "все-родную" функцию.

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

Ответ 15

Вы также можете расширить Array, чтобы иметь эту функцию и сделать ее частью каждого массива.

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

console.log( myArray.max() );

Ответ 16

Вы также можете использовать 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

Ответ 17

Использование - Array.prototype.reduce() круто!

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

где acc = аккумулятор и val = текущее значение;

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

console.log(a);

Ответ 18

Вы можете попробовать это,

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

Ответ 19

Я только начал с JS, но я думаю, что этот метод будет хорош:

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

Ответ 20

Найти наибольшее число в многомерном массиве

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;

Ответ 21

Запустите это:

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

И теперь попробуйте [3,10,2].max() возвращает 10

Ответ 22

Найти максимальное и минимальное значение, используя 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]);

Ответ 23

Попробуй это

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

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

  return currentLongest
}

Ответ 24

В соответствии с комментарием @Quasimondo, который, по-видимому, в значительной степени пропущен, приведенная ниже, похоже, имеет лучшую производительность, как показано здесь: https://jsperf.com/finding-maximum-element-in-an-array. Обратите внимание, что хотя для рассматриваемого массива производительность может не оказать существенного влияния, для больших массивов производительность становится более важной, и, как уже было отмечено, использование Math.max() даже не работает, если длина массива превышает 65535. Смотрите также этот ответ.

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

Ответ 25

Рекурсивный подход к тому, как это сделать, используя троичные операторы

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

Ответ 26

Простой один вкладыш

[].sort().pop()