Find the Max Value in a JavaScript Array

Cover Image for Find the Max Value in a JavaScript Array

Though not as simple as some other languages, there are a few ways to find the largest number in a JavaScript array.

These solutions range from least-to-most convoluted. The first is preferable depending on your application's browser requirements and build process. Check it out:

Use Math.max() to find the largest array number

As the function name implies, Math.max() is handy when finding the max value within an array.

There are several ways to use Math.max(). Depending on your use case, one approach might be more appropriate than others.

Math.max() overview

Calling Math.max() without arguments returns -Infinity.

// -Infinity

If any value passed to Math.max() can not be converted to a number, NaN will be returned.

Math.max(1, 2, 3)
// 3

Math.max(1, 2, undefined, 3)
// NaN

Use Array.reduce()

Use this approach if you're working with a large array. Here's why:

both spread (...) and apply will either fail or return the wrong result if the array has too many elements, because they try to pass the array elements as function parameters.

An entire article could be written on this topic (and I will! I promise it has been added to the backlog). For now, we'll focus on the implementation.

The cut off for when to prefer this approach to others will depend on your application's runtime environment. If you're working with large arrays and your application runs on an end-user's browser, using Array.reduce() to find the maximum array value is a safe bet.

const getMaxValueFromArray = (arr) => {
  const maxArrayValue = arr.reduce((maxValue, currentArrayValue) => {
    return Math.max(maxValue, currentArrayValue);
  }, -Infinity);

  return maxArrayValue;

getMaxValueFromArray([10, 20, 30]);
// 30

Why use -Infinity as the reducer's initial value?

-Infinity is used as the reducer's initial value as all other possible number values are greater than -Infinity. Also, -Infinity is a number in JavaScript, which ensures getMaxValueFromArray always returns a number value. This is helpful if you're working with TypeScript.

Use the spread syntax

As demonstrated by the above example, Math.max() expects multiple comma-separated number values as arguments. The built-in method doesn't support being passed an array directly.

Here's how to use the spread syntax with Math.max() to find the max value,

const arr = [1, 3, 9999, 5, 6, 7]
const maxArrayValue = Math.max(...arr)
// maxArrayValue: 9999

This approach is decidedly simpler than using the Array.reduce() approach. However, as previously mentioned, using Array.reduce() in conjunction with Math.max() may be a better approach when working with large arrays.

Use the .apply to support Internet Explorer

Internet Explorer doesn't support the spread syntax. The above example may not work depending on your application's build process & browser support requirements.

Here's an approach for finding the max value in an array by using Math.max with .apply,

const arr = [1, 3, 9999, 5, 6, 7]
const maxArrayValue = Math.max.apply(this, arr)
// maxArrayValue: 9999

This approach is appropriate when working with relatively small arrays. If you're concerned that your array is too large, use the above Array.reduce() + Math.max() approach to find the max value in an array.

The spread syntax provides a slightly simpler approach to .apply. However, both approaches return the same value and function in the same manner behind the scenes.

Get the max value in array of objects

For the last example, let's look at how we can grab the maximum value from within an array of objects.

There are a few ways to do this, but the following is among the most concise while maintaining readability.

const arr = [
  { value: 1 },
  { value: 2 },
  { value: 3 },
  { value: 9999 },
  { value: 4 },
  { value: 5 },

const getMaxValueFromArrayOfObjects = (arr) => {
  const maxArrayValue = arr.reduce((maxValue, currentArrayObject) => {
    return Math.max(maxValue, currentArrayObject.value);
  }, -Infinity);

  return maxArrayValue;

// 9999

Bonus: How to find the min value in an array

Finding the minimum value in a JavaScript array is almost the same as finding the max. Instead of using Math.max() to find the value, use Math.min().

Below are the above examples with Math.max() swapped out for `Math.min().

Basic Math.min usage

Math.min(3, 1, 2)
// 1

Using Array.reduce() & Math.min() to get the min value

This solution is similar to the above approach for finding the maximum value. However, note the important difference.

getMinValueFromArray uses Infinity as the initial reducer value. This ensures the function always returns a number.

The above getMaxValueFromArray function uses -Infinity as the initial reducer function.

  • Infinity is a good initial reducer value when getting the minimum value from an array.
  • -Infinity is the appropriate initial reducer value when finding the max array value.
const getMinValueFromArray = (arr) => {
  const minArrayValue = arr.reduce((minValue, currentArrayValue) => {
    return Math.min(minValue, currentArrayValue);
  }, Infinity);

  return minArrayValue;

getMinValueFromArray([30, 10, 20]);
// 10

Use the spread syntax to find the min value

const arr = [3000, 2000, 1, 1000, 4000]
const minArrayValue = Math.min(...arr)
// minArrayValue: 1

Use the Math.min.apply to get the min

As previously mentioned, Internet Explorer doesn't support the spread syntax. If your application's build process doesn't support the spread syntax, use Math.min.apply.

const arr = [3000, 2000, 1, 1000, 4000]
const minArrayValue = Math.min.apply(this, arr)
// minArrayValue: 1


The MDN Web Docs rock. Check out these handy JavaScript references for more information: