Javascript adding zeros to the beginning of a string (max length 4 chars)

Question

var number = 1310;

should be left alone.

var number = 120;

should be changed to \"0120\";

var num         


        

Answer 1

function pad(n, len) {
  return (new Array(len + 1).join('0') + n).slice(-len);
}

might not work in old IE versions.

Answer 2

No loop, no functions

let n = "" + 100;
let x = ("0000000000" + n).substring(n.length);//add your amount of zeros
alert(x + "-" + x.length);

Answer 3

I wrote a general function for this. It takes an input control and pad length as input.

function padLeft(input, padLength) {

    var num = $("#" + input).val();
    $("#" + input).val(('0'.repeat(padLength) + num).slice(-padLength));

}

Answer 4

An approach I like is to add 10^N to the number, where N is the number of zeros you want. Treat the resultant number as a string and slice off the zeroth digit. Of course, you'll want to be careful if your input number might be larger than your pad length, but it's still much faster than the loop method:

// You want to pad four places:
>>> var N = Math.pow(10, 4)
>>> var number = 1310
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"1310"
>>> var number = 120
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"0120"
>>> var number = 10
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"0010"
…

etc. You can make this into a function easily enough:

/**
 * Pad a number with leading zeros to "pad" places:
 *
 * @param number: The number to pad
 * @param pad: The maximum number of leading zeros
 */
function padNumber(number, pad) {
    var N = Math.pow(10, pad);
    return number < N ? ("" + (N + number)).slice(1) : "" + number
}

Answer 5

Here's another way. Comes from something I did that needs to be done thousands of times on a page load. It's pretty CPU efficient to hard code a string of zeroes one time, and chop as many as you need for the pad as many times as needed. I do really like the power of 10 method -- that's pretty flexible.

Anyway, this is as efficient as I could come up with:

For the original question, CHOOSE ONE of the cases...

var number = 1310;
var number = 120;
var number = 10;
var number = 7;

then

// only needs to happen once 
var zeroString = "00000";

// one assignment gets the padded number
var paddedNum = zeroString.substring((number + "").length, 4) + bareNum;

//output
alert("The padded number string is: " + paddedNum);

Of course you still need to validate the input. Because this ONLY works reliably under the following conditions:

• Number of zeroes in the zeroString is desired_length + 1
• Number of digits in your starting number is less than or equal to your desired length

Backstory:

I have a case that needs a fixed length (14 digit) zero-padded number. I wanted to see how basic I could make this. It's run tens of thousands of times on a page load, so efficiency matters. It's not quite re-usable as-is, and it's a bit inelegant. Except that it is very very simple.

For desired n digits padded string, this method requires a string of (at least) n+1 zeroes. Index 0 is the first character in the string, which won't ever be used, so really, it could be anything.

Note also that string.substring() is different from string.substr()!

var bareNum = 42 + '';  
var zeroString = "000000000000000";
var paddedNum = zeroString.substring(bareNumber.length, 14) + bareNum

This pulls zeroes from zeroString starting at the position matching the length of the string, and continues to get zeroes to the necessary length of 14. As long as that "14" in the third line is a lower integer than the number of characters in zeroString, it will work.

Answer 6

function pad_with_zeroes(number, length) {

    var my_string = '' + number;
    while (my_string.length < length) {
        my_string = '0' + my_string;
    }

    return my_string;

}