How can I modify this code to add a 0 before any digits lower than 10

```
$('#detect').html( toGeo(apX, screenX) + latT +', '+ toGeo(apY, screenY) + lonT );
function toGeo(d, max) {
var c = '';
var r = d/max * 180;
var deg = Math.floor(r);
c += deg + "° ";
r = (r - deg) * 60;
var min = Math.floor(r);
c += min + "? ";
r = (r - min) * 60;
var sec = Math.floor(r);
c += sec + "?";
return c;
}
```

So the outpout would change from

4° 7? 34?W, 168° 1? 23?N

to

04° 07? 34?W, 168° 01? 23?N

Thanks for your time

You can always do

```
('0' + deg).slice(-2)
```

See `slice()`

:

You can also use negative numbers to select from the end of an array

Hence

```
('0' + 11).slice(-2) // '11'
('0' + 4).slice(-2) // '04'
```

For ease of access, you could of course extract it to a function, or even extend `Number`

with it:

```
Number.prototype.pad = function(n) {
return new Array(n).join('0').slice((n || 2) * -1) + this;
}
```

Which will allow you to write:

```
c += deg.pad() + '° '; // "04° "
```

The above function `pad`

accepts an argument specifying the length of the desired string. If no such argument is used, it defaults to 2. You could write:

```
deg.pad(4) // "0045"
```

Note the obvious drawback that the value of `n`

cannot be higher than 11, as the string of 0's is currently just 10 characters long. This could of course be given a technical solution, but I did not want to introduce complexity in such a simple function. (Should you elect to, see alex's answer for an excellent approach to that).

Note also that you would not be able to write `2.pad()`

. It only works with variables. But then, if it's not a variable, you'll always know beforehand how many digits the number consists of.

Make a function that you can reuse:

```
function minTwoDigits(n) {
return (n < 10 ? '0' : '') + n;
}
```

Then use it in each part of the coordinates:

```
c += minTwoDigits(deg) + "° ";
```

and so on.

```
if(myNumber.toString().length < 2)
myNumber= "0"+myNumber;
```

or:

```
return (myNumber.toString().length < 2) ? "0"+myNumber : myNumber;
```

You can always do

```
('0' + deg).slice(-2)
```

If you use it very often, you may extend the object Number

```
Number.prototype.pad = function(n) {
if (n==undefined)
n = 2;
return (new Array(n).join('0') + this).slice(-n);
}
deg.pad(4) // "0045"
```

where you can set any pad size or leave the default 2.

You can write a generic function to do this...

```
var numberFormat = function(number, width) {
return new Array(+width + 1 - (number + '').length).join('0') + number;
}
```

That way, it's not a problem to deal with any arbitrarily width.

I was bored and playing around JSPerf trying to beat the currently selected answer prepending a zero no matter what and using `slice(-2)`

. It's a clever approach but the performance gets a lot worse as the string gets longer.

For numbers zero to ten (one and two character strings) I was able to beat by about ten percent, and the fastest approach was much better when dealing with longer strings by using `charAt`

so it doesn't have to traverse the whole string.

This follow is not quit as simple as `slice(-2)`

but is 86%-89% faster when used across mostly 3 digit numbers (3 character strings).

```
var prepended = ( 1 === string.length && string.charAt( 0 ) !== "0" ) ? '0' + string : string;
```

Hope, this help:

```
Number.prototype.zeroFill= function (n) {
var isNegative = this < 0;
var number = isNegative ? -1 * this : this;
for (var i = number.toString().length; i < n; i++) {
number = '0' + number;
}
return (isNegative ? '-' : '') + number;
}
```

Here is Genaric function for add any number of leading zeros for making any size of numeric string.

```
function add_zero(your_number, length) {
var num = '' + your_number;
while (num.length < length) {
num = '0' + num;
}
return num;
}
```

```
$('#detect').html( toGeo(apX, screenX) + latT +', '+ toGeo(apY, screenY) + lonT );
function toGeo(d, max) {
var c = '';
var r = d/max * 180;
var deg = Math.floor(r);
if(deg < 10) deg = '0' + deg;
c += deg + "° ";
r = (r - deg) * 60;
var min = Math.floor(r);
if(min < 10) min = '0' + min;
c += min + "? ";
r = (r - min) * 60;
var sec = Math.floor(r);
if(sec < 10) sec = '0' + sec;
c += sec + "?";
return c;
}
```

A single regular expression replace should do it:

```
var stringWithSmallIntegers = "4° 7? 34?W, 168° 1? 23?N";
var paddedString = stringWithSmallIntegers.replace(
/\d+/g,
function pad(digits) {
return digits.length === 1 ? '0' + digits : digits;
});
alert(paddedString);
```

shows the expected output.

©2020 All rights reserved.