# 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:

- Convert the number to a string.
- Get the first digit, and check that it’s
`1`

. - 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;
};
```