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

var number = 1310;

should be left alone.

var number = 120;

should be changed to "0120";

var number = 10;

should be changed to "0010";

var number = 7;

should be changed to "0007";

In all modern browsers you can use

numberStr.padStart(4, "0");

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

function zeroPad(num) {
  return num.toString().padStart(4, "0");
}

var numbers = [1310, 120, 10, 7];

numbers.forEach(
  function(num) {        
    var paddedNum = zeroPad(num);

    console.log(paddedNum);
  }
);

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

}

try these:

('0000' + number).slice(-4);

or

(number+'').padStart(4,'0');

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.

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

might not work in old IE versions.

//to: 0 - to left, 1 - to right
String.prototype.pad = function(_char, len, to) {
    if (!this || !_char || this.length >= len) {
        return this;
    }
    to = to || 0;

    var ret = this;

    var max = (len - this.length)/_char.length + 1;
    while (--max) {
        ret = (to) ? ret + _char : _char + ret;
    }

    return ret;
};

Usage:

someString.pad(neededChars, neededLength)

Example:

'332'.pad('0', 6); //'000332'
'332'.pad('0', 6, 1); //'332000'

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
}

No loop, no functions

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

Nate as the best way I found, it's just way too long to read. So I provide you with 3 simples solutions.

1. So here's my simplification of Nate's answer.

//number = 42
"0000".substring(number.toString().length, 4) + number;

2. Here's a solution that make it more reusable by using a function that takes the number and the desired length in parameters.

function pad_with_zeroes(number, len) {
  var zeroes = "0".repeat(len);
  return zeroes.substring(number.toString().length, len) + number;
}

// Usage: pad_with_zeroes(42,4);
// Returns "0042"

3. Here's a third solution, extending the Number prototype.

Number.prototype.toStringMinLen = function(len) {
  var zeroes = "0".repeat(len);
  return zeroes.substring(self.toString().length, len) + self;
}

//Usage: tmp=42; tmp.toStringMinLen(4)

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));

}

With RegExp/JavaScript:

var number = 7;
number = ('0000'+number).match(/\d{4}$/);
console.log(number);

With Function/RegExp/JavaScript:

var number = 7;

function padFix(n) {
  return ('0000'+n).match(/\d{4}$/);
}

console.log(padFix(number));

Use String.JS librairy function padLeft:

S('123').padLeft(5, '0').s   --> 00123