Pad a number with leading zeros in JavaScript [duplicate]

function pad(n, width, z) {
  z = z || '0';
  n = n + '';
  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
}

Quando você inicializa um array com um número, ele cria um array com o length definido para esse valor de modo que o array parece conter tantos elementos undefined. Embora alguns métodos de instância de Array ignorem elementos de array sem valores, .join() não, ou pelo menos não completamente; trata-os como se o seu valor fosse o texto vazio. Assim você obtém uma cópia do caráter zero (ou o que quer que "z" seja) entre cada um dos elementos da matriz; é por isso que há um ali dentro.

Uso de exemplo:

pad(10, 4);      // 0010
pad(9, 4);       // 0009
pad(123, 4);     // 0123

pad(10, 4, '-'); // --10

function padToFour(number) {
  if (number<=9999) { number = ("000"+number).slice(-4); }
  return number;
}

bônus incompreensível-mas-slicker versão single-line ES6:

let padToFour = number => number <= 9999 ? ("000"+number).slice(-4) : number;

Es6ismos:

• let é uma variável com escopo em bloco (em oposição à escopo funcional de var)
• => é uma função de seta que, entre outras coisas, substitui function e é precedida pelos seus parâmetros
• se uma função de seta tomar um único parâmetro, pode omitir os parêntesis (daí number =>)
• se uma seta funcionar o corpo tem uma única linha que começa com return você pode omitir os suspensórios e a palavra-chave return e simplesmente usar a expressão
• Para levar o corpo de funções para uma única linha eu copiei e usei uma expressão ternária {[[20]}

Tenta:

String.prototype.lpad = function(padString, length) {
    var str = this;
    while (str.length < length)
        str = padString + str;
    return str;
}

Agora teste:

var str = "5";
alert(str.lpad("0", 4)); //result "0005"
var str = "10"; // note this is string type
alert(str.lpad("0", 4)); //result "0010"

DEMO

'string'.padStart(targetLength [, padString]):

const str = "5";
str.padStart(4, '0'); // '0005'

function padDigits(number, digits) {
    return Array(Math.max(digits - String(number).length + 1, 0)).join(0) + number;
}

Utilizar como:

padDigits(9, 4);  // "0009"
padDigits(10, 4); // "0010"
padDigits(15000, 4); // "15000"

Não é bonito, mas eficaz.

String.prototype.padZero= function(len, c){
    var s= '', c= c || '0', len= (len || 2)-this.length;
    while(s.length<len) s+= c;
    return s+this;
}
Number.prototype.padZero= function(len, c){
    return String(this).padZero(len,c);
}

Você poderia fazer algo assim:

function pad ( num, size ) {
  return ( Math.pow( 10, size ) + ~~num ).toString().substring( 1 );
}

Editar: esta era apenas uma ideia básica para uma função, mas para adicionar suporte para números maiores (assim como entrada inválida), isto provavelmente seria melhor:

function pad ( num, size ) {
  if (num.toString().length >= size) return num;
  return ( Math.pow( 10, size ) + Math.floor(num) ).toString().substring( 1 );
}

Isto faz duas coisas:

1. Se o número for maior do que o tamanho especificado, ele simplesmente retornará o número.
2. usar Math.floor(num) no lugar de ~~num irá suportar um número maior.

Por diversão, em vez de usar um laço para criar os zeros extra:

function zeroPad(n,length){
  var s=n+"",needed=length-s.length;
  if (needed>0) s=(Math.pow(10,needed)+"").slice(1)+s;
  return s;
}

Isto não é realmente 'slick', mas é mais rápido fazer operações de inteiros do que fazer concatenações de string para cada enchimento 0.

function ZeroPadNumber ( nValue )
{
    if ( nValue < 10 )
    {
        return ( '000' + nValue.toString () );
    }
    else if ( nValue < 100 )
    {
        return ( '00' + nValue.toString () );
    }
    else if ( nValue < 1000 )
    {
        return ( '0' + nValue.toString () );
    }
    else
    {
        return ( nValue );
    }
}

Esta função também está ligada à sua necessidade específica( enchimento de 4 dígitos), por isso não é genérica.

function pad(input) {
    var BASE = "0000";
    return input ? BASE.substr(0, 4 - Math.ceil(input / 10)) + input : BASE;
}

Ideia: basta substituir "0000" pelo número indicado... O problema com isso é que, se input é 0, preciso de codificá-lo para devolver '0000'. RIR.

JSFiddler: http://jsfiddle.net/Up5Cr/