padstart - Rellena un número con ceros en JavaScript

padstart javascript

Question

Posible duplicado:
¿Cómo puedo crear un valor Zerofilled usando JavaScript?

En JavaScript, necesito tener relleno.

Por ejemplo, si tengo el número 9, será "0009". Si tengo un número de decir 10, será "0010". Observe cómo siempre contendrá cuatro dígitos.

Una forma de hacer esto sería restar el número menos 4 para obtener el número de 0s que necesito poner.

¿Hay una manera más pulida de hacer esto?

Answer 1

Como mencionaste que siempre va a tener una longitud de 4, no haré ninguna comprobación de errores para hacer que esta resbaladiza. ;)

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

Idea: Simplemente reemplace ''0000'' con el número proporcionado ... El problema es que, si la input es 0, necesito codificarla para devolver ''0000''. Jajaja

Esto debería ser lo suficientemente resbaladizo.

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

Answer 2

Curioso, recientemente tuve que hacer esto.

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"

No hermosa, pero efectiva.

Answer 3

Dijiste que tenías un número ...

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

Answer 4

Esto no es realmente "elegante", pero es más rápido realizar operaciones de enteros que hacer concatenaciones de cadenas para cada relleno 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 función también está codificada para su necesidad particular (relleno de 4 dígitos), por lo que no es genérica.

Answer 5

No hay mucha "mancha" pasando hasta ahora:

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

Cuando inicializa una matriz con un número, crea una matriz con la length establecida en ese valor para que la matriz parezca contener tantos elementos undefined . Aunque algunos métodos de instancia de Array .join() elementos de matriz sin valores, .join() no lo hace, o al menos no completamente; los trata como si su valor fuera la cadena vacía. De este modo, obtiene una copia del carácter cero (o lo que sea "z") entre cada uno de los elementos de la matriz; es por eso que hay un + 1 allí.

Ejemplo de uso:

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

Answer 6

Podrías hacer algo como esto:

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

Edición: esto fue solo una idea básica para una función, pero para agregar soporte para números más grandes (así como entrada no válida), esto probablemente sería mejor:

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

Esto hace 2 cosas:

1. Si el número es mayor que el tamaño especificado, simplemente devolverá el número.
2. Usar Math.floor(num) en lugar de ~~num admitirá números más grandes.

Answer 7

Por diversión, en lugar de usar un bucle para crear los ceros adicionales:

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

Answer 8

Tratar:

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

Ahora prueba:

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

En ES8, tenemos un nuevo método padStart y padEnd que tiene la siguiente sintaxis.

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

Así que ahora podemos usar

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

Answer 9

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

¿Algo como eso?

Versión de ES6 de una sola línea incomprensible, pero no es fácil de entender:

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

ES6ismos:

• let es una variable de ámbito de bloque (a diferencia del alcance funcional de var )
• => es una función de flecha que, entre otras cosas, reemplaza la function y está precedida por sus parámetros
• Si una función de flecha toma un solo parámetro, puede omitir los paréntesis (por lo tanto, number => )
• Si el cuerpo de una función de flecha tiene una sola línea que comienza con return , puede omitir las llaves y la palabra clave de return y simplemente usar la expresión
• Para reducir el cuerpo de la función a una sola línea, hice trampa y usé una expresión ternaria.