How can I pad a value with leading zeros?

I can't believe all the complex answers on here... Just use this:

var zerofilled = ('0000'+n).slice(-4); 

let n = 1 var zerofilled = ('0000'+n).slice(-4); console.log(zerofilled)

Simple way. You could add string multiplication for the pad and turn it into a function.

var pad = "000000"; var n = '5'; var result = (pad+n).slice(-pad.length); 

As a function,

function paddy(num, padlen, padchar) { var pad_char = typeof padchar !== 'undefined' ? padchar : '0'; var pad = new Array(1 + padlen).join(pad_char); return (pad + num).slice(-pad.length); } var fu = paddy(14, 5); // 00014 var bar = paddy(2, 4, '#'); // ###2 

I actually had to come up with something like this recently. I figured there had to be a way to do it without using loops.

This is what I came up with.

function zeroPad(num, numZeros) { var n = Math.abs(num); var zeros = Math.max(0, numZeros - Math.floor(n).toString().length ); var zeroString = Math.pow(10,zeros).toString().substr(1); if( num < 0 ) { zeroString = '-' + zeroString; } return zeroString+n; } 

Then just use it providing a number to zero pad:

> zeroPad(50,4); "0050" 

If the number is larger than the padding, the number will expand beyond the padding:

> zeroPad(51234, 3); "51234" 

Decimals are fine too!

> zeroPad(51.1234, 4); "0051.1234" 

If you don't mind polluting the global namespace you can add it to Number directly:

Number.prototype.leftZeroPad = function(numZeros) { var n = Math.abs(this); var zeros = Math.max(0, numZeros - Math.floor(n).toString().length ); var zeroString = Math.pow(10,zeros).toString().substr(1); if( this < 0 ) { zeroString = '-' + zeroString; } return zeroString+n; } 

And if you'd rather have decimals take up space in the padding:

Number.prototype.leftZeroPad = function(numZeros) { var n = Math.abs(this); var zeros = Math.max(0, numZeros - n.toString().length ); var zeroString = Math.pow(10,zeros).toString().substr(1); if( this < 0 ) { zeroString = '-' + zeroString; } return zeroString+n; } 

Cheers!

XDR came up with a logarithmic variation that seems to perform better.

WARNING: This function fails if num equals zero (e.g. zeropad(0, 2))

function zeroPad (num, numZeros) { var an = Math.abs (num); var digitCount = 1 + Math.floor (Math.log (an) / Math.LN10); if (digitCount >= numZeros) { return num; } var zeroString = Math.pow (10, numZeros - digitCount).toString ().substr (1); return num < 0 ? '-' + zeroString + an : zeroString + an; } 

Speaking of performance, tomsmeding compared the top 3 answers (4 with the log variation). Guess which one majorly outperformed the other two? :)

Modern browsers now support padStart, you can simply now do:

string.padStart(maxLength, "0"); 

Example:

string = "14"; maxLength = 5; // maxLength is the max string length, not max # of fills res = string.padStart(maxLength, "0"); console.log(res); // prints "00014" number = 14; maxLength = 5; // maxLength is the max string length, not max # of fills res = number.toString().padStart(maxLength, "0"); console.log(res); // prints "00014"

Here's what I used to pad a number up to 7 characters.

("0000000" + number).slice(-7) 

This approach will probably suffice for most people.

Edit: If you want to make it more generic you can do this:

("0".repeat(padding) + number).slice(-padding) 

Edit 2: Note that since ES2017 you can use String.prototype.padStart:

number.toString().padStart(padding, "0") 

Unfortunately, there are a lot of needless complicated suggestions for this problem, typically involving writing your own function to do math or string manipulation or calling a third-party utility. However, there is a standard way of doing this in the base JavaScript library with just one line of code. It might be worth wrapping this one line of code in a function to avoid having to specify parameters that you never want to change like the local name or style.

var amount = 5; var text = amount.toLocaleString('en-US', { style: 'decimal', minimumIntegerDigits: 3, useGrouping: false }); 

This will produce the value of "005" for text. You can also use the toLocaleString function of Number to pad zeros to the right side of the decimal point.

var amount = 5; var text = amount.toLocaleString('en-US', { style: 'decimal', minimumFractionDigits: 2, useGrouping: false }); 

This will produce the value of "5.00" for text. Change useGrouping to true to use comma separators for thousands.

Note that using toLocaleString() with locales and options arguments is standardized separately in ECMA-402, not in ECMAScript. As of today, some browsers only implement basic support, i.e. toLocaleString() may ignore any arguments.

Complete Example

If the fill number is known in advance not to exceed a certain value, there's another way to do this with no loops:

var fillZeroes = "00000000000000000000"; // max number of zero fill ever asked for in global function zeroFill(number, width) { // make sure it's a string var input = number + ""; var prefix = ""; if (input.charAt(0) === '-') { prefix = "-"; input = input.slice(1); --width; } var fillAmt = Math.max(width - input.length, 0); return prefix + fillZeroes.slice(0, fillAmt) + input; } 

Test cases here: http://jsfiddle.net/jfriend00/N87mZ/

The quick and dirty way:

y = (new Array(count + 1 - x.toString().length)).join('0') + x; 

For x = 5 and count = 6 you'll have y = "000005"

ECMAScript 2017: use padStart or padEnd

'abc'.padStart(10); // " abc" 'abc'.padStart(10, "foo"); // "foofoofabc" 'abc'.padStart(6,"123465"); // "123abc" 

More info:

• https://github.com/tc39/proposal-string-pad-start-end
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Here's a quick function I came up with to do the job. If anyone has a simpler approach, feel free to share!

function zerofill(number, length) { // Setup var result = number.toString(); var pad = length - result.length; while(pad > 0) { result = '0' + result; pad--; } return result; } 

I really don't know why, but no one did it in the most obvious way. Here it's my implementation.

Function:

/** Pad a number with 0 on the left */ function zeroPad(number, digits) { var num = number+""; while(num.length < digits){ num='0'+num; } return num; } 

Prototype:

Number.prototype.zeroPad=function(digits){ var num=this+""; while(num.length < digits){ num='0'+num; } return(num); }; 

Very straightforward, I can't see any way how this can be any simpler. For some reason I've seem many times here on SO, people just try to avoid 'for' and 'while' loops at any cost. Using regex will probably cost way more cycles for such a trivial 8 digit padding.

I often use this construct for doing ad-hoc padding of some value n, known to be a positive, decimal:

(offset + n + '').substr(1); 

Where offset is 10^^digits.

E.g., padding to 5 digits, where n = 123:

(1e5 + 123 + '').substr(1); // => 00123 

The hexadecimal version of this is slightly more verbose:

(0x100000 + 0x123).toString(16).substr(1); // => 00123 

Note 1: I like @profitehlolz's solution as well, which is the string version of this, using slice()'s nifty negative-index feature.

In all modern browsers you can use

numberStr.padStart(numberLength, "0"); 

function zeroFill(num, numLength) { var numberStr = num.toString(); return numberStr.padStart(numLength, "0"); } var numbers = [0, 1, 12, 123, 1234, 12345]; numbers.forEach( function(num) { var numString = num.toString(); var paddedNum = zeroFill(numString, 5); console.log(paddedNum); } );

Here is the MDN reference https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

I use this snippet to get a five-digits representation:

(value+100000).toString().slice(-5) // "00123" with value=123 

The power of Math!

x = integer to pad
y = number of zeroes to pad

function zeroPad(x, y) { y = Math.max(y-1,0); var n = (x / Math.pow(10,y)).toFixed(y); return n.replace('.',''); } 

This is the ES6 solution.

function pad(num, len) { return '0'.repeat(len - num.toString().length) + num; } alert(pad(1234,6));

Not that this question needs more answers, but I thought I would add the simple lodash version of this.

_.padLeft(number, 6, '0')

Don't reinvent the wheel; use underscore string:

jsFiddle

var numToPad = '5'; alert(_.str.pad(numToPad, 6, '0')); // Yields: '000005' 

After a, long, long time of testing 15 different functions/methods found in this questions answers, I now know which is the best (the most versatile and quickest).

I took 15 functions/methods from the answers to this question and made a script to measure the time taken to execute 100 pads. Each pad would pad the number 9 with 2000 zeros. This may seem excessive, and it is, but it gives you a good idea about the scaling of the functions.

The code I used can be found here: https://gist.github.com/NextToNothing/6325915

Feel free to modify and test the code yourself.

In order to get the most versatile method, you have to use a loop. This is because with very large numbers others are likely to fail, whereas, this will succeed.

So, which loop to use? Well, that would be a while loop. A for loop is still fast, but a while loop is just slightly quicker(a couple of ms) - and cleaner.

Answers like those by Wilco, Aleksandar Toplek or Vitim.us will do the job perfectly.

Personally, I tried a different approach. I tried to use a recursive function to pad the string/number. It worked out better than methods joining an array but, still, didn't work as quick as a for loop.

My function is:

function pad(str, max, padder) { padder = typeof padder === "undefined" ? "0" : padder; return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str; } 

You can use my function with, or without, setting the padding variable. So like this:

pad(1, 3); // Returns '001' // - Or - pad(1, 3, "x"); // Returns 'xx1' 

Personally, after my tests, I would use a method with a while loop, like Aleksandar Toplek or Vitim.us. However, I would modify it slightly so that you are able to set the padding string.

So, I would use this code:

function padLeft(str, len, pad) { pad = typeof pad === "undefined" ? "0" : pad + ""; str = str + ""; while(str.length < len) { str = pad + str; } return str; } // Usage padLeft(1, 3); // Returns '001' // - Or - padLeft(1, 3, "x"); // Returns 'xx1' 

You could also use it as a prototype function, by using this code:

Number.prototype.padLeft = function(len, pad) { pad = typeof pad === "undefined" ? "0" : pad + ""; var str = this + ""; while(str.length < len) { str = pad + str; } return str; } // Usage var num = 1; num.padLeft(3); // Returns '001' // - Or - num.padLeft(3, "x"); // Returns 'xx1' 

First parameter is any real number, second parameter is a positive integer specifying the minimum number of digits to the left of the decimal point and third parameter is an optional positive integer specifying the number if digits to the right of the decimal point.

function zPad(n, l, r){ return(a=String(n).match(/(^-?)(\d*)\.?(\d*)/))?a[1]+(Array(l).join(0)+a[2]).slice(-Math.max(l,a[2].length))+('undefined'!==typeof r?(0<r?'.':'')+(a[3]+Array(r+1).join(0)).slice(0,r):a[3]?'.'+a[3]:''):0 } 

so

 zPad(6, 2) === '06' zPad(-6, 2) === '-06' zPad(600.2, 2) === '600.2' zPad(-600, 2) === '-600' zPad(6.2, 3) === '006.2' zPad(-6.2, 3) === '-006.2' zPad(6.2, 3, 0) === '006' zPad(6, 2, 3) === '06.000' zPad(600.2, 2, 3) === '600.200' zPad(-600.1499, 2, 3) === '-600.149' 

I didn't see anyone point out the fact that when you use String.prototype.substr() with a negative number it counts from the right.

A one liner solution to the OP's question, a 6-digit zerofilled representation of the number 5, is:

console.log(("00000000" + 5).substr(-6));

Generalizing we'll get:

function pad(num, len) { return ("00000000" + num).substr(-len) }; console.log(pad(5, 6)); console.log(pad(45, 6)); console.log(pad(345, 6)); console.log(pad(2345, 6)); console.log(pad(12345, 6));

The latest way to do this is much simpler:

var number = 2 number.toLocaleString(undefined, {minimumIntegerDigits:2}) 

output: "02"

Just another solution, but I think it's more legible.

function zeroFill(text, size) { while (text.length < size){ text = "0" + text; } return text; }

This one is less native, but may be the fastest...

zeroPad = function (num, count) { var pad = (num + '').length - count; while(--pad > -1) { num = '0' + num; } return num; }; 

My solution

Number.prototype.PadLeft = function (length, digit) { var str = '' + this; while (str.length < length) { str = (digit || '0') + str; } return str; }; 

Usage

var a = 567.25; a.PadLeft(10); // 0000567.25 var b = 567.25; b.PadLeft(20, '2'); // 22222222222222567.25 

With ES6+ JavaScript:

You can "zerofill a number" with something like the following function:

/** * @param number The number * @param minLength Minimal length for your string with leading zeroes * @return Your formatted string */ function zerofill(nb, minLength) { // Convert your number to string. let nb2Str = nb.toString() // Guess the number of zeroes you will have to write. let nbZeroes = Math.max(0, minLength - nb2Str.length) // Compute your result. return `${ '0'.repeat(nbZeroes) }${ nb2Str }` } console.log(zerofill(5, 6)) // Displays "000005" 

With ES2017+:

/** * @param number The number * @param minLength Minimal length for your string with leading zeroes * @return Your formatted string */ const zerofill = (nb, minLength) => nb.toString().padStart(minLength, '0') console.log(zerofill(5, 6)) // Displays "000005" 

The simplest, most straight-forward solution you will find.

function zerofill(number,length) { var output = number.toString(); while(output.length < length) { output = '0' + output; } return output; } 

Use recursion:

function padZero(s, n) { s = s.toString(); // In case someone passes a number return s.length >= n ? s : padZero('0' + s, n); } 

Some monkeypatching also works

String.prototype.padLeft = function (n, c) { if (isNaN(n)) return null; c = c || "0"; return (new Array(n).join(c).substring(0, this.length-n)) + this; }; var paddedValue = "123".padLeft(6); // returns "000123" var otherPadded = "TEXT".padLeft(8, " "); // returns " TEXT"