Dmitri Pavlutin
Thoughts on Frontend development

Infinity in JavaScript

Infinity in JavaScript is a special number with an interesting property: it’s bigger than any finite number.

Without knowing the properties of Infinity in advance, you might be surprised how infinite numbers perform in conditionals and arithmetical operations.

Let’s look at the properties of Infinity number in JavaScript, understand the use cases and be aware of common pitfalls.

1. The definition of Infinity

The ECMAScript standard describes Infinity as follows:

There are two other special values, called positive Infinity and negative Infinity. […] Note that these two infinite Number values are produced by the program expressions +Infinity (or simply Infinity) and -Infinity.

Which means that Infinity, as well as -Infinity (the number small than any finite number) are special values of type number:

typeof Infinity;  // => 'number'
typeof -Infinity; // => 'number'

Infinity is a property on the global object. For instance in a browser:

window.Infinity; // => Infinity

Note that Number function has 2 properties holding the infinite values as well:

Number.POSITIVE_INFINITY; // => Infinity
Number.NEGATIVE_INFINITY; // => -Infinity

2. The properties of Infinity

Infinity is bigger than any finite number.

Let’s see some examples:

Infinity > 100;                     // => true
Infinity > Number.MAX_SAFE_INTEGER; // => true
Infinity > Number.MAX_VALUE;        // => true

Infinity has interesting effects when used as an operand in arithmetical operations like addition, multiplication and division:

Infinity + 1;        // => Infinity
Infinity + Infinity; // => Infinity

Infinity * 2;        // => Infinity
Infinity * Infinity; // => Infinity

Infinity / 2;        // => Infinity

Some operations with Infinity result in finite numbers:

10 / Infinity; // => 0

Dividing a finite number by 0 results in Infinity:

2 / 0; // => Infinity

Making conceptually incorrect operations on infinite numbers results in NaN. For example, you can’t divide infinite numbers, and you cannot determine if an infinite number is odd or even:

Infinity / Infinity; // => NaN
Infinity % 2;        // => NaN

2.1 The negative infinity

-Infinity (the negative infinity) is smaller than any finite number.

Let’s compare -Infinity with some finite numbers:

-Infinity < 100;                      // => true
-Infinity < -Number.MAX_SAFE_INTEGER; // => true
-Infinity < -Number.MAX_VALUE;        // => true

At the same time, negative infinity is smaller than positive infinity:

-Infinity < Infinity; // => true

You might end up in negative infinity when using operands of different signs:

Infinity * -1; // => -Infinity
Infinity / -2; // => -Infinity
-2 / 0;        // => -Infinity

3. Checking for Infinity

Fortunately, an infinite value equals to an infinite value of the same sign:

Infinity === Infinity; // => true
-Infinity === -Infinity; // => true

Because of different signs Infinity doesn’t equal -Infinity:

Infinity === -Infinity; // => false

JavaScript has a special function Number.isFinite(value) that checks whether the provided value is finite:

Number.isFinite(Infinity);  // => false
Number.isFinite(-Infinity); // => false
Number.isFinite(999);       // => true

4. Infinity use cases

The infinity value is handy when you’d like to initialize computations involving comparisons of numbers.

For example, when searching for a minimum value in an array:

function findMin(array) {
  let min = Infinity;  for (const item of array) {
    min = Math.min(min, item);
  }
  return min;
}

findMin([5, 2, 1, 4]); // => 1

The min variable is initialized with Infinity. On first for() iteration the minimum value becomes the first item.

5. Pitfalls of Infinity

Most likely you won’t work directly with Infinity values so often. However, it worth knowing when the infinite values could appear.

5.1 Parsing numbers

Let’s say JavaScript uses an input (POST request, value from an input field, etc) to parse a number. In simple cases it would work fine:

// Parses the float number
parseFloat('10.5'); // => 10.5

// Indicates an invalid number
parseFloat('ZZZ'); // => NaN

Care must be taken because 'Infinity' string is parsed by parseFloat() as an actual Infinity number:

parseFloat('Infinity'); // => Infinity

It should be a validation error when the user introduces the 'Infinity' string into a numeric input field.

An alternative could be parseInt() to parse integers. It doesn’t recongize 'Infinity' as an integer:

parseInt('10', 10); // => 10

parseInt('Infinity', 10); // => NaN

5.2 JSON serialization

JSON.stringify() serializes an Infinity number to null.

const worker = {
 salary: Infinity
};

JSON.stringify(worker); // => '{ "salary": null }'

salary property is Infinity. But when stringified to JSON, "salary" becomes null.

5.3 Max number overflow

Number.MAX_VALUE is the biggest float number in JavaScript.

Trying to use a number even bigger than Number.MAX_VALUE, JavaScript transforms such number to Infinity:

2 * Number.MAX_VALUE; // => Infinity
Math.pow(10, 1000);   // => Infinity

5.4 Math functions

Some functions of Math namespace in JavaScript can return infinite numbers.

Here are a few examples:

const numbers = [1, 2];
const empty = [];

Math.max(...numbers); // => 2
Math.max(...empty);   // => -Infinity
Math.min(...numbers); // => 1
Math.min(...empty);   // => Infinity

Math.max() when invoked without arguments returns -Infinity, and Math.min() correspondingly Infinity. That could be a surprise if you try to determine the max or min of an empty array.

Here’s an interesting math discussion why that happens.

6. Key takeaway

Infinity in JavaScript represents the concept of an infinite number. Any finite number is smaller than Infinity, and any finite number is bigger -Infinity.

Comparing infinite values in JavaScript is easy: Infinity === Infinity is true. The special function Number.isFinite() determines if the supplied argument is a finite number.

You can initialize variables with Infinite when starting an algorithm that involves a comparison of numbers. A use case is finding the minimum of an array.

Care must be taken with Infinity when parsing numbers from inputs: Number('Infinity'), parseFloat('Infinity') return the actual Infinity number. When serialized with JSON.stringify(), the infinite number becomes null.

Hopefully, after reading my post you have a better idea of infinite numbers!

Love the post? Please share!

Quality posts to your inbox

I regularly publish posts containing:

  • Important JavaScript concepts explained in simple words
  • Overview of new JavaScript features
  • React best practices and design patterns

Subscribe to my newsletter to get them right to your inbox.

About Dmitri Pavlutin

I'm a software developer and tech writer specialized in Frontend technologies. I like to read books, run and travel the world.