How to test if a number is a power of ten with vanilla js

This week, we looked at how to round a number to the nearest whole number with vanilla JS, and how to keep our code DRY.

In our original `round()` function, the `precision` argument has to be a power of ten: `10`, `100`, `1000`, etc.

``````var round = function (num, precision) {
num = parseFloat(num);
if (!precision) return num.toLocaleString();
return (Math.round(num / precision) * precision).toLocaleString();
};
``````

One of my readers asked me if it’s worth checking that it is before continuing with the function.

Today, let’s look at how we might do that.

Checking multiples of

Vanilla JS provides a remainder operator: `%`. It will divide a number by another number, and return whatever amount is leftover.

``````// Returns 1
// 2 goes into 5 twice with 1 left over
5 % 2;

// Return 3
// 4 goes into 7 once, with 3 left over
7 % 4;

// Returns 0
// 3 goes into 9 three times, with 0 left over
9 % 3;
``````

You can use is to check if one number is a multiple of another by testing if the remainder is `0` or not.

``````// logs "yep!"
if (1000 % 10 === 0) {
console.log('yep!');
}

// also logs "yep!"
if (100 % 10 === 0) {
console.log('yep!');
}

// does NOT log "yep!"
if (243 % 10 === 0) {
console.log('yep!');
}
``````

There’s a problem with this approach, though: numbers like `20`, `42000`, etc. are also multiples of ten, but don’t fit our formula.

``````// logs "yep!"
if (20 % 10 === 0) {
console.log('yep!');
}

// also logs "yep!"
if (42000 % 10 === 0) {
console.log('yep!');
}
``````

Creating a helper function

For this to work, we’ll need to create our own little test. Here’s the plan:

1. Convert the number to a string.
2. Get the first digit, and check that it’s `1`.
3. Get the rest of the string, convert it back to a number, and make sure it’s `0` (since the string `"0000"` converted to a number is `0`).

If both items 2 and 3 are true, the number is ten-based. If not, it’s not.

First, let’s setup our helper function and convert the number to a string using the `Number.toString()` method.

``````var isTenBased = function (num) {
var str = num.toString();
};
``````

Next, we’ll get the first digit and the rest of the number and store both to variables. We’ll use the `String.slice()` method to split the string into a substring at specific integers.

``````var isTenBased = function (num) {
var str = num.toString();
var first = str.slice(0, 1);
var rest = str.slice(1, str.length);
};
``````

Finally, we’ll check that `first` is `1` (remember, it’s a string, not a number). We’ll also use the `parseFloat()` method to convert `rest` into a number and check that it’s `0`.

We’ll return the result of the check to get a `true`/`false` boolean we can use.

``````var isTenBased = function (num) {
var str = num.toString();
var first = str.slice(0, 1);
var rest = str.slice(1, str.length);
return first === '1' & parseFloat(rest) === 0;
};
``````

Here’s a demo.