在JavaScript中对值进行zerofill的推荐方法是什么？我想我可以构建一个自定义函数来将零填充到一个类型化的值，但我想知道是否有更直接的方法来执行此操作？
注意：“zerofilled”我的意思是数据库中的单词意义（数字5的6位零填充表示形式为“000005”）。
答案 0 :(得分：297)
简单的方法。您可以为打击垫添加字符串乘法并将其转换为函数。
var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);
作为一项功能，
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
答案 1 :(得分：259)
我无法相信这里所有复杂的答案......只需使用：
var zerofilled = ('0000'+n).slice(-4);
答案 2 :(得分：194)
读者注意！
正如评论者指出的那样，这种解决方案是“聪明的”，并且如此 巧妙的解决方案通常是，它是内存密集型和相对的 慢。如果您担心性能问题，请不要使用此解决方案！
潜在过时 ：自ECMAScript 3.1起，ECMAScript 2017包括String.prototype.padStart和Number.prototype.toLocaleString。例如：
var n=-0.1; n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false})...将输出“-0000.10”。
// or const padded = (.1+"").padStart(6,"0"); `-${padded}`...将输出“-0000.1”。
您需要的只是一个简单的功能
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
}
答案 3 :(得分：105)
我最近不得不想出这样的事情。 我认为必须有一种方法可以在不使用循环的情况下完成它。
这就是我想出来的。
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提出了对数变化，似乎效果更好。
警告：如果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 compared the top 3 answers（4 with the log variation）。猜猜哪一个主要胜过其他两个？ ：）
答案 4 :(得分：57)
以下是我用来填充最多7个字符的数字。
("0000000" + number).slice(-7)
这种方法可能足以满足大多数人的需求。
编辑：如果你想让它更通用，你可以这样做：
("0".repeat(padding) + number).slice(-padding)
答案 5 :(得分：25)
不幸的是，对于这个问题有很多不必要的复杂建议，通常包括编写自己的函数来进行数学或字符串操作或调用第三方实用程序。但是，只需一行代码就可以在基本JavaScript库中执行此操作的标准方法。在函数中包含这一行代码可能是值得的，以避免必须指定您永远不想更改的参数，如本地名称或样式。
var amount = 5;
var text = amount.toLocaleString('en-US',
{
style: 'decimal',
minimumIntegerDigits: 3,
useGrouping: false
});
这将产生＆＃34; 005＆＃34;对于文本。您还可以使用Number的toLocaleString函数将零填充到小数点的右侧。
var amount = 5;
var text = amount.toLocaleString('en-US',
{
style: 'decimal',
minimumFractionDigits: 2,
useGrouping: false
});
这将产生＆＃34; 5.00＆＃34;对于文本。将useGrouping更改为true以使用数千个逗号分隔符。
请注意，toLocaleString()使用locales和options参数is standardized separately in ECMA-402，而不是ECMAScript。截至今天，某些浏览器only implement basic support，即toLocaleString()可能会忽略任何参数。
答案 6 :(得分：20)
如果预先知道填充编号不超过某个值，那么还有另一种方法可以做到这一点而没有循环：
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;
}
答案 7 :(得分：19)
在提议的（阶段3）ES2017方法.padStart()中，您现在可以做到（当实施/支持时）：
string.padStart(maxLength, "0"); //max length is the max string length, not max # of fills
答案 8 :(得分：18)
快速而肮脏的方式：
y = (new Array(count + 1 - x.toString().length)).join('0') + x;
对于x = 5和count = 6，你将得到y =“000005”
答案 9 :(得分：12)
这是我想出来完成这项工作的快速功能。如果有人有更简单的方法，请随时分享！
function zerofill(number, length) {
// Setup
var result = number.toString();
var pad = length - result.length;
while(pad > 0) {
result = '0' + result;
pad--;
}
return result;
}
答案 10 :(得分：11)
我真的不知道为什么，但没有人以最明显的方式做到这一点。这是我的实施。
功能：
/** 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'循环。使用正则表达式可能会花费更多的周期来进行这种简单的8位填充。
答案 11 :(得分：11)
这里的派对迟到了，但我经常使用这个构造来做一些值n的ad-hoc填充，已知是一个正数，小数：
(offset + n + '').substr(1);
offset为10 ^^位。
E.g。填充到5位数，其中n = 123：
(1e5 + 123 + '').substr(1); // => 00123
这个的十六进制版本稍微冗长一点：
(0x100000 + 0x123).toString(16).substr(1); // => 00123
注1：我也喜欢@ profitehlolz的解决方案，这是使用slice（）的漂亮的负索引功能的字符串版本。
答案 12 :(得分：10)
我使用此代码段获得5位数字表示
(value+100000).toString().slice(-5) // "00123" with value=123
答案 13 :(得分：8)
我没有看到有人指出这样一个事实：当你使用带有负数的String.prototype.substr()时，它会从右边算起。
OP问题的单线解决方案是5号的6位零填充表示：
console.log(("00000000" + 5).substr(-6));
概括我们得到：
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));
答案 14 :(得分：8)
数学的力量！
x =填充整数
y =要填充的零的数量
function zeroPad(x, y)
{
y = Math.max(y-1,0);
var n = (x / Math.pow(10,y)).toFixed(y);
return n.replace('.','');
}
答案 15 :(得分：7)
不要重新发明方向盘，请使用underscore string：
var numToPad = '5';
alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'
答案 16 :(得分：7)
第一个参数是任意实数，第二个参数是一个正整数，指定小数点左边的最小位数，第三个参数是一个可选的正整数，指定小数点右边的数字。
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'
答案 17 :(得分：7)
这是ES6解决方案。
function pad(num, len) {
return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));
答案 18 :(得分：6)
ECMAScript 2017： 使用 padStart 或 padEnd
'abc'.padStart(10); // " abc"
'abc'.padStart(10, "foo"); // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
更多信息：
答案 19 :(得分：6)
经过长时间的长时间测试，在这个问题答案中找到了15个不同的功能/方法，我现在知道哪个是最好的（最通用和最快）。
我从这个问题的答案中选取了15个函数/方法，并制作了一个脚本来测量执行100个填充所需的时间。每个打击垫都会填充9个2000个零。这可能看起来过分，而且它可以让你对功能的缩放有一个很好的了解。
我在这里可以找到我使用的代码： https://gist.github.com/NextToNothing/6325915
随意修改和测试代码。
为了获得最通用的方法，您必须使用循环。这是因为非常大的数字可能会失败，而这将成功。
那么，使用哪个循环？好吧，这将是一个while循环。 for循环仍然很快，但while循环只是稍微快一点（几毫秒） - 而且更干净。
Wilco，Aleksandar Toplek或Vitim.us之类的答案将完美地完成这项工作。
就个人而言，我尝试了不同的方法。我试图使用递归函数来填充字符串/数字。它比加入数组的方法更好，但仍然没有像for循环一样快。
我的功能是：
function pad(str, max, padder) {
padder = typeof padder === "undefined" ? "0" : padder;
return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}
您可以使用或不使用我的函数来设置填充变量。像这样：
pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'
就个人而言，在我的测试之后，我会使用带有while循环的方法，例如Aleksandar Toplek或Vitim.us。但是，我会稍微修改它，以便您可以设置填充字符串。
所以，我会使用这段代码：
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'
答案 20 :(得分：5)
在所有现代浏览器中，您都可以使用
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);
}
);
这是MDN参考https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
答案 21 :(得分：4)
最新的方法更为简单：
var number = 2
number.toLocaleString(undefined, {minimumIntegerDigits:2})
output: "02"
答案 22 :(得分：4)
只是另一种解决方案，但我认为它更清晰。
function zeroFill(text, size)
{
while (text.length < size){
text = "0" + text;
}
return text;
}
答案 23 :(得分：4)
不是说这个问题需要更多的答案，但我想我会添加简单的lodash版本。
_.padLeft(number, 6, '0')
答案 24 :(得分：3)
为什么不使用递归？
function padZero(s, n) {
s = s.toString(); // in case someone passes a number
return s.length >= n ? s : padZero('0' + s, n);
}
答案 25 :(得分：3)
这个本土较少，但可能是最快的......
zeroPad = function (num, count) {
var pad = (num + '').length - count;
while(--pad > -1) {
num = '0' + num;
}
return num;
};
答案 26 :(得分：3)
我的解决方案
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
答案 27 :(得分：2)
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
...等
干杯
答案 28 :(得分：2)
如果性能非常关键（循环数百万条记录），可以预先生成一个填充字符串数组，避免为每次调用执行此操作。
时间复杂度： O（1）。
空间复杂度： O（1）。
<!DOCTYPE HTML>
<html>
<body>
<p id="test"></p> // this is where date will be displayed
<script>
var date = new Date(); // i get the date
var m = date.getMonth(); // i get the month
var fm; // all this is to convert number to month name
if (m===0){fm="January";}
else if (m===1){fm="February";}
else if (m===2){fm="March";}
else if (m===3){fm="April";}
else if (m===4){fm="May";}
else if (m===5){fm="Jun";}
else if (m===6){fm="July";}
else if (m===7){fm="August";}
else if (m===8){fm="September";}
else if (m===9){fm="October";}
else if (m===10){fm="November";}
else if (m===11){fm="December";}
else {fm="Error01"}console.log(fm)
var d = date.getDate(); // the day
var y = date.getFullYear();
document.getElementById("test").innerHTML= fm + " is the month, " + d + " is the Date(day) and "+ y + " is the full year";
// i removed this ^ to highlight the new output below:
//document.getElementById("test").innerHTML= date + "<br>" + m + " - " + fm;
//the above code has completed tests properly, and so has been replaced by the original code
</script>
</body>
</html>
答案 29 :(得分：2)
只是为了好玩，这是我的pad功能版本：
function pad(num, len) {
return Array(len + 1 - num.toString().length).join('0') + num;
}
它也不会截断长于填充长度的数字
答案 30 :(得分：2)
最简单 ，您将找到最直接的解决方案。
function zerofill(number,length) {
var output = number.toString();
while(output.length < length) {
output = '0' + output;
}
return output;
}
答案 31 :(得分：2)
一些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"
答案 32 :(得分：1)
sprintf.js 是一个完整的开源JavaScript sprintf实现 对于浏览器和node.js。
它的原型很简单：
string sprintf(string format , [mixed arg1 [, mixed arg2 [ ,...]]])
我想在整个解决方案中推荐来自sprintf module的Alexandru Mărășteanu只是看起来像：
var sprintf = require('sprintf');
var zeroFilled = sprintf('%06d', 5);
console.log(zeroFilled); // 000005
注意：我在6年后回答这个问题，但似乎就是这样 问题变成了一个“ javascript zero leading ”参考考虑 这是很多观点和答案。
答案 33 :(得分：1)
我正在使用这种简单的方法
var input = 1000; //input any number
var len = input.toString().length;
for (i = 1; i < input; i++) {
console.log("MyNumber_" + ('000000000000000' + i).slice(-len));
}
答案 34 :(得分：1)
好的，好吧，我无法相信我在为这个提交另一个答案时感到烦恼，但我认为我的做法有点不同。我需要填充数字的原因是在<pre>元素（屏幕日志的一部分）中显示它，所以它最终将成为一个字符串。我没有做任何数学运算，而是编写了一个简单的函数来将字符串值叠加在掩码字符串上：
function overlayr(m, s) {
return m.length > s.length ? m.substr(0, m.length - s.length) + s : s;
}
这样做的好处是我可以将它用于各种字符串对齐任务。要调用它，只需将掩码和数字作为字符串传递：
> overlayr('00000', (5).toString())
< "00005"
作为额外的奖励，它正确处理溢出：
> overlayr('00000', (555555).toString())
< "555555"
当然，它不仅限于0填充：
> overlayr('*****', (55).toString())
< "***55"
答案 35 :(得分：1)
function zFill(n,l){
return
(l > n.toString().length) ?
( (Array(l).join('0') + n).slice(-l) ) : n;
}
答案 36 :(得分：1)
我对这个主题的贡献很少（https://gist.github.com/lucasferreira/a881606894dde5568029）：
/* Autor: Lucas Ferreira - http://blog.lucasferreira.com | Usage: fz(9) or fz(100, 7) */
function fz(o, s) {
for(var s=Math.max((+s||2),(n=""+Math.abs(o)).length); n.length<s; (n="0"+n));
return (+o < 0 ? "-" : "") + n;
};
用法：
fz(9) & fz(9, 2) == "09"
fz(-3, 2) == "-03"
fz(101, 7) == "0000101"
我知道，这是一个相当脏的功能，但它很快，甚至可以使用负数;）
答案 37 :(得分：1)
function numberPadding(n, p) {
n = n.toString();
var len = p - n.length;
if (len > 0) {
for (var i=0; i < len; i++) {
n = '0' + n;
}
}
return n;
}
答案 38 :(得分：1)
这种方法并不快，但它相当原生。
zeroPad = function (num, count) {
return [Math.pow(10, count - num.toString().length), num].join('').substr(1);
};
答案 39 :(得分：1)
也许我天真，但我认为这适用于一个简单而有效的代码行（对于正数）：
padded = (value+Math.pow(10,total_length)+"").slice(1)
只要你根据你的值设置保持你的长度OK（如任何零填充），这应该有用。
步骤如下：
对于自然列表（文件，目录......）非常有用。
答案 40 :(得分：1)
function zeroFill(number, width) {
width -= (number.toString().length - /\./.test(number));
if (width > 0) {
return new Array(width + 1).join('0') + number;
}
return number + ""; // always return a string
}
对Peter的代码略有改动。使用他的代码，如果输入是（1.2,3），返回的值应该是01.2但它返回1.2。这里的更改应该纠正这一点。
答案 41 :(得分：1)
这是我认为很酷的小技巧：
(2/10000).toString().split(".")[1]
"0002"
(52/10000).toString().split(".")[1]
"0052"
答案 42 :(得分：1)
一个简单的用例（填充毫秒，从不> 999） 您可以为您调整零的数量，或者在需要时使用更通用的方式。
/**
* @val integer
* @zeros padding
*/
function zeroFill(val, zeros)
{
var str = val.toString();
if (str.length >= zeros)
return str;
str = "000" + str;
return str.substring(str.length - zeros);
}
答案 43 :(得分：1)
又一个版本：
function zPad(s,n){
return (new Array(n+1).join('0')+s).substr(-Math.max(n,s.toString().length));
}
答案 44 :(得分：1)
只是想发表评论（但我没有足够的分数），最高投票的答案会因负数和小数而失败
function padNumber(n,pad) {
p = Math.pow(10,pad);
a = Math.abs(n);
g = (n<0);
return (a < p) ? ((g ? '-' : '') + (p+a).toString().substring(1)) : n;
}
padNumber( -31.235, 5);
"-00031.235"
答案 45 :(得分：0)
以下内容提供了快速而又快速的解决方案：
function numberPadLeft(num , max, padder = "0"){
return "" == (num += "") ? "" :
( dif = max - num.length, dif > 0 ?
padder.repeat(dif < 0 ? 0 : dif) + num :
num )
}
答案 46 :(得分：0)
我没有以这种形式看到任何答案，所以在这里我用正则表达式和字符串操作进行了射击
（也适用于负和十进制个数字）
代码：
function fillZeroes(n = 0, m = 1) {
const p = Math.max(1, m);
return String(n).replace(/\d+/, x => '0'.repeat(Math.max(p - x.length, 0)) + x);
}
一些输出：
console.log(fillZeroes(6, 2)) // >> '06'
console.log(fillZeroes(1.35, 2)) // >> '01.35'
console.log(fillZeroes(-16, 3)) // >> '-016'
console.log(fillZeroes(-1.456, 3)) // >> '-001.456'
console.log(fillZeroes(-456.53453, 6)) // >> '-000456.53453'
console.log(fillZeroes('Agent 7', 3)) // >> 'Agent 007'
答案 47 :(得分：0)
我在ecmaScript6（TypeScript）中写了一些东西，也许有人可以使用它：
class Helper {
/**
* adds leading 0 and returns string if value is not minSize long,
* else returns value as string
*
* @param {string|number} value
* @param {number} minSize
* @returns {string}
*/
public static leadingNullString(value: string|number, minSize: number): string {
if (typeof value == "number") {
value = "" + value;
}
let outString: string = '';
let counter: number = minSize - value.length;
if (counter > 0) {
for (let i = 0; i < counter; i++) {
outString += '0';
}
}
return (outString + value);
}
}
Helper.leadingNullString(123, 2);返回“123”
Helper.leadingNullString(5, 2);返回“05”
Helper.leadingNullString(40,2);返回“40”
ecmaScript4（JavaScript）转换如下：
var Helper = (function () {
function Helper() {
}
Helper.leadingNullString = function (value, minSize) {
if (typeof value == "number") {
value = "" + value;
}
var outString = '';
var counter = minSize - value.length;
if (counter > 0) {
for (var i = 0; i < counter; i++) {
outString += '0';
}
}
return (outString + value);
};
return Helper;
}());
答案 48 :(得分：0)
在编写数字基转换器时，我想到了一个荒唐的单行代码。在其他答案中没有看到任何类似的东西，所以去了：
// This is cursed
function p(i,w,z){z=z||0;w=w||8;i+='';var o=i.length%w;return o?[...Array(w-o).fill(z),...i].join(''):i;}
console.log(p(8675309)); // Default: pad w/ 0 to 8 digits
console.log(p(525600, 10)); // Pad to 10 digits
console.log(p(69420, 10, 'X')); // Pad w/ X to 10 digits
console.log(p(8675309, 4)); // Pad to next 4 digits
console.log(p(12345678)); // Don't pad if you ain't gotta pad
或者，以一种不太容易出卖我将自己的灵魂卖给Black Perl的形式：
function pad(input, width, zero) {
zero = zero || 0; width = width || 8; // Defaults
input += ''; // Convert input to string first
var overflow = input.length % width // Do we overflow?
if (overflow) { // Yep! Let's pad it...
var needed = width - overflow; // ...to the next boundary...
var zeroes = Array(needed); // ...with an array...
zeroes = zeroes.fill(zero); // ...full of our zero character...
var output = [...zeroes,...input]; // ...and concat those zeroes to input...
output = output.join(''); // ...and finally stringify.
} else {
var output = input; // We don't overflow; no action needed :)
}
return output; // Done!
}
与其他答案不同的一件事是，它采用数字长度的模到目标宽度，而不是简单的大于校验。如果您要确保结果长度是目标宽度的某些倍数（例如，您需要输出5个或10个字符长），这很方便。
不知道它的性能如何，但是，至少它已经缩小了！
答案 49 :(得分：0)
一个简单而优雅的解决方案，其中n是数字，l是长度。
function nFill (n, l) {return (l>n.toString().length)?((Array(l).join('0')+n).slice(-l)):n;}
如果需要，可以保留长度，以免更改数字。
n = 500;
console.log(nFill(n, 5));
console.log(nFill(n, 2));
function nFill (n, l) {return (l>n.toString().length)?((Array(l).join('0')+n).slice(-l)):n;}
答案 50 :(得分：0)
我有2个解决方案。 第一个是真正的基本数字，如果您知道这就是您想要快速完成的工作，那就用0破坏数字。
第二个也将填充负数-与似乎具有最佳答案分数的“聪明”解决方案相同。
在这里：
// One liner simple mode!
// (always ensure the number is 6 digits long knowing its never negative)
var mynum = 12;
var mynum2 = "0".repeat((n=6-mynum.toString().length)>0?n:0)+mynum;
alert("One liner to pad number to be 6 digits long = Was "+mynum+" Now "+mynum2);
// As a function which will also pad negative numbers
// Yes, i could do a check to only take "-" into account
// if it was passed in as an integer and not a string but
// for this, i haven't.
//
// @s The string or integer to pad
// @l The minumum length of @s
// @c The character to pad with
// @return updated string
function padme(s,l,c){
s = s.toString();
c = c.toString();
m = s.substr(0,1)=="-";
return (m?"-":"")+c.repeat((n=l-(s.length-(m?1:0)))>0?n:0)+s.substr((m?1:0));
}
alert("pad -12 to ensure it is 8 digits long = "+padme(-12,8,0));
alert("pad 'hello' with 'x' to ensure it is 12 digits long = "+padme('hello',12,'x'));
答案 51 :(得分：0)
您可以使用类似以下功能的“零填充数字”：
/**
* @param number The number
* @param minLength Minimal length for your string with leading zeroes
* @return Your formatted string
*/
function zerofill(nb, minLength) {
// Convert your number to string.
let nb2Str = nb.toString()
// Guess the number of zeroes you will have to write.
let nbZeroes = Math.max(0, minLength - nb2Str.length)
// Compute your result.
return `${ '0'.repeat(nbZeroes) }${ nb2Str }`
}
console.log(zerofill(5, 6)) // Displays "000005"
/**
* @param number The number
* @param minLength Minimal length for your string with leading zeroes
* @return Your formatted string
*/
const zerofill = (nb, minLength) => nb.toString().padStart(minLength, '0')
console.log(zerofill(5, 6)) // Displays "000005"
答案 52 :(得分：0)
一个简单的功能：
function padStr(number, numDigits){
return
(number < 0 ? '-':'')
+ ((new Array(numDigits + 1).join("0"))
+ Math.abs(number)).slice(-numDigits);
}
答案 53 :(得分：0)
发布以防这是您要查找的内容，将以毫秒为单位的剩余时间转换为像 00:04:21 这样的字符串
function showTimeRemaining(remain){
minute = 60 * 1000;
hour = 60 * minute;
//
hrs = Math.floor(remain / hour);
remain -= hrs * hour;
mins = Math.floor(remain / minute);
remain -= mins * minute;
secs = Math.floor(remain / 1000);
timeRemaining = hrs.toString().padStart(2, '0') + ":" + mins.toString().padStart(2, '0') + ":" + secs.toString().padStart(2, '0');
return timeRemaining;
}
答案 54 :(得分：0)
如果您的环境中有npm，则可以使用一些现成的包：www.npmjs.com/browse/keyword/zeropad。
我喜欢zero-fill。
安装
$ npm install zero-fill
用法
var zeroFill = require('zero-fill')
zeroFill(4, 1) // '0001'
zeroFill(4, 1, '#') // '###1' custom padding
zeroFill(4)(1) // '0001' partials
答案 55 :(得分：0)
exports.pad = (num, length) => "0".repeat(length - num.toString().length) + num;
答案 56 :(得分：0)
即使是晚会。
function zfill(num, len) {
return(0 > num ? "-" : "") + (Math.pow(10, len) <= Math.abs(num) ? "0" + Math.abs(num) : Math.pow(10, len) + Math.abs(num)).toString().substr(1)
}
这处理负数和数字长于字段宽度的情况。和浮点。
答案 57 :(得分：0)
function numPadding (padding,i) {
return padding.substr(0, padding.length - (Math.floor(i).toString().length)) + Math.floor(i );
}
numPadding("000000000",234); -> "000000234"
或
function numPadding (number, paddingChar,i) {
var padding = new Array(number + 1).join(paddingChar);
return padding.substr(0, padding.length - (Math.floor(i).toString().length)) + Math.floor(i );
}
numPadding(8 ,"0", 234); -> "00000234";
答案 58 :(得分：0)
可变长度填充函数
function addPaddingZeroes(value, nLength)
{
var sValue = value + ''; //converts to string
if(sValue.length>=nLength)
return sValue;
else
{
for(var nZero = 0; nZero < nLength; nZero++)
sValue = "0" + sValue;
return (sValue).substring(nLength - sValue.length, nLength);
}
}
答案 59 :(得分：0)
一个简单的简短递归函数来实现您的建议：
function padleft (YourNumber, OutputLength){
if (YourNumber.length >= OutputLength) {
return YourNumber;
} else {
return padleft("0" +YourNumber, OutputLength);
}
}
如果您的输入数字长度短于所需的输出数字长度，此函数将在左侧添加0。
答案 60 :(得分：0)
function uint_zerofill(num, width) {
var pad = ''; num += '';
for (var i = num.length; i < width; i++)
pad += '0';
return pad + num;
}
答案 61 :(得分：0)
一点点数学可以给你一个单行函数：
function zeroFill( number, width ) {
return Array(width - parseInt(Math.log(number)/Math.LN10) ).join('0') + number;
}
假设number是一个不大于width的整数。如果调用例程无法做出保证，则该函数需要进行一些检查：
function zeroFill( number, width ) {
var n = width - parseInt(Math.log(number)/Math.LN10);
return (n < 0) ? '' + number : Array(n).join('0') + number;
}
答案 62 :(得分：0)
我的贡献：
我假设您希望总字符串长度包含＆＃39; dot＆＃39;。如果不是，如果数字是浮点数，则重写以添加额外零也很简单。
padZeros = function (num, zeros) {
return (((num < 0) ? "-" : "") + Array(++zeros - String(Math.abs(num)).length).join("0") + Math.abs(num));
}
答案 63 :(得分：0)
这是一个两行函数中的小数组解决方案。它还会检查前导零是否小于数字字符串的长度。
function pad(num, z) {
if (z < (num = num + '').length) return num;
return Array(++z - num.length).join('0') + num;
}
答案 64 :(得分：0)
我偶然发现这篇文章寻找原生解决方案。由于没有内置解决方案，因此我采取了以下措施：
function zerofill(number, width) {
var num = '';
while (width-- > 0) {
num += '0';
}
return num.slice(0, - (number + '').length) + number + '';
}
答案 65 :(得分：0)
如果您使用Lodash。
var n = 1;
alert( _.padLeft(n, 2, 0) ); // 01
n = 10;
alert( _.padLeft(n, 2, 0) ); // 10<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.0/lodash.min.js"></script>
答案 66 :(得分：0)
ES6使这一点变得相当简单：
function pad (num, length, countSign = true) {
num = num.toString()
let negative = num.startsWith('-')
let numLength = negative && !countSign ? num.length - 1 : num.length
if (numLength >= length) {
return num
} else if (negative) {
return '-' + '0'.repeat(length - numLength) + num.substr(1)
} else {
return '0'.repeat(length - numLength) + num
}
}
pad(42, 4) === '0042'
pad(12345, 4) === '12345'
pad(-123, 4) === '-100'
pad(-123, 4, false) === '-0100'
答案 67 :(得分：0)
只是一个FYI，更清晰，更易读的语法恕我直言
"use strict";
String.prototype.pad = function( len, c, left ) {
var s = '',
c = ( c || ' ' ),
len = Math.max( len, 0 ) - this.length,
left = ( left || false );
while( s.length < len ) { s += c };
return ( left ? ( s + this ) : ( this + s ) );
}
Number.prototype.pad = function( len, c, left ) {
return String( this ).pad( len, c, left );
}
Number.prototype.lZpad = function( len ) {
return this.pad( len, '0', true );
}
这也导致结果的视觉和可读性故障少于其他一些解决方案，这些解决方案强制执行＆＃39; 0＆＃39;作为一个角色;回答我的问题，如果我想填充其他字符，或者在另一个方向（右边填充），我该怎么办，同时保持易于打字和清除阅读。非常确定它也是干的最好的例子，实际的前导零填充函数体的代码最少（因为其他相关函数在很大程度上与问题无关）。
该代码可通过github用户的gist进行评论（代码的原始来源） https://gist.github.com/Lewiscowles1986/86ed44f428a376eaa67f
关于控制台＆amp;的说明脚本测试，数字文字似乎需要括号，或变量以调用方法，所以2.pad（...）将导致错误，而（2）.pad（0，＆＃39;＃＆＃39 ;） 将不会。这似乎是所有数字
答案 68 :(得分：0)
这是我写的一个角度提供程序，它使用了@profitehlolz的答案但使用了memoization，因此常用的pad pad-pad字符组合不会不必要地调用数组构建连接：
angular.module('stringUtilities', [])
.service('stringFunctions', [function() {
this.padMemo={ };
this.padLeft=function(inputString,padSize,padCharacter) {
var memoKey=padSize+""+padCharacter;
if(!this.padMemo[memoKey]) {
this.padMemo[memoKey]= new Array(1 + padSize).join(padCharacter);
}
var pad=this.padMemo[memoKey];
return (pad + inputString).slice(-pad.length);
};
}]);
答案 69 :(得分：-1)
我们的测试是假的，因为我有一个错字。
zeroPad = function (num, count) {
return ((num / Math.pow(10, count)) + '').substr(2);
};
Paul是最快的，但我认为.substr比.slice更快，即使它是一个字符更多;）
答案 70 :(得分：-1)
要在数字的末尾填充，请使用num.toFixed
例如：
document.getElementById('el').value = amt.toFixed(2);
这是我发现的最简单的解决方案，并且有效。
答案 71 :(得分：-1)
在这里寻找标准。与保罗和乔纳森有同样的想法...他们的超级可爱，这是一个可怕的可爱版本：
function zeroPad(n,l,i){
return (i=n/Math.pow(10,l))*i>1?''+n:i.toFixed(l).replace('0.','');
}
也有效（我们假设是整数，是吗？）...
> zeroPad(Math.pow(2, 53), 20);
'00009007199254740992'
> zeroPad(-Math.pow(2, 53), 20);
'-00009007199254740992'
> zeroPad(Math.pow(2, 53), 10);
'9007199254740992'
> zeroPad(-Math.pow(2, 53), 10);
'-9007199254740992'
答案 72 :(得分：-2)
我用过
Utilities.formatString("%04d", iThe_TWO_to_FOUR_DIGIT)
最多可提供4个前导0
注意：这需要Google的应用程序脚本实用程序：
https://developers.google.com/apps-script/reference/utilities/utilities#formatstringtemplate-args
答案 73 :(得分：-2)
Mnah ......我还没有看到这个问题的“终极”答案，如果你面临同样的挑战，我必须节省一些时间，因为可悲的是，JavaScript上没有内置函数;但PHP中的 this awesome function 在填充字符串以及包含单个字符或任意字符串的数字方面表现出色，所以经过一段时间的努力，因为JS上没有正确的工具[主要用于zerofillin'数字，通常用于修剪字符串以适应固定长度]和过多的编码工作我决定编写我自己的函数，做同样的[“几乎相同”，阅读详细信息]，梦想PHP的功能，但在舒适的客户端JavaScript。
function str_pad(input,pad_length,pad_string,pad_type){
var input=input.toString();
var output="";
if((input.length>pad_length)&&(pad_type=='STR_PAD_RIGHT')){var output=input.slice(0,pad_length);}
else if((input.length>pad_length)&&(pad_type=='STR_PAD_LEFT')){var output=input.slice(input.length-pad_length,input.length);}
else if((input.length<pad_length)&&(pad_type=='STR_PAD_RIGHT')){
var caracteresNecesarios=pad_length-input.length;
var rellenoEnteros=Math.floor(caracteresNecesarios/pad_string.length);
var rellenoParte=caracteresNecesarios%pad_string.length;
var output=input;
for(var i=0;i<rellenoEnteros;i++){var output=output+pad_string;};
var output=output+pad_string.slice(0,rellenoParte);
}
else if((input.length<pad_length)&&(pad_type=='STR_PAD_LEFT')){
var caracteresNecesarios=pad_length-input.length;
var rellenoEnteros=Math.floor(caracteresNecesarios/pad_string.length);
var rellenoParte=caracteresNecesarios%pad_string.length;
var output="";
for(var i=0;i<rellenoEnteros;i++){var output=output+pad_string;};
var output=output+pad_string.slice(0,rellenoParte);
var output=output+input;
}
else if(input.length==pad_length){var output=input;};
return output;
};
我的功能唯一不做的是STR_PAD_BOTH行为，我可以添加一段时间和更舒适的键盘。
您可以调用该函数并对其进行测试;如果你不介意内部代码在西班牙语中使用一两个单词，那么你会喜欢它...我认为这并不重要。我没有为我的编码添加“水印”注释，因此您可以在工作中无缝使用它，也不会压缩代码以提高可读性。
使用它并像这样测试它并传播代码：
alert("str_pad('murcielago',20,'123','STR_PAD_RIGHT')="+str_pad('murcielago',20,'123','STR_PAD_RIGHT')+'.');
答案 74 :(得分：-3)
function zeroPad(num,digits){ return ((num/Math.pow(10,digits))+'').slice(2) }