quitar - ¿Cómo puedo formatear un entero a una longitud específica en javascript?

quitar separador de miles javascript

Question

Tengo un número en Javascript, que sé que es menos de 10000 y también no negativo. Quiero mostrarlo como un número de cuatro dígitos, con ceros a la izquierda. ¿Hay algo más elegante que lo siguiente?

if(num<10) num="000"+num;
else if(num<100) num="00"+num;
else if(num<1000) num="0"+num;

Quiero algo que esté incorporado en Javascript, pero parece que no puedo encontrar nada.

Answer 1

Como el relleno de ES2017 a una longitud mínima se puede hacer simplemente con String.prototype.padStart y String.prototype.padEnd :

let num = 3
let str = num.toString().padStart(3, "0")
console.log(str) // "003"

O si solo la parte completa de un flotador debe tener una longitud fija:

let num = 3.141
let arr = num.toString().split(".")
arr[0] = arr[0].padStart(3, "0")
let str = arr.join(".")
console.log(str) // "003.141"

Answer 2

Creo que la forma más compacta pero intuitiva es:

function toFixedLength(input, length, padding) {
    padding = String(padding || "0");
    return (padding.repeat(length) + input).slice(-length);
}

El método de slice aquí podría reemplazarse con substr si eso es más intuitivo para el codificador.

Answer 3

Esto podría ayudar:

String.prototype.padLeft = function (length, character) { 
     return new Array(length - this.length + 1).join(character || ''0'') + this; 
}

var num = ''12'';

alert(num.padLeft(4, ''0''));

Answer 4

La forma más sencilla en que pienso es esta:

("000" + num).slice(-4)

Un número acolchado es una cadena.
Cuando agrega un número a una cadena, se convierte en una cadena.
Cadenas tiene el segmento de método, que vuelve a ejecutar una pieza de longitud fija de la cadena.
Si la longitud es negativa, la cadena devuelta se corta desde el final de la cadena.

Probar:

var num=12;
console.log(("000" + num).slice(-4)); // Will show "0012"

(Debido a que esto solo funciona para enteros positivos de hasta 4 dígitos)

Answer 5

Lo último con el método de repetición () ES6:

function PadDigits(input, totalDigits) 
{ 
    var result = input;
    if (totalDigits > input.length) 
    { 
        for (i=0; i < (totalDigits - input.length); i++) 
        { 
            result = ''0'' + result; 
        } 
    } 
    return result;
} 

Answer 6

Me encontré con el mismo problema y encontré una forma compacta de resolverlo. Si tuviera que usarlo varias veces en mi código o si lo hiciera por más de cuatro dígitos, usaría una de las otras soluciones sugeridas, pero de esta manera me permite poner todo en una expresión:

function format_number_length(num, length) {
    var r = num.toString();
    if (r.length<length) r = Array(length - r.length + 1).join(''0'') + r;
    return r;
}

En realidad es lo mismo que tu código, pero usando el operador ternario en lugar de las instrucciones "if-else" (y moviendo el "+ x", que siempre será parte de la expresión, fuera del código condicional).

Answer 7

No creo que haya nada "incorporado" en el lenguaje JavaScript para hacer esto. Aquí hay una función simple que hace esto:

function FormatNumberLength(num, length) {
    var r = "" + num;
    while (r.length < length) {
        r = "0" + r;
    }
    return r;
}


FormatNumberLength(10000, 5) outputs ''10000''
FormatNumberLength(1000, 5)  outputs ''01000''
FormatNumberLength(100, 5)   outputs ''00100''
FormatNumberLength(10, 5)    outputs ''00010''

Answer 8

Otro:

function format_number_length(num, length) { var r = num.toString(); if (r.length<length) r = Array(length - r.length + 1).join(''0'') + r; return r; }

Answer 9

Podrías volverte loco con métodos como estos:

function formatLength(a) {
    var num = document.getElementById(a)
    while (num.value.length < 4) {
        num.value = ''0'' + num.value
    }
}

Pero no hará la vida más fácil. C # tiene un método como PadLeft y PadRight en la clase String, desafortunadamente Javascript no tiene esta funcionalidad incorporada

Answer 10

Qué tal algo como esto:

function prefixZeros(number, maxDigits) 
{  
    var length = maxDigits - number.toString().length;
    if(length <= 0)
        return number;

    var leadingZeros = new Array(length + 1);
    return leadingZeros.join(''0'') + number.toString();
}
//Call it like prefixZeros(100, 5); //Alerts 00100

Answer 11

Un ciclo "while" debería facilitar esto.

((x<10)?"000": (x<100)?"00": (x<1000)?"0": "") + x

Eso pasaría en bucle hasta que la longitud del valor numérico alcanzara los 4 dígitos (suponiendo que haya pasado el id del elemento numérico como un argumento)

Answer 12

Una forma divertida (pero interesante) de prefijar números con ceros:

function FormatInteger(num, length) {

    return (num / Math.pow(10, length)).toFixed(length).substr(2);
}

Answer 13

Vine buscando la respuesta, pero creo que este es un mejor enfoque funcional (ES6):

const formatNumberToString = (num, minChars) => {
  return num.toString().length < minChars
   ? formatNumberToString(`0${num}`, minChars)
   : num.toString()
}
// formatNumberToString(12, 4) // "0012"
// formatNumberToString(12, 5) // "00012"
// formatNumberToString(1, 4) // "0001"
// formatNumberToString(1, 2) // "01"
// formatNumberToString(12, 2) // "12"
// formatNumberToString(12, 1) // "12"

Además, esto se puede implementar en una sola línea.