JavaScript 배열에 포함 된 가장 큰 숫자를 어떻게 찾을 수 있습니까?

몇 개의 숫자를 포함하는 간단한 JavaScript Array 객체가 있습니다.

[267, 306, 108]

이 배열에서 가장 큰 숫자를 찾는 함수가 있습니까?

구조에 참여하십시오 :

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

경고 : 일부 VM의 경우 최대 인수 수는 65535 개 이므로 배열이 그렇게 작은 지 확실하지 않으면 for 루프를 사용하십시오.

apply 함수를 사용하여 Math.max 를 호출 할 수 있습니다 .

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

어떻게 작동합니까?

은 적용 함수 배열로 제공 주어진 컨텍스트와 인수와 다른 함수를 호출하는데 사용된다. min 및 max 함수는 임의의 수의 입력 인수를 사용할 수 있습니다. Math.max (val1, val2, ..., valN)

우리가 전화하면 :

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

적용 기능이 실행됩니다 :

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

첫 번째 매개 변수 인 컨텍스트는 정적이므로이 함수에는 중요하지 않으므로 컨텍스트로 전달되는 내용에 관계없이 작동합니다.

새로운 스프레드 연산자를 사용하는 가장 쉬운 구문 :

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

출처 : Mozilla MDN

저는 JS 전문가는 아니지만 이러한 방법이 어떻게 쌓이는 지 알고 싶었습니다. 이것이 기술적으로 성능을 테스트하는 올바른 방법인지는 모르겠지만 내 코드에서 볼 수 있듯이 하나씩 차례로 실행했습니다.

0 번째 값을 정렬하고 얻는 것은 최악의 방법입니다 (그리고 배열의 순서를 수정하므로 바람직하지 않을 수 있습니다). 다른 사람들에게는 수백만 개의 지표를 말하지 않는 한 그 차이는 무시할 수 있습니다.

100,000 개의 인덱스로 구성된 난수 배열로 5 회 실행 한 평균 결과 :

• 했다 줄일 4.0392ms를 실행
• Math.max.apply 를 실행하는 데 3.3742ms 가 걸렸습니다.
• 정렬하고 0 값을 얻는 데 67.4724ms 가 걸렸습니다.
• reduce () 내의 Math.max 를 실행하는 데 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)

더 큰 배열 (~ 100k 요소)의 경우 실제로는 다음 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;
}

벤치 마크 결과

배열을 내림차순으로 정렬하고 첫 번째 항목을 가져올 수 있습니다.

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

이건 어때요:

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

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

console.log(largest);

Array.reduce 를 사용하는 방법은 무엇입니까?

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

거의 모든 대답 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;
  }
}

내 컴퓨터 -591519의 FireFox에서 가장 큰 것으로 나타 났습니다 . 이는 배열에 591519 개 이상의 항목이 포함 된 경우 RangeErrorMath.max.apply() 가 발생 함을 의미합니다 .

이 문제에 대한 가장 좋은 해결책은 반복적 인 방법입니다 (신용 : 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];
}

내 블로그에이 질문에 대해 쓴 여기 .

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

최대 및 최소값을 쉽고 수동으로 찾는 방법. 이 코드는 다음보다 훨씬 빠릅니다 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;
}

배열에서 가장 큰 숫자를 찾으려면을 사용해야 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를

물론 존재합니다 : Math.max.apply(null,[23,45,67,-45]) 그리고 결과는 67;

간단한 하나의 라이너

[].sort().pop()

랩 Function.prototype.bind을 사용하여 "전부" 기능을 수행 할 수 있다는 것을 잊지 마십시오 .

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

Array이 기능을 확장 하여 모든 배열의 일부로 만들 수도 있습니다.

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

console.log( myArray.max() );

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

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

당신은 이것을 시도 할 수 있습니다

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

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

다차원 배열에서 가장 큰 숫자 찾기

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;

이것을 실행하십시오 :

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

그리고 이제 [3,10,2].max()반품을 시도하십시오10

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

이 시도

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

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

  return currentLongest
}

크게 놓친 것 같은 @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;
}

삼항 연산자를 사용하여 수행하는 방법에 대한 재귀 적 접근

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