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

我有一个简单的JavaScript数组对象，其中包含一些数字

[267, 306, 108]

是否有一个函数可以查找此数组中的最大数字？

---

警告：因为，如果您不确定数组是否那么小，请使用for循环。

您可以使用apply函数调用：

它是如何工作的

该函数用于调用另一个函数，该函数具有给定的上下文和参数，作为数组提供。min和max函数可以接受任意数量的输入参数：Math.max（val1，val2，…，valN）

因此，如果我们呼吁：

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

应用功能将执行：

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

---

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

您可以按降序对数组排序，并获得第一项：

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

---

我发现，对于较大的数组（~100k个元素），实际上只需使用一个简单的

for

循环来迭代数组就可以了，其性能比

Math.max.apply（）好约30%：

几乎所有的答案都使用了
Math.max.apply（）
，这很好，很漂亮，但也有局限性

函数参数放在堆栈上，堆栈有一个缺点-限制。因此，如果数组大于限制，它将失败，并出现
RangeError:超出最大调用堆栈大小。

要查找调用堆栈大小，我使用以下代码：

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

我已经在我的博客上写过这个问题。
别忘了可以使用
Function.prototype.bind
完成包装，为您提供一个“纯本地”函数

找到最大值和最小值的简单和手动方式。此代码比
Math.max.apply
快得多；我在阵列中尝试了多达100000个数字

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

函数findmax（数组）
{
var max=0；
var a=数组长度；
用于（计数器=0；计数器最大值）
{
max=数组[计数器]；
}
}
返回最大值；
}
函数findmin（数组）
{
var min=数组[0]；
var a=数组长度；
对于（计数器=0；计数器使用：

您还可以扩展
Array
以拥有此函数，并使其成为每个数组的一部分

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

console.log( myArray.max() );

是的，当然存在
Math.max.apply（null[23,45,67，-45]）
，结果是返回
67
使用：

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

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

console.log(largest);

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

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

使用100000个随机数索引数组运行五次的平均结果：


减少运行时间4.0392 ms
Math.max.apply运行时间3.3742 ms
排序和获取第0个值需要67.4724 ms才能运行
reduce（）中的Math.max运行时间6.5804 ms
自定义findmax函数运行时间1.6102 ms


var performance=window.performance
函数findmax（数组）
{
var max=0，
a=数组长度，
柜台
用于（计数器=0；计数器最大值）
{
最大值=数组[计数器]
}
}
返回最大值
}
函数findBiggestNumber（num）{
变量计数=[]
变量i
对于（i=0；i计数？最高值：计数
}, 0)
b=性能。现在（）
log（'reduce-take'+（b-a）+'ms-to-run'）
a=性能。现在（）
var biggest2=Math.max.apply（数学，计数）
b=性能。现在（）
log（'Math.max.apply'+（b-a）+'ms to run'）
a=性能。现在（）
var biggest3=counts.sort（函数（a，b）{返回b-a；}）[0]
b=性能。现在（）
log（'排序和获取第0个值需要'+（b-a）+'毫秒才能运行'）
a=性能。现在（）
var biggest4=counts.reduce（函数（最高，计数）{
返回Math.max（最高，计数）
}, 0)
b=性能。现在（）
log（'Math.max in reduce（）使用'+（b-a）+'ms运行'）
a=性能。现在（）
var biggest5=findmax（计数）
b=性能。现在（）
log（'自定义findmax函数需要'+（b-a）+'毫秒才能运行'）
log（最大+'-'+biggest2+'-'+biggest3+'-'+biggest4+'-'+biggest5）
}
findBiggestNumber（1E5）
查找多维数组中的最大数字
最简单的语法，使用新的：

来源：
您还可以使用：


var max=Number.MIN\u SAFE\u整数；
var数组=[-3，-2217,9，-8,46]；
array.forEach（函数（值）{
如果（值>最大值）{
最大值=最大值；
}
});
console.log（最大）；/217使用-
Array.prototype.reduce（）
很酷

[267306108]。减少（（acc，val）=>（acc>val）？acc:val）

其中，acc=累加器和val=当前值


var a=[267306108]。减少（（acc，val）=>（acc>val）？acc:val）；
console.log（a）；
运行以下命令：

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

现在试试
[3,10,2].max（）
返回
10


constinputarray=[1,3,4,9,16,2,20,18]；
常量maxNumber=Math.max（…输入阵列）；
console.log（maxNumber）；
您可以试试这个

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

var-arr=[267306108]；
var largestNum=0；
对于（i=0；i最大）{
var最大=arr[i]；
}
}
控制台日志（最大）；
我刚开始使用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];
  }
}

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


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

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

console.log( myArray.max() );

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

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

console.log(largest);

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)

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;

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

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

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

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

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

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

  return currentLongest
}

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

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

[].sort().pop()

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

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

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