Pad a number with leading zeros in JavaScript [duplicate]
Em JavaScript, preciso de enchimento. Por exemplo, se eu tiver o número 9, será "0009". Se eu tiver um número de digamos 10, será "0010". Observe como ele sempre conterá quatro dígitos. Uma maneira de fazer isso seria subtrair o número menos 4 para obter o número de 0s que eu preciso colocar. Há uma maneira mais inteligente de a fazer isto?possível duplicado:
Como posso criar um valor Zerofilled usando JavaScript?
9 answers
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;
}
Algo assim?
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 devar
) -
=>
é uma função de seta que, entre outras coisas, substituifunction
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-chavereturn
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"
Na ES8 , temos um novo método.
padStart
e padEnd
que tem abaixo da sintaxe.
Então agora podemos usar'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:
- Se o número for maior do que o tamanho especificado, ele simplesmente retornará o número.
- 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/