The Math Object in Practice

Math is a namespace of static functions for numeric work. Nothing on it needs a receiver, so every call is written as a method on Math itself.

console.log(Math.max(3, 1, 7));   // 7
console.log(Math.min(3, 1, 7));   // 1
console.log(Math.round(2.5));     // 3
console.log(Math.floor(2.9));     // 2
console.log(Math.ceil(2.1));      // 3
console.log(Math.trunc(-2.9));    // -2
console.log(Math.abs(-5));        // 5
console.log(Math.pow(2, 10));     // 1024
console.log(Math.sqrt(16));       // 4
console.log(Math.sign(-3));       // -1

The rounding family is the part worth understanding properly, because the members differ on negative numbers. Floor always rounds towards negative infinity, so it goes down. Ceil always rounds towards positive infinity, so it goes up. Trunc drops the fractional part, so it goes towards zero. And round rounds to the nearest integer, with halfway cases going towards positive infinity, which means a negative halfway value rounds up towards zero.

On top of those there are the numeric limits. The maximum safe integer is the largest integer that can be represented exactly as a double, which is nine quadrillion and change. Anything above that loses precision, and the maximum value itself is a much larger number that is not an integer. The epsilon constant is the gap between one and the next representable number, and it is the standard trick for correcting floating point rounding errors.

Math also holds the trigonometric functions, the logarithm and exponential functions, the hyperbolic variants, and a handful of helpers such as the sign function and the random number generator.

The naive approach fails on floating point values. Because most decimals cannot be represented exactly as a binary double, a value that looks like one and zero zero five is actually stored slightly below it, and rounding it produces the wrong answer.

console.log(Math.round(2.5));      // 3
console.log(Math.round(-2.5));     // -2 - halfway rounds toward positive infinity
console.log((1.005).toFixed(2));   // "1.00" - the stored value is just under 1.005

// Round to a number of decimal places.
const roundTo = (n, places) => {
  const factor = 10 ** places;
  return Math.round(n * factor) / factor;
};

console.log(roundTo(3.14159, 2));   // 3.14
console.log(roundTo(2.345, 2));     // 2.35

// Floating point arithmetic itself.
console.log(0.1 + 0.2);               // 0.30000000000000004
console.log((0.1 + 0.2).toFixed(2));   // "0.30"

Three practical points. First, multiplying by a power of ten and then dividing back can itself introduce error, so roundTo is not perfect. If exact decimal behaviour matters, do the arithmetic in integer minor units such as cents, or use a decimal library.

Second, and this is the one that catches people out, Math.round is not symmetric around zero. A positive halfway value rounds up and a negative halfway value rounds towards zero, so rounding a list of values with the round method can produce a total that is off by one in either direction.

Third, for money, never use floating point at all. Store an integer number of cents and format it for display. Every financial system that has had a rounding bug eventually learned this lesson, and the interview answer that demonstrates judgement is the integer approach.

The Math methods earn their keep in two places: normalising a list of numbers, and generating random values in a specific range.

const values = [3.7, -1.2, 0, 8.4];

console.log(values.map((n) => Math.round(n)));  // [4, -1, 0, 8]
console.log(values.map((n) => Math.floor(n)));  // [3, -2, 0, 8]
console.log(values.map((n) => Math.ceil(n)));   // [4, -1, 0, 9]
console.log(values.map((n) => Math.abs(n)));     // [3.7, 1.2, 0, 8.4]

console.log(Math.max(...values));   // 8.4
console.log(Math.min(...values));   // -1.2

// A random integer in an inclusive range.
const randomInt = (min, max) =>
  Math.floor(Math.random() * (max - min + 1)) + min;

console.log(randomInt(1, 6));   // 1 to 6

The spread operator in the max call matters when the list is large. Math.max accepts any number of arguments, so passing an array directly does not work; spreading it turns the elements into arguments. For a very large array, a reduce loop is faster because it avoids building the argument list.

The random integer helper is the pattern people expect. The random function returns a value between zero and one, so multiplying by the size of the range and flooring gives an index, and adding the minimum shifts it into range. The plus one makes the upper bound inclusive, which is usually what you want for dice and inclusive ranges.

One warning about randomness. The Math.random function is not cryptographically secure, because it uses a fast pseudo-random generator that an attacker could predict if they know the internal state. For tokens, password resets or anything security related, use the crypto module instead, which pulls from the operating system's entropy source.