Come posso formattare un numero intero a una lunghezza specifica in javascript?

Question

Ho un numero in Javascript, che so è inferiore a 10000 e anche non negativo. Voglio visualizzarlo come un numero di quattro cifre, con zeri iniziali. C'è qualcosa di più elegante del seguente?

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

Voglio qualcosa che è incorporato in Javascript, ma non riesco a trovare nulla.

Answer 1

Non credo ci sia nulla di "costruito" nel linguaggio JavaScript per farlo. Ecco una semplice funzione che fa questo:

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 2

Questo potrebbe aiutare:

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 3

Si potrebbe impazzire con metodi come questi:

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

Ma non renderà la vita più facile . C# è un metodo come PadLeft e PadRight nella classe String, purtroppo Javascript non avere questa funzionalità build-in

Answer 4

Che ne dite di qualcosa di simile:

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 5

Un modo divertente (ma interessante) come prefisso numeri con zeri:

function FormatInteger(num, length) { 

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

Answer 6

Un ciclo "while" dovrebbe renderlo abbastanza semplice.

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

Che farebbe scorrere fino alla lunghezza del valore num raggiunto 4 cifre (ammesso che abbiate passato nel id dell'elemento numero come argomento)

Answer 7

Ho incontrato più o meno lo stesso problema e ho trovato un modo compatto per risolverlo. Se dovessi usarlo più volte nel mio codice o se lo facessi per più di quattro cifre, userei una delle altre soluzioni suggerite, ma in questo modo mi consente di mettere tutto in un'espressione:

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

In realtà è lo stesso del codice, ma utilizzando l'operatore ternario anziché le istruzioni "if-else" (e spostando "+ x", che sarà sempre parte dell'espressione, al di fuori del codice condizionale).

Answer 8

Il modo più semplice ci penso, è questa:

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

Un numero imbottita è una stringa.
Quando si aggiunge un numero a una stringa, questo viene convertito in una stringa.
Le stringhe hanno il metodo slice, che riattribuisce un pezzo di lunghezza fissa della stringa.
Se la lunghezza è negativa, ritorna dalla fine.

alla prova:

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

(Di causa questo funziona solo per numeri interi positivi fino a 4 cifre)

Answer 9

un altro:

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 10

penso che il più compatto e intuitivo è:

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

T Il metodo slice qui può essere sostituito con substr se questo è più intuitivo per il programmatore.

Answer 11

Sono venuto a cercare la risposta, ma penso che questo sia un approccio migliore funzionale (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" 

anche, questo può essere implementato solo in una sola riga