javascript - 如何找到 JavaScript 数组中包含的最大数？

Question

我有一个包含几个数字的简单 JavaScript 数组对象。

[267, 306, 108]

有没有一个函数可以在这个数组中找到最大的数？

score 320 · Accepted Answer

辞职救援：

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

警告：由于某些 VM 上的最大参数数量低至 65535，如果您不确定数组有那么小，请使用 for 循环。

score 205 · Accepted Answer

您可以使用 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]);

应用函数将执行：

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

请注意，第一个参数 context 对于这些函数并不重要，因为它们是静态的。无论作为上下文传递什么，它们都将起作用。

score 64 · Accepted Answer

最简单的语法，使用新的扩展运算符：

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

来源：Mozilla MDN

score 45 · Accepted Answer

我不是 JavaScript 专家，但我想看看这些方法是如何叠加的，所以这对我来说是个好习惯。我不知道这在技术上是否是对这些进行性能测试的正确方法，但我只是一个接一个地运行它们，正如您在我的代码中看到的那样。

排序并获取第 0 个值是迄今为止最糟糕的方法（它会修改数组的顺序，这可能是不可取的）。对于其他人，除非您谈论数百万个索引，否则差异可以忽略不计。

使用 100,000 索引的随机数数组运行五次的平均结果：

reduce运行时间为4.0392 毫秒
Math.max.apply运行时间为3.3742 毫秒
排序和获取第 0 个值需要67.4724 毫秒才能运行
reduce() 中的 Math.max 需要6.5804 毫秒才能运行
自定义 findmax 函数需要1.6102 毫秒才能运行

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)

score 37 · Accepted Answer

我发现对于更大的数组（约 10 万个元素），实际上只需用一个不起眼的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;
}

基准测试结果

score 33 · Accepted Answer

您可以按降序对数组进行排序并获取第一项：

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

score 29 · Accepted Answer

采用：

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

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

console.log(largest);

score 8 · Accepted Answer

使用Array.reduce：

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

score 5 · Accepted Answer

几乎所有的答案都使用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];
}

我已经在我的博客上写过这个问题。

score 5 · Accepted Answer

以简单和手动的方式查找最大值和最小值。这段代码比Math.max.apply;快得多我在数组中尝试了多达 1000k 个数字。

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

score 5 · Accepted Answer

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

score 5 · Accepted Answer

要查找数组中的最大数，您只需使用Math.max(...arrayName);. 它是这样工作的：

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

要了解更多信息Math.max： https ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

score 4 · Accepted Answer

4

简单的一班轮

[].sort().pop()

于 2019-10-07T09:45:15.743 回答

score 3 · Accepted Answer

3

是的，当然存在Math.max.apply(null,[23,45,67,-45]) ，结果是返回67。

于 2015-02-01T15:34:37.860 回答

score 1 · Accepted Answer

不要忘记 wrap 可以用来完成Function.prototype.bind，给你一个“全原生”的功能。

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

score 1 · Accepted Answer

您还可以扩展Array以具有此功能并使其成为每个数组的一部分。

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

console.log( myArray.max() );

score 1 · Accepted Answer

您还可以使用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

score 1 · Accepted Answer

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

score 1 · Accepted Answer

你可以试试这个

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

score 1 · Accepted Answer

我刚开始使用 JavaScript，但我认为这种方法会很好：

var array = [34, 23, 57, 983, 198];
var score = 0;

for(var i = 0; i = array.length; i++) {
  if(array[ i ] > score) {
    score = array[i];
  }
}

score 1 · Accepted Answer

关于如何使用三元运算符的递归方法

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

score 1 · Accepted Answer

var nums = [1,4,5,3,1,4,7,8,6,2,1,4];
nums.sort();
nums.reverse();
alert(nums[0]);

最简单的方法：

var nums = [1,4,5,3,1,4,7,8,6,2,1,4]; nums.sort(); nums.reverse(); alert(nums[0]);

score 0 · Accepted Answer

查找多维数组中的最大数

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;

score 0 · Accepted Answer

运行这个：

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

现在尝试[3,10,2].max()返回10

score 0 · Accepted Answer

使用冒泡排序查找最大值和最小值

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

score 0 · Accepted Answer

试试这个

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

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

  return currentLongest
}

score 0 · Accepted Answer

根据@Quasimondo 的评论，这似乎在很大程度上被遗漏了，下面似乎有最好的性能，如下所示：https ://jsperf.com/finding-maximum-element-in-an-array 。请注意，虽然对于问题中的数组，性能可能没有显着影响，但对于大型数组，性能变得更加重要，并且再次指出，如果数组长度超过 65535，则使用Math.max()甚至不起作用。另请参阅此答案。

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

score 0 · Accepted Answer

单循环for/of解决方案：

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

score 0 · Accepted Answer

我在数组中返回最大数字的解决方案。

const largestOfFour = arr => {
    let arr2 = [];
    arr.map(e => {
        let numStart = -Infinity;
        e.forEach(num => {
            if (num > numStart) {
                numStart = num;

            }
        })
        arr2.push(numStart);
    })
    return arr2;
}

score 0 · Accepted Answer

应该很简单：

var countArray = [1,2,3,4,5,1,3,51,35,1,357,2,34,1,3,5,6];

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

console.log("Highest Count is " + highestCount);

score 0 · Accepted Answer

使用箭头函数排序的最大值和最小值

var highest=[267, 306, 108,700,490,678,355,399,500,800].sort((a,b)=>{return b-a;})[0]
console.log(highest)
var smallest=[267, 306, 108,700,490,678,355,399,500,800].sort((a,b)=>{return a-b;})[0]
console.log(smallest)

score -1 · Accepted Answer

-1

let array = [267, 306, 108]
let longest = Math.max(...array);

于 2020-10-03T15:07:23.503 回答

javascript - 如何找到 JavaScript 数组中包含的最大数？

32 回答 32

查找多维数组中的最大数

Related

Reference