JavaScript - Numbers and Math

Numbers in JavaScript include both integers and floating point numbers as just a single Number type. This is unlike some other programming languages like C# which distinguish between the many types of numbers depending on the size of the number and space taken up in memory. Numbers in JavaScript can be very flexible, but also pose some risks depending on how they’re processed by the program.

JavaScript Numbers and Math
JavaScript Numbers and Math

Primitive number values have a Number object equivalent that wraps around the value and provide access to constants and methods that can be used to work with number values.

Creating Numbers

A new number can be created a few different ways:

  1. With the Number() function

  2. As a number literal

let myNumber = Number(481);
typeof myNumber; // 'number'

let anotherNumber = 326.74;
typeof anotherNumber; // 'number'

Converting to Numbers

It’s possible to convert values to numbers using a few different techniques. It’s important to be aware of how numbers are converted since they can sometimes produce expected results.

  1. Convert a value using the Number() function

  2. Convert a value by placing a + value before the value

  3. Use the parseFloat() or parseInt() functions. The parseFloat function will attempt return a float value upon evaluating the passed parameter. Similarly, the parseInt function will attempt to return a integer value upon evaluation of the passed parameter. In cases where a float value passed as a string is used with the parseInt function, only the integer segment of the value will be returned.

let total = '36226.72';
let numberTotal = Number(total);
numberTotal; // 36226.72

let myAge = '21';
+myAge; // 21

let myPrice = '51.85';
parseFloat(myPrice); // 51.85
parseInt(myPrice); // 51

The examples above show conversion of strings containing numbers to Numbers. It’s important to understand how the results vary depending on how the string is constructed. For example, strings that include non-numeric characters will produce different results depending on how the string is constructed.

let myPayment = '$24.64';
let mySecondPayment = '75.25 dollars';

Number(myPayment); // NaN
parseInt(myPayment); // NaN

Number(mySecondPayment); // NaN
parseInt(mySecondPayment); // 75
parseFloat(mySecondPayment); // 75.25

If the function Number() encounters a non-numeric character it will produce a NaN result. By contrast, both parseInt() and parseFloat() will terminate once encountering a non-numeric character. In cases when

Boolean values can also be converted into numbers. This is sometimes useful, especially is data is being boolean data is being stored in a data object or databases and needs to be converted to a number.

+true; // 1
+false; // 0

Number(true); // 1
Number(false); // 0

parseInt(true); // NaN
parseInt(false); // NaN

parseFloat(true); // NaN
parseFloat(false); // NaN

The other primitive values of null and undefined can also be converted into numbers by adding a + before each.

+null; // 0
+undefined; // NaN

These examples show that there are many ways to create numbers and how convert different data types into numbers. These are common actions performed during a program and often needed when getting data from form inputs. For example, form fields that collect numeric data store the data as a string and should be checked and converted to a number to avoid any arithmetic errors.


Math is a built-in JavaScript object that works with number value types. The Math object is not a constructor since it only has static properties and methods and cannot be created as an instance of a Math object. The Math object is useful to provide useful constant values, such as PI, and perform common mathematical operations like producing a random number, to show a few examples.

Examples of Math properties and methods

Some of the most useful Math properties include PI and E, two mathematical constants.

let pi = Math.PI;
pi; // 3.141592653589793

let e = Math.E;
e; // 2.718281828459045

The Math object has many methods that are very useful. These include useful methods like trigonometry functions such as methods to calculate sine, cosine, tangent. There’s also useful methods like rounding values, calculating the floor or ceiling of a number, or even producing a random number.

A good example of the usefulness of these mathematical methods is using several of them in combination to produce a random number between two values.

let randomBetween = function (min, max) {
  const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
  return randomNumber;

randomBetween(1, 100); // 23


Using numbers and performing complex calculations is integral to programming with JavaScript. Having a good awareness of how to create numbers and convert other value types into numbers is important to make programs work as desired and avoid costly errors.