如何用前导零填充一个值?

推荐使用JavaScript填充值的方法是什么? 我想我可以build立一个自定义的函数来填充一个typecasted值的零,但我想知道是否有一个更直接的方法来做到这一点?

注意: “zerofilled”的意思是数据库意义上的字(数字5的一个6位数的零填充表示将是“000005”)。

给读者的提示!

正如评论者指出的那样,这个解决scheme是“聪明的”,聪明的解决scheme往往是内存密集的,相对较慢。 如果性能是您关心的问题,请不要使用此解决scheme!

可能过时 :ECMAScript 2017包含String.prototype.padStart和Number.prototype.toLocaleString ,因为ECMAScript 3.1。 例:

 var n=-0.1;n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false}) 

…会输出“-0000.10”。

一个简单的function就是你所需要的

 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 } 

如果你想保存命名空间或任何东西,你可以把它烧成一个库。 就像jQuery的扩展一样 。

简单的方法。 你可以为pad添加string乘法,并把它变成一个函数。

 var pad = "000000"; var n = '5'; var result = (pad+n).slice(-pad.length); 

作为一项function,

 function paddy(n, p, c) { var pad_char = typeof c !== 'undefined' ? c : '0'; var pad = new Array(1 + p).join(pad_char); return (pad + n).slice(-pad.length); } var fu = paddy(14, 5); // 00014 var bar = paddy(2, 4, '#'); // ###2 

我不能相信这里的所有复杂的答案…只是使用这个:

var zerofilled = ('0000'+n).slice(-4);
var zerofilled = ('0000'+n).slice(-4); 

我最近不得不想出这样的事情。 我觉得必须有一种方法来做到这一点,而不使用循环。

这是我想出来的。

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

然后使用它提供一个数字零垫:

 > zeroPad(50,4); "0050" 

如果数字大于填充,则数字将扩展超出填充:

 > zeroPad(51234, 3); "51234" 

小数点也可以!

 > zeroPad(51.1234, 4); "0051.1234" 

如果您不介意污染全局名称空间,则可以直接将其添加到Number中:

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

而且如果你想让小数点在填充中占用一些空间:

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

干杯!



XDR提出了一个似乎performance更好的对数变化

警告 :如果num等于零,则此函数失败(例如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; } 

说到性能, tomsmeding 比较了前3个答案 ( 4与日志变化 )。 猜猜哪一个主要跑赢其他两个? 🙂

这是我用来填充最多7个字符的数字。

 ("0000000" + number).slice(-7) 

这种方法对大多数人来说可能就足够了。

编辑:如果你想使它更通用,你可以这样做:

 ("0".repeat(padding) + number).slice(-padding) 

如果填充号码事先知道不超过某个值,还有另外一种方法可以不用循环:

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

这里的testing用例: http : //jsfiddle.net/jfriend00/N87mZ/

不幸的是,这个问题有很多不必要的复杂build议,通常涉及编写自己的函数来进行math或string操作或调用第三方实用程序。 但是,只有一行代码,在基本JavaScript库中有这样做的标准方法。 在函数中包含这一行代码可能是值得的,以避免必须指定你永远不想改变的参数,如本地名称或样式。

 var amount = 5; var text = amount.toLocaleString('en-US', { style: 'decimal', minimumIntegerDigits: 3, useGrouping: false }); 

这将产生文本的值“005”。 您还可以使用Number的toLocaleString函数将零填充到小数点的右侧。

 var amount = 5; var text = amount.toLocaleString('en-US', { style: 'decimal', minimumFractionDigits: 2, useGrouping: false }); 

这将产生文本“5.00”的值。 将useGrouping更改为true以使用逗号分隔符为数千个。

请注意,在localesoptions参数中使用toLocaleString() 在ECMA-402中是分开标准化的 ,而不是在ECMAScript中标准化。 截至今天,一些浏览器只实现基本支持 ,即toLocaleString()可能会忽略任何参数。

完整的例子

快速和肮脏的方式:

 y = (new Array(count + 1 - x.toString().length)).join('0') + x; 

对于x = 5和count = 6,你将有y =“000005”

在build议的(阶段3)ES2017方法.padStart()您现在可以简单地执行(当实现/支持时):

 string.padStart(maxLength, "0"); //max length is the max string length, not max # of fills 

我想出了一个快速的function来完成这项工作。 如果有人有一个更简单的方法,随时分享!

 function zerofill(number, length) { // Setup var result = number.toString(); var pad = length - result.length; while(pad > 0) { result = '0' + result; pad--; } return result; } 

在这里晚了,但是我经常使用这个构造来做一些值为n的特殊填充,这个值被称为正数,小数:

 (offset + n + '').substr(1); 

其中offset是10 ^^数字。

例如填充到5位数,其中n = 123:

 (1e5 + 123 + '').substr(1); // => 00123 

这个hex版本稍微冗长:

 (0x100000 + 0x123).toString(16).substr(1); // => 00123 

注1:我喜欢@ profitehlolz的解决scheme,这是string版本,使用slice()的漂亮的负指数function。

我真的不知道为什么,但没有人以最明显的方式去做。 这是我的实现。

function:

 /** Pad a number with 0 on the left */ function zeroPad(number, digits) { var num = number+""; while(num.length < digits){ num='0'+num; } return num; } 

原型:

 Number.prototype.zeroPad=function(digits){ var num=this+""; while(num.length < digits){ num='0'+num; } return(num); }; 

非常简单,我看不出任何方式可以简单。 出于某种原因,我在这里似乎已经有很多次了,人们只是不惜一切代价来避免“for”和“while”循环。 使用正则expression式可能会花费更多的周期为这样一个微不足道的8位填充。

我用这snipet得到一个5位数的表示

 (value+100000).toString().slice(-5) // "00123" with value=123 

math的力量!

x =整数垫
y =填充零的数量

 function zeroPad(x, y) { y = Math.max(y-1,0); var n = (x / Math.pow(10,y)).toFixed(y); return n.replace('.',''); } 

不要重新发明轮子,使用下划线string :

的jsfiddle

 var numToPad = '5'; alert(_.str.pad(numToPad, 6, '0')); // yields: '000005' 

经过很长时间的testing发现这个问题中的15个不同的function/方法,我现在知道哪个是最好的(最通用和最快的)。

我从这个问题的答案中拿出了15个函数/方法,并且用一个脚本来测量执行100个焊盘所花费的时间。 每个垫将填充2000零的数字9 。 这可能看起来过分了,但是它给你一个关于函数缩放的好主意。

我使用的代码可以在这里find: https : //gist.github.com/NextToNothing/6325915

随意自行修改和testing代码。

为了得到最通用的方法,你必须使用一个循环。 这是因为很多人可能会失败,而这将会成功。

那么,使用哪个循环? 那么,那将是一个while循环。 一个for循环仍然很快,但一个while循环稍微快一点(几个毫秒) – 而且更干净。

WilcoAleksandar ToplekVitim.us那样的Vitim.us将完美地完成这项工作。

就我个人而言,我尝试了不同的方法。 我试图使用recursion函数来填充string/数字。 它比join数组的方法更好,但仍然没有像for循环那样快。

我的function是:

 function pad(str, max, padder) { padder = typeof padder === "undefined" ? "0" : padder; return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str; } 

你可以使用我的function,或不使用,设置填充variables。 所以像这样:

 pad(1, 3); // Returns '001' // - Or - pad(1, 3, "x"); // Returns 'xx1' 

就个人而言,在我的testing后,我会用一个while循环的方法,像Aleksandar ToplekVitim.us 。 但是,我会稍微修改它,以便您可以设置填充string。

所以,我会使用这个代码:

 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' 

你也可以用它作为原型函数,通过使用这个代码:

 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' 

第一个参数是任何实数,第二个参数是指定小数点左边的最小位数的正整数,第三个参数是指定小数点右边的位数的可选正整数。

 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 } 

所以

  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' 

这是ES6解决scheme。

 function pad(num, len) { return '0'.repeat(len - num.toString().length) + num; } alert(pad(1234,6)); 

ECMAScript 2017:使用padStartpadEnd

 'abc'.padStart(10); // " abc" 'abc'.padStart(10, "foo"); // "foofoofabc" 'abc'.padStart(6,"123465"); // "123abc" 

更多信息:

这一个是不太原生的,但可能是最快的…

 zeroPad = function (num, count) { var pad = (num + '').length - count; while(--pad > -1) { num = '0' + num; } return num; }; 

我的解决scheme

 Number.prototype.PadLeft = function (length, digit) { var str = '' + this; while (str.length < length) { str = (digit || '0') + str; } return str; }; 

用法

 var a = 567.25; a.PadLeft(10); // 0000567.25 var b = 567.25; b.PadLeft(20, '2'); // 22222222222222567.25 

不是说这个问题需要更多的答案,但我想我会添加这个简单的lodash版本。

_.padLeft(number, 6, '0')

最新的做法是简单得多:

 var number = 2 number.toLocaleString(undefined, {minimumIntegerDigits:2}) 

output: "02"

为什么不使用recursion?

 function padZero(s, n) { s = s.toString(); // in case someone passes a number return s.length >= n ? s : padZero('0' + s, n); } 

我没有看到任何人指出,当您使用String.prototype.substr()与一个负数时,它从右边数。

对OP问题的一个单线解决scheme是5号的6位数字填充表示:

 console.log(("00000000" + 5).substr(-6)); 

一些monkeypatching也适用

 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(5, 0, 6) = 000005

pad('10', 0, 2) = 10 // don't pad if not necessary

pad('S', 'O', 2) = SO

…等等。

干杯

最简单 ,最直接的解决scheme,你会发现。

 function zerofill(number,length) { var output = number.toString(); while(output.length < length) { output = '0' + output; } return output; } 

只是为了好玩,这是我的版本的垫function:

 function pad(num, len) { return Array(len + 1 - num.toString().length).join('0') + num; } 

它也不会截断比填充长度更长的数字

只是另一个解决scheme,但我认为它更清晰。

 function zeroFill(text, size) { while (text.length < size){ text = "0" + text; } return text; }