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.
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.
