JavaScript 배열의 최소 또는 최대 요소를 쉽게 얻을 수있는 방법은 무엇입니까?

유사 코드 예 :

let array = [100, 0, 50]

array.min() //=> 0
array.max() //=> 100

Math.max/ Math.min대신 사용하도록 내장 Array 객체를 보강하는 방법은 다음과 같습니다.

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

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

다음은 JSFiddle 입니다.

내장 기능을 보강하면 다른 라이브러리와 충돌 할 수 있으므로 (일부 참조) 배열에 직접 연결 apply하는 것이 더 편할 수 있습니다 Math.xxx().

var min = Math.min.apply(null, arr),
    max = Math.max.apply(null, arr);

또는 브라우저가 ECMAScript 6을 지원한다고 가정 하면 메소드 와 유사한 기능을 하는 스프레드 연산자 를 사용할 수 있습니다 apply.

var min = Math.min( ...arr ),
    max = Math.max( ...arr );

var max_of_array = Math.max.apply(Math, array);

자세한 내용은 http://aaroncrane.co.uk/2008/11/javascript_max_api/를 참조하십시오.

큰 배열 (~ 10⁷ 요소)의 경우 Math.min와 Math.max모두 Node.js.에서 다음과 같은 오류가 발생합니다

RangeError : 최대 호출 스택 크기를 초과했습니다

보다 강력한 솔루션은 모든 요소를 ​​호출 스택에 추가하는 것이 아니라 배열을 전달하는 것입니다.

function arrayMin(arr) {
  return arr.reduce(function (p, v) {
    return ( p < v ? p : v );
  });
}

function arrayMax(arr) {
  return arr.reduce(function (p, v) {
    return ( p > v ? p : v );
  });
}

속도가 걱정된다면 다음 코드가 Math.max.apply컴퓨터 보다 ~ 3 배 빠릅니다 . http://jsperf.com/min-and-max-in-array/2를 참조하십시오 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (arr[len] < min) {
      min = arr[len];
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (arr[len] > max) {
      max = arr[len];
    }
  }
  return max;
};

배열에 숫자 대신 문자열이 포함 된 경우 숫자로도 강제 변환해야합니다. 아래 코드는 그렇게하지만 내 컴퓨터에서 코드가 ~ 10 배 느려집니다. http://jsperf.com/min-and-max-in-array/3를 참조하십시오 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (Number(arr[len]) < min) {
      min = Number(arr[len]);
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (Number(arr[len]) > max) {
      max = Number(arr[len]);
    }
  }
  return max;
};

스프레드 연산자 (ES6) 사용

Math.max(...array);  // the same with "min" => Math.min(...array);

const array = [10, 2, 33, 4, 5];

console.log(
  Math.max(...array)
)

tl; dr

// For regular arrays:
var max = Math.max(...arrayOfNumbers);

// For arrays with tens of thousands of items:
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

MDN 솔루션

에 공식 MDN 워드 프로세서Math.max() 이미이 문제를 다루고 있습니다 :

다음 함수는 Function.prototype.apply () 를 사용 하여 숫자 형 배열에서 최대 요소를 찾습니다. getMaxOfArray([1, 2, 3])와 동일 Math.max(1, 2, 3)하지만 getMaxOfArray()어떤 크기의 프로그래밍 방식으로 구성된 배열에 사용할 수 있습니다 .

function getMaxOfArray(numArray) {
    return Math.max.apply(null, numArray);
}

또는 새로운 스프레드 연산자 를 사용하면 최대 배열을 얻는 것이 훨씬 쉬워집니다.

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

배열의 최대 크기

MDN에 따르면apply 및 확산 솔루션은 한 인수의 최대 수의 제한에서 온 65536의 제한 :

그러나 이런 식으로 적용하면 JavaScript 엔진의 인수 길이 제한을 초과 할 위험이 있습니다. 너무 많은 인수가있는 함수를 적용 한 결과 (수만 개의 인수 이상으로 생각) 는 엔진마다 다릅니다 ( JavaScriptCore는 하드 코딩 된 인수 한계 65536 ). 동작)이 지정되지 않았습니다. 일부 엔진은 예외가 발생합니다. 더 악의적으로, 다른 사람들은 실제로 적용된 함수에 전달되는 인수의 수를 임의로 제한합니다. 후자의 경우를 설명하기 위해 : 만약 그러한 엔진이 4 개의 인수의 한계를 가지고 있다면 (실제 한계는 물론 상당히 높음), 위의 예제에서 인수 5, 6, 2, 3이 적용되는 것처럼, 전체 배열보다는.

심지어 다른 솔루션에 비해 성능이 좋지 않은 하이브리드 솔루션도 제공합니다. 자세한 내용은 아래 성능 테스트를 참조하십시오.

2019 년의 실제 제한은 콜 스택의 최대 크기입니다 . 최신 Chromium 기반 데스크톱 브라우저의 경우 최소 또는 최대 apply또는 분산 을 찾는 경우 실제로 숫자 배열의 최대 크기는 ~ 120000 입니다. 이 위에 스택 오버플로가 발생하고 다음과 같은 오류가 발생합니다.

RangeError : 최대 호출 스택 크기를 초과했습니다

아래의 스크립트 ( 이 블로그 게시물을 기반으로 함 )를 사용하여 해당 오류를 발견하면 특정 환경의 한계를 계산할 수 있습니다.

경고! 이 스크립트를 실행하려면 시간이 걸리며 시스템 성능에 따라 브라우저 / 시스템 속도가 느려지거나 충돌 할 수 있습니다!

let testArray = Array.from({length: 10000}, () => Math.floor(Math.random() * 2000000));
for (i = 10000; i < 1000000; ++i) {
  testArray.push(Math.floor(Math.random() * 2000000));
  try {
    Math.max.apply(null, testArray);
  } catch (e) {
    console.log(i);
    break;
  }
}

큰 어레이에서의 성능

EscapeNetscape 의 의견 에 대한 테스트를 기반으로 100000 개의 항목이 있는 난수 배열에서만 5 가지 방법을 테스트하는 벤치 마크를 만들었습니다 .

2019 년 결과에 따르면 표준 루프 (BTW에는 크기 제한이 없음)가 가장 빠릅니다. apply스프레드 는 그 뒤를 잇고, 그 후 MDN의 하이브리드 솔루션 reduce이 가장 느리게 진행됩니다.

스프레드가 왜 가장 느리게 진행되는지를 제외하고는 거의 모든 테스트에서 동일한 결과를 얻었습니다.

백만 개의 항목을 갖도록 배열을 강화하면 문제가 발생하기 시작하고 표준 루프가 빠른 솔루션과 reduce느린 것으로 남게됩니다 .

JSPerf 벤치 마크

JSBen 벤치 마크

JSBench.me 벤치 마크

벤치 마크 소스 코드

var testArrayLength = 100000
var testArray = Array.from({length: testArrayLength}, () => Math.floor(Math.random() * 2000000));

// ES6 spread
Math.min(...testArray);
Math.max(...testArray);

// reduce
testArray.reduce(function(a, b) {
  return Math.max(a, b);
});
testArray.reduce(function(a, b) {
  return Math.min(a, b);
});

// apply
Math.min.apply(Math, testArray);
Math.max.apply(Math, testArray);

// standard loop
let max = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] > max) {
    max = testArray[i];
  }
}

let min = testArray[0];
for (let i = 1; i < testArrayLength; ++i) {
  if (testArray[i] < min) {
    min = testArray[i];
  }
}

// MDN hibrid soltuion
// Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Using_apply_and_built-in_functions
function minOfArray(arr) {
  var min = Infinity;
  var QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
    min = Math.min(submin, min);
  }

  return min;
}

minOfArray(testArray);

function maxOfArray(arr) {
  var max = -Infinity;
  var QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submax = Math.max.apply(null, arr.slice(i, Math.max(i + QUANTUM, len)));
    max = Math.max(submax, max);
  }

  return max;
}

maxOfArray(testArray);

사용에 대해 나처럼 편집증 경우 Math.max.apply(큰 배열을 부여 할 때 오류가 발생할 수있는 MDN에 따라 ),이 시도 :

function arrayMax(array) {
  return array.reduce(function(a, b) {
    return Math.max(a, b);
  });
}

function arrayMin(array) {
  return array.reduce(function(a, b) {
    return Math.min(a, b);
  });
}

또는 ES6에서 :

function arrayMax(array) {
  return array.reduce((a, b) => Math.max(a, b));
}

function arrayMin(array) {
  return array.reduce((a, b) => Math.min(a, b));
}

익명 함수는 불행하게도 필요한 (대신 사용하고 Math.max.bind(Math)있기 때문에 reduce단지 통과하지 못할 a와 b그 기능에, 또한 i우리는 우리가 전화를하지 않도록 할 수 있도록하고, 배열 자체에 대한 참조 max뿐만 아니라 이들에.

.apply 인수 값 목록과 함께 가변 함수를 호출하려는 경우에 자주 사용됩니다. 예 :

이 Math.max([value1[,value2, ...]])함수는 0보다 큰 숫자 중 가장 큰 숫자를 반환합니다.

Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20

이 Math.max()방법을 사용하면 배열을 전달할 수 없습니다. 당신이 값 목록이있는 경우 그 중 당신이 가장 큰 얻을 필요가, 당신은 일반적으로 사용하여이 함수를 호출 할 Function.prototype.apply의 () , 예를

Math.max.apply(null, [10, 20]); // 20
Math.max.apply(null, [-10, -20]); // -10
Math.max.apply(null, [-10, 20]); // 20

그러나 ECMAScript 6부터는 스프레드 연산자를 사용할 수 있습니다 .

spread 연산자를 사용하면 여러 인수 (함수 호출) 또는 여러 요소 (배열 리터럴)가 필요한 위치에서 표현식을 확장 할 수 있습니다.

스프레드 연산자를 사용하면 위와 같이 다시 작성할 수 있습니다.

Math.max(...[10, 20]); // 20
Math.max(...[-10, -20]); // -10
Math.max(...[-10, 20]); // 20

variadic 연산자를 사용하여 함수를 호출 할 때 추가 값을 추가 할 수도 있습니다 (예 :

Math.max(...[10, 20], 50); // 50
Math.max(...[-10, -20], 50); // 50

보너스:

Spread 연산자를 사용하면 ES5 push에서 splice, 등 의 조합을 사용하여 명령형 코드로 대체해야하는 상황에서 배열 리터럴 구문을 사용하여 새 배열을 작성할 수 있습니다 .

let foo = ['b', 'c'];
let bar = ['a', ...foo, 'd', 'e']; // ['a', 'b', 'c', 'd', 'e']

두 가지 방법이 더 짧고 쉽습니다.

let arr = [2, 6, 1, 0]

방법 1 :

let max = Math.max.apply(null, arr)

방법 2 :

let max = arr.reduce(function(a, b) {
    return Math.max(a, b);
});

배열 유형을 확장하여 수행하십시오.

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

에서 힘 입어 여기 (존 레식에 의해)

Array여러 요소에 대한 최소값을 찾는 간단한 솔루션 은 Array프로토 타입 함수 를 사용하는 것입니다 reduce.

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9

또는 JavaScript의 내장 Math.Min () 함수 사용 (@Tenflex 덕분에) :

A.reduce((min,val) => Math.min(min,val), A[0]);

이 설정 min에 A[0]이어서, 및 검사 용 A[1]...A[n]엄격히 적은 전류를 초과하는지 여부 min. 그렇다면 A[i] < min로 min업데이트됩니다 A[i]. 모든 배열 요소가 처리되면 min결과로 반환됩니다.

편집 : 최소값 위치 포함 :

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min._min ? {_min: val, _idx: min._curr, _curr: min._curr + 1} : {_min: min._min, _idx: min._idx, _curr: min._curr + 1}, {_min: A[0], _idx: 0, _curr: 0}); // returns { _min: -9, _idx: 2, _curr: 6 }

다른 사람들은 이미 그것들을 강화시키는 몇 가지 해결책을 제시했습니다 Array.prototype. 이 답변의 모든 I의 희망은 그것이 있어야 여부를 명확하게하는 것이다 Math.min.apply( Math, array )나 Math.min.apply( null, array ). 그래서 문맥 것은 사용되어야한다 Math나 null?

null에 컨텍스트로 전달 apply하면 컨텍스트는 기본적으로 전역 객체 ( window브라우저의 경우 객체)로 설정됩니다. Math컨텍스트로 객체를 전달하는 것이 올바른 해결책이지만 전달 null에도 해를 끼치 지 않습니다 . 다음 null은 Math.max함수를 장식 할 때 문제를 일으킬 수 있는 예입니다 .

// decorate Math.max
(function (oldMax) {
    Math.max = function () {
        this.foo(); // call Math.foo, or at least that's what we want

        return oldMax.apply(this, arguments);
    };
})(Math.max);

Math.foo = function () {
    print("foo");
};

Array.prototype.max = function() {
  return Math.max.apply(null, this); // <-- passing null as the context
};

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

print(max);

this.foo으로 평가 되기 때문에 위의 예외 window.foo가 발생 undefined합니다. 우리가 교체 할 경우 null에 Math예상 문자열 "foo는"이 화면에 인쇄 될 것 같은 상황이 작동합니다 (I이 사용하여 테스트 모질라 코뿔소 ).

아무도 Math.max그렇게 장식하지 않았다고 생각할 수 있습니다 null. 통과 는 문제없이 작동합니다.

그것을하는 또 다른 방법 :

var arrayMax = Function.prototype.apply.bind(Math.max, null);

용법:

var max = arrayMax([2, 5, 1]);

대체 방법

Math.min및 Math.max방법 모두 JS 엔진의 호출 스택에 추가되는 것을 재귀 적 연산, 가장 가능성있는 충돌 항목의 다수를 포함하는 배열은
(더 ~ 10⁷ 품목보다는 사용자의 브라우저에 따라 다름).

Math.max (... Array (1000000) .keys ());

잡히지 않은 RangeError : 최대 호출 스택 크기를 초과했습니다

대신 다음과 같이 사용하십시오.

arr.reduce((max, val) => max > val ? max : val, arr[0])

또는 더 나은 런타임으로 :

function maxValue(arr) {
  let max = arr[0];

  for (let val of arr) {
    if (val > max) {
      max = val;
    }
  }
  return max;
}

또는 Min과 Max를 모두 얻으려면 :

function getMinMax(arr) {
  return arr.reduce(({min, max}, v) => ({
    min: min < v ? min : v,
    max: max > v ? max : v,
  }), { min: arr[0], max: arr[0] });
}

또는 더 나은 런타임 *으로 :

function getMinMax(arr) {
  let min = arr[0];
  let max = arr[0];
  let i = arr.length;

  while (i--) {
    min = arr[i] < min ? arr[i] : min;
    max = arr[i] > max ? arr[i] : max;
  }
  return { min, max };
}

* 1,000,000 개 항목으로 테스트 :
참조 용으로, 첫 번째 기능 런타임 (내 컴퓨터)은 15.84ms 대 두 번째 기능은 4.32ms입니다.

이것은 귀하의 목적에 적합 할 수 있습니다.

Array.prototype.min = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.min);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

Array.prototype.max = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.max);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

var arr = [100, 0, 50];
console.log(getMaxOfArray(arr))

이것은 나를 위해 일했습니다.

축소 기능을 언급하지 않은 것에 놀랐습니다.

var arr = [1, 10, 5, 11, 2]

var b = arr.reduce(function(previous,current){ 
                      return previous > current ? previous:current
                   });

b => 11
arr => [1, 10, 5, 11, 2]

큰 배열 (~ 10⁷ 요소)의 경우 Math.min와Math.max procuces하면 RangeError node.js.에 (최대 호출 스택의 크기 초과)

큰 배열의 경우 빠르고 더러운 솔루션은 다음과 같습니다.

Array.prototype.min = function() {
    var r = this[0];
    this.forEach(function(v,i,a){if (v<r) r=v;});
    return r;
};

나는 같은 문제가 있었고 배열의 최소값과 최대 값을 얻어야했고 놀랍게도 배열에 대한 내장 함수가 없었습니다. 많은 내용을 읽은 후 "최고 3"솔루션을 직접 테스트하기로 결정했습니다.

1. 이산 솔루션 : 현재 최대 및 / 또는 최소 값에 대해 어레이의 모든 요소를 ​​확인하는 FOR 루프.
2. 적용 솔루션 : apply (null, array);를 사용하여 배열을 Math.max 및 / 또는 Math.min 내부 함수로 전송;
3. REDUCE 솔루션 : reduce (function)를 사용하여 배열의 모든 요소에 대해 검사를 반복합니다.

테스트 코드는 다음과 같습니다.

function GetMaxDISCRETE(A)
{   var MaxX=A[0];

    for (var X=0;X<A.length;X++)
        if (MaxX<A[X])
            MaxX=A[X];

    return MaxX;
}

function GetMaxAPPLY(A)
{   return Math.max.apply(null,A);
}

function GetMaxREDUCE(A)
{   return A.reduce(function(p,c)
    {   return p>c?p:c;
    });
}

어레이 A는 100,000 개의 임의의 정수로 채워졌으며, 각 기능은 Windows Vista가 설치된 Intel Pentium 4 2.99GHz 데스크탑의 Mozilla Firefox 28.0에서 10,000 번 실행되었습니다. 시간은 초 단위이며 performance.now () 함수에 의해 검색됩니다. 결과는 다음과 같으며 3 개의 소수 자릿수와 표준 편차가 있습니다.

1. 이산 솔루션 : 평균 = 0.161s, sd = 0.078
2. 적용 솔루션 : 평균 = 3.571s, sd = 0.487
3. REDUCE 솔루션 : 평균 = 0.350s, sd = 0.044

REDUCE 솔루션은 개별 솔루션보다 117 % 느 렸습니다. APPLY 솔루션은 개별 솔루션보다 2,118 % 느리게 나빴습니다. 또한 Peter가 관찰 한 것처럼 큰 배열 (약 1,000,000 개 이상의 요소)에서는 작동하지 않습니다.

또한 테스트를 완료하기 위해이 확장 된 이산 코드를 테스트했습니다.

var MaxX=A[0],MinX=A[0];

for (var X=0;X<A.length;X++)
{   if (MaxX<A[X])
        MaxX=A[X];
    if (MinX>A[X])
        MinX=A[X];
}

타이밍 : 평균 = 0.218s, sd = 0.094

따라서 단순 이산 솔루션보다 35 % 느리지 만 한 번에 최대 값과 최소값을 모두 검색합니다 (다른 솔루션은 검색하는 데 최소 두 배가 소요됨). 일단 OP가 두 값을 모두 필요로한다면, 이산 솔루션이 최선의 선택이 될 것입니다 (하나는 최대 값을 계산하기위한 함수와 최소값을 계산하기위한 함수 중 하나는 REDUCE 솔루션을 능가합니다).

프로젝트의 어느 곳에서나 다음 기능을 사용할 수 있습니다.

function getMin(array){
    return Math.min.apply(Math,array);
}

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

그런 다음 배열을 전달하는 함수를 호출 할 수 있습니다.

var myArray = [1,2,3,4,5,6,7];
var maximo = getMax(myArray); //return the highest number

다음 코드는 저에게 효과적입니다.

var valueList = [10,4,17,9,3];
var maxValue = valueList.reduce(function(a, b) { return Math.max(a, b); });
var minValue = valueList.reduce(function(a, b) { return Math.min(a, b); });

이동하면서 추적하면서 반복합니다.

var min = null;
var max = null;
for (var i = 0, len = arr.length; i < len; ++i)
{
    var elem = arr[i];
    if (min === null || min > elem) min = elem;
    if (max === null || max < elem) max = elem;
}
alert( "min = " + min + ", max = " + max );

배열에 요소가없는 경우 min / max는 null로 유지됩니다. 배열에 요소가있는 경우 한 번에 min과 max를 설정합니다.

range위 의 방법을 사용하여 Array를 확장 하여 재사용 성을 높이고 가독성을 향상시킬 수 있습니다. http://jsfiddle.net/9C9fU/ 에서 작동하는 바이올린을 참조하십시오.

Array.prototype.range = function() {

    var min = null,
        max = null,
        i, len;

    for (i = 0, len = this.length; i < len; ++i)
    {
        var elem = this[i];
        if (min === null || min > elem) min = elem;
        if (max === null || max < elem) max = elem;
    }

    return { min: min, max: max }
};

로 사용

var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];

var range = arr.range();

console.log(range.min);
console.log(range.max);

간단하고 이해하기 쉬운 솔루션을 공유한다고 생각했습니다.

최소 :

var arr = [3, 4, 12, 1, 0, 5];
var min = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] < min) {
    min = arr[k];
  }
}
console.log("Min is: " + min);

그리고 최대 :

var arr = [3, 4, 12, 1, 0, 5];
var max = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] > max) {
    max = arr[k];
  }
}
console.log("Max is: " + max);

수학 함수 max와 min을 사용하는 것 외에도 사용할 또 다른 함수는 sort ()의 내장 함수입니다.

const nums = [12, 67, 58, 30].sort((x, y) => 
x -  y)
let max = nums[0]
let min = nums[nums.length -1]

정말 간단한 것입니다.

var arr = [10,20,30,40];
arr.max = function() { return  Math.max.apply(Math, this); }; //attach max funct
arr.min = function() { return  Math.min.apply(Math, this); }; //attach min funct

alert("min: " + arr.min() + " max: " + arr.max());

다음은 객체 배열에서 최대 값을 얻는 한 가지 방법입니다. 슬라이스를 사용하여 복사본을 만든 다음 복사본을 내림차순으로 정렬하고 첫 번째 항목을 가져옵니다.

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

maxsort = myArray.slice(0).sort(function(a, b) { return b.ID - a.ID })[0].ID; 

Math.max()또는 사용Math.min()

Math.max(10, 20);   //  20
Math.min(-10, -20); // -20

다음 함수는 Function.prototype.apply()숫자 형 배열에서 최대 요소를 찾는 데 사용 합니다. getMaxOfArray([1, 2, 3])와 동일 Math.max(1, 2, 3)하지만 getMaxOfArray()어떤 크기의 프로그래밍 방식으로 구성된 배열에 사용할 수 있습니다 .

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

또는 새로운 스프레드 연산자를 사용하면 최대 배열을 얻는 것이 훨씬 쉬워집니다.

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

Protoype를 사용하는 경우 ChaosPandion의 솔루션이 작동합니다. 그렇지 않은 경우 다음을 고려하십시오.

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

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

위의 값은 배열 값이 정수가 아닌 경우 NaN을 반환하므로이를 피하기 위해 일부 기능을 빌드해야합니다. 그렇지 않으면 이것이 작동합니다.

sugar.js 라이브러리를 사용하면 다음 과 같이 작성할 수 있습니다. 제안한대로 arr.min () 및 arr.max () 를. 숫자가 아닌 배열에서 최소값과 최대 값을 얻을 수도 있습니다.

min (map, all = false) 배열에서 가장 낮은 값을 가진 요소를 반환합니다. map은 확인할 값을 매핑하는 함수이거나 바로 가기 역할을하는 문자열 일 수 있습니다. 모두 참이면 배열의 모든 최소값을 반환합니다.

max (map, all = false) 배열에서 가장 큰 값을 가진 요소를 반환합니다. map은 확인할 값을 매핑하는 함수이거나 바로 가기 역할을하는 문자열 일 수 있습니다. 모두 참이면 배열의 모든 최대 값을 반환합니다.

예 :

[1,2,3].min() == 1
['fee','fo','fum'].min('length') == "fo"
['fee','fo','fum'].min('length', true) == ["fo"]
['fee','fo','fum'].min(function(n) { return n.length; }); == "fo"
[{a:3,a:2}].min(function(n) { return n['a']; }) == {"a":2}
['fee','fo','fum'].max('length', true) == ["fee","fum"]

Lo-Dash 와 같은 라이브러리 underscore.js도 유사한 강력한 최소 및 최대 기능을 제공합니다.

Lo-Dash의 예 :

_.max([4, 2, 8, 6]) == 8
var characters = [
  { 'name': 'barney', 'age': 36 },
  { 'name': 'fred',   'age': 40 }
];
_.max(characters, function(chr) { return chr.age; }) == { 'name': 'fred', 'age': 40 }

let arr = [2,5,3,5,6,7,1];

let max = Math.max(...arr); // 7
let min = Math.min(...arr); // 1

시험

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

let max= a=> a.reduce((m,x)=> m>x ? m:x);
let min= a=> a.reduce((m,x)=> m<x ? m:x);

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

console.log('Max', max(arr));
console.log('Min', min(arr))

Math.min / max (+ apply)의 경우 오류가 발생합니다.

최대 통화 스택 크기를 초과했습니다 (Chrome 74.0.3729.131)

// TEST - pixel buffer
let arr = Array(200*800*4).fill(0); 
arr.forEach((x,i)=> arr[i]=100-i%101); 

// Exception: Maximum call stack size exceeded

try {
  let max1= Math.max(...arr);          
} catch(e) { console.error('Math.max :', e.message) }

try {
  let max2= Math.max.apply(null, arr); 
} catch(e) { console.error('Math.max.apply :', e.message) }


// same for min