JavaScript is a very forgiving language. It’s easy to write code that runs but has issues in it.

In this article, we’ll look at how we should work with numbers in JavaScript.

### Avoid Magic Numbers

Magic numbers are numbers that are used everywhere but their meaning isn’t explicitly specified.

To make them easier to understand and change, we should assign them to a named constant so that we can see what they mean.

Also, we only have to change one place since the constant name is referenced instead of numeric literals.

So instead of writing:

```
for (let i = 0; i < 10; i++) {
//...
}
```

We write:

```
const MAX_DONUTS = 10;
for (let i = 0; i < MAX_DONUTS; i++) {
//...
}
```

### Use Hard-Coded 0s and 1s if we Need to

0’s and 1’s are OK for hard coding since they’re used for incrementing or setting as an initial number.

We often increment numbers by 1, so we can hard code 1.

0 are used for initial values of variables, so that’s also OK to hard code.

Other numbers should be replaced with something more descriptive.

### Anticipate Divide-by-Zero Errors

We shouldn’t expect that the denominator a fraction will never be 0. Therefore, when we divide a number by another number, we should make sure that the divisor is never 0.

### Make Type Conversions Obvious

In JavaScript, types may be converted explicitly.

This may cause unexpected results.

To make them obvious, we should convert the variables explicitly.

So, we should use functions like `Number`

, `Number.parseInt`

, or `Number.parseFloat`

to convert non-numbers to numbers.

The `+`

sign before a variable or a non-number can also convert them to numbers.

Also, when we compare things that may be numbers of equality, we should use `===`

so that we’ve to convert the operands to numbers with those functions and operators.

### Avoid Mixed-Type Comparisons

Mixed type comparisons often create unexpected results.

Therefore, we should avoid them as much as possible. We should use the `===`

operator to compare for equality.

If we’re checking for inequality, then we should convert both operands to the same type before comparing them.

So we should convert them both to numbers with those methods and operations we looked at before.

### Check for Integer Division

We should check that the result of any integer division is what we expect.

We should make sure that division is done last if we have an expression with multiple arithmetic operations.

For instance, instead of writing:

```
10 * 3 / 10
```

we write:

```
(10 * 3) / 10
```

to avoid anything unexpected.

### Check for Integer Overflow

We should check if our number’s absolute value is bigger than `Number.MAX_SAFE_INTEGER`

is we’re working with large integers.

If it is, then we need to use the bigInt type instead.

bigInt is a primitive data type that can let us store integers with magnitude bigger than `Number.MAX_SAFE_INTEGER`

.

We can do arithmetic with other bigInts only and not numbers.

Photo by Austin Distel on Unsplash

### Avoid Additions and Subtractions on Numbers that have Greatly Different Magnitudes

The result might not be what we expect if we do additions and subtractions on numbers that have big difference in magnitudes.

For instance, `1000000000.00 + 0.00000000001`

returns `1000000000`

since there aren’t enough significant digits to include all the digits of the result.

### Avoid Equality Comparisons

Equality comparisons don’t work well with numbers.

For instance if we have:

```
let sum = 0;
for (let i = 0; i < 10; i++) {
sum += 0.1;
}
```

We get `0.9999999999999999`

as the value of `sum`

instead of 0.1

Therefore, comparing both directly won’t work very well.

We may want to write our function to see if one number is close enough to what we want to be considered equal.

### Anticipate Rounding Errors

As e can see, rounding errors happen frequently. If we add a number 10 times, it doesn’t equal to the number we expect, for example.

### Conclusion

When we deal with numbers in JavaScript, we should keep a few things in mind.

Rounding errors are a problem that w should be aware of.

When we apply arithmetic operations to numbers, we don’t always get the same thing as we do the same thing on paper.

Therefore, we should be careful when checking for values.

Mixed-type comparisons are also bad. We should convert everything to numbers before comparing them.