如何用前导零填充一个值？
推荐使用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以使用逗号分隔符为数千个。
请注意，在locales和options参数中使用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循环稍微快一点（几个毫秒） – 而且更干净。
像Wilco ， Aleksandar Toplek或Vitim.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 Toplek或Vitim.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：使用padStart或padEnd
'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; }
