Ten+ Math Functions Every JavaScript Developer Should Know
Tags: javascript, webdev
Published: 2021-10-29 09:56:18

In this article, I want to show you the commonly used Math functions that every JavaScript developer should know. In addition to general examples, I have provided different use-case examples to clarify the context of functions.

Let's dive in and have fun!

## Introduction

**Math** is a built-in object that provides properties and methods for mathematical constants and functions to execute mathematical operations. Unlike many other global objects, the Math object has no constructor. All properties and methods of Math are *static*.

The Math works with the **Number** type. It doesn't work with **BigInt**.

Following is a list of commonly used Math object methods:

### `Math.abs`

The `Math.abs` function returns the absolute value of a number. It takes a number as its parameter and returns its absolute value.

``` JavaScript
console.log(Math.abs(5));
// Output: 5

console.log(Math.abs(5.2));
// Output: 5.2

console.log(Math.abs(-5.2));
// Output: 5.2
```

**Bonus Tip:** It is useful when you have a case where you should find the difference between the two numbers. Let's take a look at the example below:

``` JavaScript
function difference(a, b) {
  return Math.abs(a - b);
}

console.log(difference(4, 7));
// Output: 3

console.log(difference(7, 4));
// Output: 3
```

### `Math.ceil`

The `Math.ceil` function always rounds a number up to the next largest integer. It takes a number as its parameter and returns its upward round value.

``` JavaScript
console.log(Math.ceil(0.8));
// Output: 1

console.log(Math.ceil(-0.8));
// Output: -0

console.log(Math.ceil(4));
// Output: 4

console.log(Math.ceil(3.004));
// Output: 4

console.log(Math.ceil(-3.004));
// Output: -3
```

### `Math.floor`

The `Math.floor` function rounds a number down to its nearest integer. It takes a number as its parameter and returns its downward round value.

``` JavaScript
console.log(Math.floor(0.8));
// Output: 0

console.log(Math.floor(-0.8));
// Output: -1

console.log(Math.floor(4));
// Output: 4

console.log(Math.floor(3.004));
// Output: 3

console.log(Math.floor(-3.004));
// Output: -4
```

### `Math.round`

The `Math.round` function rounds a number to its nearest integer. It takes a number as its parameter and returns its nearest rounded value.

``` JavaScript
console.log(Math.round(0.8));
// Output: 1

console.log(Math.round(-0.8));
// Output: -1

console.log(Math.round(5));
// Output: 5

console.log(Math.round(5.95));
// Output: 6

console.log(Math.round(5.5));
// Output: 6

console.log(Math.round(5.05));
// Output: 5
```

**Description:** If the fractional portion of the argument is greater than 0.5, the argument is rounded to the integer with the next higher absolute value. If it is less than 0.5, the argument is rounded to the integer with the lower absolute value.  If the fractional portion is exactly 0.5, the argument is rounded to the next integer in the direction of +∞.

Consider the following examples for better clarity:

``` JavaScript
console.log(Math.round(10.49));
// Output: 10

console.log(Math.round(10.5));
// Output: 11

console.log(Math.round(22));
// Output: 22

console.log(Math.round(-10.5));
// Output: -10

console.log(Math.round(-10.51));
// Output: -11
```

### `Math.trunc`

The `Math.trunc` function takes a number as its parameter and returns its integer part of a number by removing any fractional digits.

``` JavaScript
console.log(Math.trunc(0.8));
// Output: 0

console.log(Math.trunc(-0.8));
// Output: -0

console.log(Math.trunc(5));
// Output: 5

console.log(Math.trunc(5.95));
// Output: 5

console.log(Math.trunc(5.5));
// Output: 5

console.log(Math.trunc(5.05));
// Output: 5
```

**Description:** Unlike the other Math methods, the way `Math.trunc` works is very simple. It truncates (cuts off) the dot and the digits to the right of it, no matter whether the argument is a positive or negative number.

The `Math.trunc` is one of the new features of *ECMAScript 6* and before that, the following method was used:

``` JavaScript
// In ECMAScript 5
function mathTrunc(num) {
  return (num < 0 ? Math.ceil(num) : Math.floor(num));
}
```

### `Math.max`

The `Math.max` function returns the largest of `0` to `n` numbers given as input parameters.

``` JavaScript
let largestNumber = Math.max(2, 5, 15, 3);

console.log(largestNumber);
// Output: 15
```

### `Math.min`

The `Math.min` function returns the smallest of `0` to `n` numbers given as input parameters.

``` JavaScript
let smallestNumber = Math.min(2, 5, 15, 3);

console.log(smallestNumber );
// Output: 2
```

**Note:** Both `Math.max` & `Math.min` are variadic functions. A variadic function takes a variable number of arguments. In other words, a variadic function is a function where the total number of parameters are unknown and can be adjusted when the method is invoked.

**Bonus Tip:** You can also find the largest/smallest number in an array with the help of the Spread Syntax, which unpacks array values. Take a look at the example below:

``` JavaScript
let salaries = [1000, 2500, 400, 14000, 800];

let highestSalary = Math.max(...salaries);
console.log(highestSalary);
// Output: 14000

let lowestSalary = Math.min(...salaries);
console.log(lowestSalary);
// Output: 400
```

### `Math.pow`

The `Math.pow` function returns the `base` to the `exponent` power. It takes two number parameters and returns as `base^exponent`.

``` JavaScript
console.log(Math.pow(2, 5));
// Output: 32

console.log(Math.pow(2, 0));
// Output: 1
```

### `Math.sqrt`

The `Math.sqrt` function takes a number as a parameter and returns the square root of the number.

``` JavaScript
console.log(Math.sqrt(9));
// Output: 3

console.log(Math.sqrt(2));
// Output: 1.4142135623730951

console.log(Math.sqrt(-9));
// Output: NaN
```

### `Math.cbrt`

The `Math.cbrt` function returns the cube root of a number taken as a parameter.

``` JavaScript
console.log(Math.cbrt(64));
// Output: 4

console.log(Math.cbrt(-1));
// Output: -1

console.log(Math.cbrt(1));
// Output: 1
```

### `Math.random`

The `Math.random` function returns a floating-point, pseudo-random number in the range 0 to less than 1 (inclusive of 0, and exclusive of 1).

``` JavaScript
console.log(Math.random());
// Output: 0.9785027066546665

console.log(Math.random());
// Output: 0.4401509062770659

console.log(Math.random());
// Output: 0.04055758334158077
```

You can also generate random integer numbers, one can pass the `Math.random()` as an argument to the `parseInt` method.

``` JavaScript
let randomNumber = parseInt((Math.random() * 100), 10);

console.log(randomNumber);
// Output: 80
```

In the above code, the `Math.random` function returns a random integer between 0 and 1. To convert that to a random number up to 100, multiply it by 100. So if you want a random number up to 10, multiply it by 10. The `parseInt` function casts the generated random number to an integer by the radix of 10, which indicates to convert from a decimal number.

**Bonus Tip:** To get a random integer within a specific range you can use the following method instead:

``` JavaScript
function generateRandomNumber(min, max) {
  return parseInt((Math.random() * (max - min + 1)), 10) + min;
}

console.log(generateRandomNumber(20, 50));
// Output: 32

console.log(generateRandomNumber(80, 100));
// Output: 89
```

## Final thoughts

The `Math` object allows you to perform mathematical instructions. It has 8 static properties and more than 30 static methods.

Let's look at a glance at what common Math functions are:

| Function                      | Description                                                      |
|-------------------------------|------------------------------------------------------------------|
| Math.abs(x)                   | Returns the absolute value of a number.                          |
| Math.ceil(x)                  | Rounds a number up to the next largest integer.                  |
| Math.floor(x)                 | Rounds a number down to its nearest integer.                     |
| Math.round(x)                 | Rounds a number to its nearest integer.                          |
| Math.trunc(x)                 | Returns the integer part of a number.                            |
| Math.max(n1, n2, n3, ..., nx) | Returns the number with the highest value.                       |
| Math.min(n1, n2, n3, ..., nx) | Returns the number with the lowest value.                        |
| Math.pow(x, y)                | Returns the base to the exponent power.                          |
| Math.sqrt(x)                  | Returns the square root of a number.                             |
| Math.cbrt(x)                  | Returns the cubic root of a number.                              |
| Math.random()                 | Returns a random number between 0 (inclusive) and 1 (exclusive). |