Come posso pad un valore con zeri?
https://stackoverflow.com/questions/1267283
-
13-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Qual è il metodo consigliato per ZEROFILL un valore in JavaScript? Immagino ho potuto costruire una funzione personalizzata per zeri pad su un valore typecasted, ma mi chiedo se c'è un modo più diretto per fare questo?
Nota. Per "zerofilled" Dico sul serio, nel senso banca dati della parola (in cui una rappresentazione zerofilled 6 cifre del numero 5 sarebbe "000005")
Soluzione
Nota per i lettori!
Come commentatori hanno sottolineato, questa soluzione è "intelligente", e come soluzioni intelligenti sono spesso, è intensivo di memoria e relativamente lento. Se le prestazioni sono un problema per voi, non utilizzare questa soluzione!
Potenzialmente superate : ECMAScript 2017 include String.prototype.padStart e Number.prototype.toLocaleString è lì da ECMAScript 3.1. Esempio:
var n=-0.1; n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false})... sarà in uscita "-0.000,10".
// or const padded = (.1+"").padStart(6,"0"); `-${padded}`... sarà in uscita "-0.000,1".
Una funzione semplice è tutto ciò che serve
function zeroFill( number, width )
{
width -= number.toString().length;
if ( width > 0 )
{
return new Array( width + (/\./.test( number ) ? 2 : 1) ).join( '0' ) + number;
}
return number + ""; // always return a string
}
è possibile cuocere questo in una libreria, se si vuole risparmiare spazio dei nomi o qualsiasi altra cosa. Come con jQuery di estendere .
Altri suggerimenti
modo semplice. Si potrebbe aggiungere stringa di moltiplicazione per il pad e di trasformarlo in una funzione.
var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);
In funzione,
function paddy(num, padlen, padchar) {
var pad_char = typeof padchar !== 'undefined' ? padchar : '0';
var pad = new Array(1 + padlen).join(pad_char);
return (pad + num).slice(-pad.length);
}
var fu = paddy(14, 5); // 00014
var bar = paddy(2, 4, '#'); // ###2
Non posso credere che tutte le risposte complesse su qui ... Basta usare questo:
var zerofilled = ('0000'+n).slice(-4);
Ho dovuto venire con qualcosa di simile a questo di recente. Ho pensato che ci doveva essere un modo per farlo senza l'utilizzo di loop.
Questo è quello che mi è venuta.
function zeroPad(num, numZeros) {
var n = Math.abs(num);
var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
var zeroString = Math.pow(10,zeros).toString().substr(1);
if( num < 0 ) {
zeroString = '-' + zeroString;
}
return zeroString+n;
}
Poi basta usarlo fornendo un numero di pad a zero:
> zeroPad(50,4);
"0050"
Se il numero è più grande l'imbottitura, il numero si espanderà al di là del padding:
> zeroPad(51234, 3);
"51234"
I decimali vanno bene anche!
> zeroPad(51.1234, 4);
"0051.1234"
Se non ti dispiace inquinare il namespace globale è possibile aggiungere al numero direttamente:
Number.prototype.leftZeroPad = function(numZeros) {
var n = Math.abs(this);
var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
var zeroString = Math.pow(10,zeros).toString().substr(1);
if( this < 0 ) {
zeroString = '-' + zeroString;
}
return zeroString+n;
}
E se si preferisce avere decimali occupano spazio nella padding:
Number.prototype.leftZeroPad = function(numZeros) {
var n = Math.abs(this);
var zeros = Math.max(0, numZeros - n.toString().length );
var zeroString = Math.pow(10,zeros).toString().substr(1);
if( this < 0 ) {
zeroString = '-' + zeroString;
}
return zeroString+n;
}
Cheers!
XDR si avvicinò con una variazione logaritmica che sembra funzionare meglio.
Attenzione : Questa funzione fallisce se num è uguale a zero (ad esempio zeropad (0, 2))
function zeroPad (num, numZeros) {
var an = Math.abs (num);
var digitCount = 1 + Math.floor (Math.log (an) / Math.LN10);
if (digitCount >= numZeros) {
return num;
}
var zeroString = Math.pow (10, numZeros - digitCount).toString ().substr (1);
return num < 0 ? '-' + zeroString + an : zeroString + an;
}
A proposito di prestazioni, tomsmeding rispetto i primi 3 risposte ( 4 con la variazione di registro ). Indovinare quale majorly sovraperformato gli altri due? :)
Ecco quello che ho usato per riempire un numero massimo di 7 caratteri.
("0000000" + number).slice(-7)
Questo approccio sarà probabilmente sufficiente per la maggior parte delle persone.
Edit: Se si vuole rendere più generico si può fare questo:
("0".repeat(padding) + number).slice(-padding)
Modifica 2: Si noti che, dal momento ES2017 è possibile utilizzare String.prototype.padStart:
number.toString().padStart(padding, "0")
Purtroppo, ci sono un sacco di suggerimenti complicati inutili per questo problema, di solito coinvolge la scrittura la propria funzione di fare matematica o di manipolazione di stringhe o chiamare un programma di utilità di terze parti. Tuttavia, c'è un modo standard di fare questo nella libreria JavaScript di base con una sola riga di codice. Potrebbe valere la pena di chiudere questo una linea di codice in una funzione per evitare di dover specificare i parametri che non si desidera modificare, come il nome locale o di stile.
var amount = 5;
var text = amount.toLocaleString('en-US',
{
style: 'decimal',
minimumIntegerDigits: 3,
useGrouping: false
});
Questo produrrà il valore di "005" per il testo. È inoltre possibile utilizzare la funzione di toLocaleString numero di zeri pad a destra del punto decimale.
var amount = 5;
var text = amount.toLocaleString('en-US',
{
style: 'decimal',
minimumFractionDigits: 2,
useGrouping: false
});
Questo produrrà il valore di "5,00" per il testo. Cambiare useGrouping su true per utilizzare la virgola come separatore per le migliaia.
Si noti che usare toLocaleString() con locales e options argomenti è standardizzato separatamente in ECMA-402 , non in ECMAScript. Ad oggi, alcuni browser implementano solo supporto di base , vale a dire toLocaleString() può ignorare qualsiasi argomento.
Se il numero di riempimento è noto in anticipo di non superare un certo valore, c'è un altro modo per fare questo con nessun cicli:
var fillZeroes = "00000000000000000000"; // max number of zero fill ever asked for in global
function zeroFill(number, width) {
// make sure it's a string
var input = number + "";
var prefix = "";
if (input.charAt(0) === '-') {
prefix = "-";
input = input.slice(1);
--width;
}
var fillAmt = Math.max(width - input.length, 0);
return prefix + fillZeroes.slice(0, fillAmt) + input;
}
Casi di test qui: http://jsfiddle.net/jfriend00/N87mZ/
In una proposta (3 fasi) Metodo ES2017 .padStart() è possibile semplicemente fare ora (quando implementato / supportato):
string.padStart(maxLength, "0"); //max length is the max string length, not max # of fills
Il modo più rapido e sporco:
y = (new Array(count + 1 - x.toString().length)).join('0') + x;
Per x = 5 e contare = 6 Dovrete y = "000005"
Ecco una funzione quick mi è venuta per fare il lavoro. Se qualcuno ha un approccio più semplice, sentitevi liberi di condividere!
function zerofill(number, length) {
// Setup
var result = number.toString();
var pad = length - result.length;
while(pad > 0) {
result = '0' + result;
pad--;
}
return result;
}
in ritardo alla festa qui, ma io spesso uso questo costrutto per fare imbottiture ad hoc di alcuni n valore, noto per essere uno spirito positivo, decimali:
(offset + n + '').substr(1);
Dove offset è di 10 ^^ cifre.
es. Imbottitura a 5 cifre, dove n = 123:
(1e5 + 123 + '').substr(1); // => 00123
La versione esadecimale di questo è un po 'più dettagliato:
(0x100000 + 0x123).toString(16).substr(1); // => 00123
Nota 1: Mi piace @ soluzione profitehlolz pure, che è la versione stringa di questo, utilizzando slice () 's elegante aspetto negativo-index
.Io davvero non so perché, ma nessuno ha fatto nel modo più ovvio. Qui è la mia realizzazione.
funzione:
/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
var num = number+"";
while(num.length < digits){
num='0'+num;
}
return num;
}
Prototipo:
Number.prototype.zeroPad=function(digits){
var num=this+"";
while(num.length < digits){
num='0'+num;
}
return(num);
};
Molto semplice, non riesco a vedere alcun modo come questo può essere più semplice. Per qualche motivo che ho sembra molte volte qui su SO, la gente cerca di evitare 'per' e 'mentre' loop ad ogni costo. Utilizzando regex probabilmente costerà modo più cicli per una tale imbottitura banale a 8 cifre.
Io uso questo frammento di codice per ottenere una rappresentazione 5 cifre
(value+100000).toString().slice(-5) // "00123" with value=123
Il potere della matematica!
x = intero al pad
y = numero di zeri al pad
function zeroPad(x, y)
{
y = Math.max(y-1,0);
var n = (x / Math.pow(10,y)).toFixed(y);
return n.replace('.','');
}
ECMAScript 2017: utilizzare padStart o padEnd
'abc'.padStart(10); // " abc"
'abc'.padStart(10, "foo"); // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
Più informazioni:
Non ho visto nessuno sottolineare il fatto che quando si utilizza String.prototype.substr () con un numero negativo che conta da destra.
Una soluzione uno di linea alla domanda del PO, una rappresentazione zerofilled 6 cifre del numero 5, è:
console.log(("00000000" + 5).substr(-6));
Generalizzando ci arriveremo:
function pad(num, len) { return ("00000000" + num).substr(-len) };
console.log(pad(5, 6));
console.log(pad(45, 6));
console.log(pad(345, 6));
console.log(pad(2345, 6));
console.log(pad(12345, 6));
Il primo parametro è un numero reale, secondo parametro è un numero intero positivo che specifica il numero minimo di cifre a sinistra del punto decimale e terzo parametro è un numero intero positivo facoltativo che specifica il numero se cifre a destra del punto decimale.
function zPad(n, l, r){
return(a=String(n).match(/(^-?)(\d*)\.?(\d*)/))?a[1]+(Array(l).join(0)+a[2]).slice(-Math.max(l,a[2].length))+('undefined'!==typeof r?(0<r?'.':'')+(a[3]+Array(r+1).join(0)).slice(0,r):a[3]?'.'+a[3]:''):0
}
così
zPad(6, 2) === '06'
zPad(-6, 2) === '-06'
zPad(600.2, 2) === '600.2'
zPad(-600, 2) === '-600'
zPad(6.2, 3) === '006.2'
zPad(-6.2, 3) === '-006.2'
zPad(6.2, 3, 0) === '006'
zPad(6, 2, 3) === '06.000'
zPad(600.2, 2, 3) === '600.200'
zPad(-600.1499, 2, 3) === '-600.149'
Non reinventare la ruota, utilizzare sottolineare stringa :
var numToPad = '5';
alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'
Questa è la soluzione ES6.
function pad(num, len) {
return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));
Dopo una, molto, molto tempo di test 15 differenti funzioni / metodi si trovano in questa domanda risposte, ora so che è il migliore (il più versatile e veloce).
Ho preso 15 funzioni / metodi dalle risposte a questa domanda e ha fatto uno script per misurare il tempo di esecuzione di 100 pastiglie. Ciascun tampone sarebbe pad il numero 9 con zeri 2000. Questo può sembrare eccessiva, e lo è, ma ti dà una buona idea circa il ridimensionamento delle funzioni.
Il codice che ho usato può essere trovato qui: https://gist.github.com/NextToNothing/6325915
Sentitevi liberi di modificare e testare il codice.
Al fine di ottenere il metodo più versatile, è necessario utilizzare un ciclo. Questo perché con numeri molto grandi gli altri rischiano di fallire, mentre, questo avrà successo.
Quindi, quale anello da usare? Beh, quello sarebbe un loop while. Un ciclo for è ancora veloce, ma un ciclo while è solo leggermente più veloce (un paio di ms) -. E più pulito
Le risposte come quelle di Wilco, Aleksandar Toplek o Vitim.us farà il lavoro perfettamente.
Personalmente, ho provato un approccio diverso. Ho provato ad utilizzare una funzione ricorsiva al pad stringa / numero. Ha funzionato meglio di metodi di giunzione una matrice, ma, ancora, non ha funzionato più velocemente un ciclo for.
La mia funzione è:
function pad(str, max, padder) {
padder = typeof padder === "undefined" ? "0" : padder;
return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}
È possibile utilizzare la mia funzione con, o senza, impostando la variabile imbottitura. Quindi, in questo modo:
pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'
Personalmente, dopo le mie prove, vorrei utilizzare un metodo con un ciclo while, come Aleksandar Toplek o Vitim.us. Tuttavia, vorrei modifico leggermente in modo che siano in grado di impostare la stringa padding.
Quindi, vorrei utilizzare questo codice:
function padLeft(str, len, pad) {
pad = typeof pad === "undefined" ? "0" : pad + "";
str = str + "";
while(str.length < len) {
str = pad + str;
}
return str;
}
// Usage
padLeft(1, 3); // Returns '001'
// - Or -
padLeft(1, 3, "x"); // Returns 'xx1'
Si potrebbe anche usare come un prototipo di funzione, utilizzando questo codice:
Number.prototype.padLeft = function(len, pad) {
pad = typeof pad === "undefined" ? "0" : pad + "";
var str = this + "";
while(str.length < len) {
str = pad + str;
}
return str;
}
// Usage
var num = 1;
num.padLeft(3); // Returns '001'
// - Or -
num.padLeft(3, "x"); // Returns 'xx1'
In tutti i browser moderni è possibile utilizzare
numberStr.padStart(numberLength, "0");
function zeroFill(num, numLength) {
var numberStr = num.toString();
return numberStr.padStart(numLength, "0");
}
var numbers = [0, 1, 12, 123, 1234, 12345];
numbers.forEach(
function(num) {
var numString = num.toString();
var paddedNum = zeroFill(numString, 5);
console.log(paddedNum);
}
);
Ecco il https: / /developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
Non che questa domanda ha bisogno di più risposte, ma ho pensato di aggiungere la versione semplice lodash di questo.
_.padLeft(number, 6, '0')
L'ultimo modo per farlo è molto più semplice:
var number = 2
number.toLocaleString(undefined, {minimumIntegerDigits:2})
output: "02"
Solo un un'altra soluzione, ma penso che sia più leggibile.
function zeroFill(text, size)
{
while (text.length < size){
text = "0" + text;
}
return text;
}
Questo è meno nativa, ma può essere il più veloce ...
zeroPad = function (num, count) {
var pad = (num + '').length - count;
while(--pad > -1) {
num = '0' + num;
}
return num;
};
La mia soluzione
Number.prototype.PadLeft = function (length, digit) {
var str = '' + this;
while (str.length < length) {
str = (digit || '0') + str;
}
return str;
};
Uso
var a = 567.25;
a.PadLeft(10); // 0000567.25
var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25
Perché non usare la ricorsione?
function padZero(s, n) {
s = s.toString(); // in case someone passes a number
return s.length >= n ? s : padZero('0' + s, n);
}
Alcuni monkeypatching funziona anche
String.prototype.padLeft = function (n, c) {
if (isNaN(n))
return null;
c = c || "0";
return (new Array(n).join(c).substring(0, this.length-n)) + this;
};
var paddedValue = "123".padLeft(6); // returns "000123"
var otherPadded = "TEXT".padLeft(8, " "); // returns " TEXT"
function pad(toPad, padChar, length){
return (String(toPad).length < length)
? new Array(length - String(toPad).length + 1).join(padChar) + String(toPad)
: toPad;
}
pad(5, 0, 6) = 000005
pad('10', 0, 2) = 10 // don't pad if not necessary
pad('S', 'O', 2) = SO
... etc.
Saluti
Il semplice , soluzione più straight-forward che troverete.
function zerofill(number,length) {
var output = number.toString();
while(output.length < length) {
output = '0' + output;
}
return output;
}
