我怎么能垫一个值与前导零?

自ECMAScript 2017以来，我们有padStart:

const padded = (.1 + "").padStart(6, "0");
console.log(`-${padded}`);

在ECMAScript 2017之前

与# EYZ0:

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

这是我想出的一个快速函数。如果有人有更简单的方法，欢迎分享!

function zerofill(number, length) {
// Setup
var result = number.toString();
var pad = length - result.length;


while(pad > 0) {
result = '0' + result;
pad--;
}


return result;
}

这是我想到的。

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

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

> 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 = 0(例如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随对数变化)。猜猜哪一个极其比其他两个表现更好?：）

这个方法不是更快，但它相当原生。

zeroPad = function (num, count) {
return [Math.pow(10, count - num.toString().length), num].join('').substr(1);
};

function zeroPad(num,digits){ return ((num/Math.pow(10,digits))+'').slice(2) }

这一种不太本土，但可能是最快的…

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

我们的测试是假的，因为我的有个错别字。

zeroPad = function (num, count) {
return ((num / Math.pow(10, count)) + '').substr(2);
};

Paul的是最快的，但我认为.substr比.slice快，即使它多了一个字符;)

一些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 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"

快速而肮脏的方式:

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

当x = 5 count = 6时y = "000005"

如果填充数事先知道不超过某个值，还有另一种不循环的方法:

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

测试用例:http://jsfiddle.net/jfriend00/N87mZ/

要填充数字的末尾，使用num.toFixed

例如:

  document.getElementById('el').value = amt.toFixed(2);

这是我找到的最简单的解决办法，而且很有效。

还有另一个版本:

function zPad(s,n){
return (new Array(n+1).join('0')+s).substr(-Math.max(n,s.toString().length));
}

简单的方法。您可以为pad添加字符串乘法并将其转换为函数。

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

function pad(toPad, padChar, length){
return (String(toPad).length < length)
? new Array(length - String(toPad).length + 1).join(padChar) + String(toPad)
: toPad;
}

# eyz0 = # eyz1

# eyz0 = # eyz1

# eyz0 = # eyz1

…等。

干杯

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。这里的变化应该会纠正这一点。

我经常使用这个构造来做一些值n的临时填充，已知是一个正数，小数:

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

其中offset是10^^位。

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

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

十六进制的版本稍微详细一些:

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

注1:我也喜欢@profitehlolz的解决方案，它是这个的字符串版本，使用slice()的漂亮的负索引特性。

使用:

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

这可以处理负数和数字比字段宽度长的情况。和浮点。

Mnah……我还没有看到一个“终极”;这个问题的答案，如果你也面临同样的挑战，我必须为你节省一些时间，遗憾的是JavaScript中没有内置的函数。

但是PHP中的这个很棒的函数在填充字符串以及单个字符或任意字符串的数字方面做得很好。经过一段时间的思考，我没有合适的JavaScript工具(主要用于零数字，通常用于调整字符串以适应固定长度)和过多的编码工作，我决定编写自己的函数。

它做同样的("几乎相同";;详细信息请继续阅读)，梦想的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;
};

alert("str_pad('murcielago', 20, '123', 'STR_PAD_RIGHT')=" + str_pad('murcielago', 20, '123', 'STR_PAD_RIGHT') + '.');

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

也许我太天真了，但我认为这在一行简单而有效的代码中就可以实现(对于正数):

padded = (value + Math.pow(10, total_length) + "").slice(1)

只要你保持你的长度根据你的值集(在任何零填充)，这应该是可行的。

步骤如下:

1. 10的幂与正确的0数相加[69+1000 = 1069]
2. 转换为字符串+""[1069 =比;“1069“)
3. 切片第一个1，这是第一次乘法的结果["1069"=比;“069“)

对于自然列表(文件，dirs…)是非常有用的。

我的解决方案

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

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

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

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

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

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

编辑2:注意，从ES2017开始，你可以使用String.prototype.padStart:

number.toString().padStart(padding, "0")

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

功能:

/** 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”循环。使用regex可能会为这样一个微不足道的8位数填充花费更多的周期。

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

可变长度填充功能:

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

数学的力量!

x = integer to pad
Y =要填充的0个数

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

一个简单的用例(填充毫秒从不> 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);
}

在测试了这个问题答案中15个不同的函数/方法之后，我现在知道哪个是最好的(最通用和最快的)。

我从这个问题的答案中选取了15个函数/方法，并制作了一个脚本来测量执行100个pad所花费的时间。每个衬垫将填充数字9与2000零。这看起来有点过分，确实如此，但它让你对函数的缩放有了一个很好的了解。

我使用的代码可以在这里找到: # EYZ0 < / p >

您可以自行修改和测试代码。

为了得到最通用的方法，你必须使用循环。这是因为在数量非常大的情况下，其他人可能会失败，而这将会成功。

那么，使用哪个循环呢?这将是一个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'

我使用这个片段来获得一个五位数的表示:

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

我在这里寻找一个标准，和保罗和约拿单有同样的想法……他们的照片超级可爱，但这里有一个非常可爱的版本:

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'

一个简单的递归函数来实现您的建议:

function padleft (YourNumber, OutputLength){
if (YourNumber.length >= OutputLength) {
return YourNumber;
} else {
return padleft("0" +YourNumber, OutputLength);
}
}

• YourNumber是输入数字。
• OutputLength是首选的输出数字长度(填充为0)。

如果您的输入数字长度小于所需的输出数字长度，此函数将在左侧添加0。

我不敢相信这里有这么多复杂的答案……就用这个吧:

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

let n = 1
var zerofilled = ('0000'+n).slice(-4);
console.log(zerofilled)

function uint_zerofill(num, width) {
var pad = ''; num += '';
for (var i = num.length; i < width; i++)
pad += '0';
return pad + num;
}

简单的数学运算就可以得到一个单行函数:

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

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

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'

我的贡献:

我假设你想要的总字符串长度包括'点'。如果不是，如果数字是浮点数，重写为增加一个额外的0仍然很简单。

padZeros = function (num, zeros) {
return (((num < 0) ? "-" : "") + Array(++zeros - String(Math.abs(num)).length).join("0") + Math.abs(num));
}

不要白费力气;使用# EYZ0:

jsFiddle

var numToPad = '5';


alert(_.str.pad(numToPad, 6, '0')); // Yields: '000005'

我对这个话题的一点贡献(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"

我知道，这是一个很脏的函数，但它很快，即使是负数也能工作;)

function zFill(n,l){
return
(l > n.toString().length) ?
( (Array(l).join('0') + n).slice(-l) ) : n;
}

不幸的是，对于这个问题，有很多不必要的复杂建议，通常涉及编写自己的函数来进行数学运算或字符串操作或调用第三方实用程序。但是，在基本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以使用逗号分隔千位。

注意，使用toLocaleString()和locales和options参数在ECMA-402中单独标准化，而不是在ECMAScript中。截至今天，一些浏览器只实现基本支持，即toLocaleString()可能会忽略任何参数。

完整示例

< em >简单< / em >，你会发现最直接的解决方案。

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

这里有一个两行函数中的数组解。它还检查前导零是否小于数字字符串的长度。

function pad(num, z) {
if (z < (num = num + '').length) return num;
return Array(++z - num.length).join('0') + num;
}

我只是偶然发现这篇文章寻找一个本地的解决方案。由于没有内置的解决方案，以下是我的看法:

function zerofill(number, width) {
var num = '';
while (width-- > 0) {
num += '0';
}


return num.slice(0, - (number + '').length) + number + '';
}

只是为了好玩，这里是我版本的pad函数:

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

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

这就是ES6的解决方案。

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

如果你使用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>

并不是说这个问题需要更多的答案，但我认为我应该添加这个简单的lodash版本。

# EYZ0

sprintf.js是一个完整的开源JavaScript sprintf实现 对于浏览器和node.js。

.js

它的原型很简单:

string sprintf(string format , [mixed arg1 [, mixed arg2 [ ,...]]])

我想从Alexandru Mărășteanu中推荐# EYZ0模块，整个解决方案看起来就像:

var sprintf = require('sprintf');
var zeroFilled = sprintf('%06d', 5);


console.log(zeroFilled); // 000005

我在6年后回答这个问题，但似乎这个 问题变成了“Javascript零前导”参考考虑 这是很高的观看数和回答数

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'

仅供参考，更清晰，更可读的语法恕我直言

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

这也导致结果的视觉和可读性问题比其他一些解决方案更少，这些解决方案强制'0'作为字符;回答我的问题，我该怎么做，如果我想垫其他字符，或在其他方向(右填充)，同时保持容易打字，并清楚地阅读。我敢肯定，这也是DRY的最佳示例，实际的前导零填充函数体的代码最少(因为其他相关函数在很大程度上与这个问题无关)。

该代码可通过gist从这个github用户(代码的原始来源)评论 # EYZ0 < / p >

关于控制台的注意事项脚本测试，数值文字似乎需要圆括号，或一个变量来调用方法，因此2.pad(…)将导致错误，而(2).pad(0，'#')不会。这似乎对所有数字都是一样的

这是我写的一个angular提供程序，它利用了@profitehlolz的答案，但使用了内存，这样常用的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);
};
}]);

最新的方法要简单得多:

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

# EYZ0

exports.pad = (num, length) => "0".repeat(length - num.toString().length) + num;

现代浏览器现在支持padStart，你现在可以简单地做:

string.padStart(maxLength, "0");

例子:

string = "14";
maxLength = 5; // maxLength is the max string length, not max # of fills
res = string.padStart(maxLength, "0");
console.log(res); // prints "00014"


number = 14;
maxLength = 5; // maxLength is the max string length, not max # of fills
res = number.toString().padStart(maxLength, "0");
console.log(res); // prints "00014"

如果npm在您的环境中可用，则可以使用一些现成的包:www.npmjs.com/browse/keyword/zeropad。

我喜欢补零。

安装

$ npm install zero-fill

使用

var zeroFill = require('zero-fill')


zeroFill(4, 1)      // '0001'
zeroFill(4, 1, '#') // '###1' custom padding
zeroFill(4)(1)      // '0001' partials

使用递归:

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

一个简单的函数来做:

function padStr(number, numDigits){
return
(number < 0 ? '-':'')
+ ((new Array(numDigits + 1).join("0"))
+ Math.abs(number)).slice(-numDigits);
}

我正在使用这个简单的方法

var input = 1000; //input any number
var len = input.toString().length;
for (i = 1; i < input; i++) {
console.log("MyNumber_" + ('000000000000000' + i).slice(-len));
}

只是另一种解决方案，但我觉得更容易辨认。

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


return text;
}

如果性能真的很关键(遍历数百万条记录)，则可以预先生成填充字符串数组，从而避免每次调用都这样做。

时间复杂度:O (1).
. 0 空间复杂度:O (1).

const zeroPads = Array.from({ length: 10 }, (_, v) => '0'.repeat(v))


function zeroPad(num, len) {
const numStr = String(num)
return (zeroPads[len - numStr.length] + numStr)
}

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

更多信息:

• # EYZ0
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

我写了一些东西在ECMAScript 6 (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;
}());

我觉得我的方法有点不同。我需要填充一个数字的原因是要在<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"

在所有现代浏览器中都可以使用

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

我没有看到任何人指出，当你使用String.prototype.substr ()和一个负数时，它从右边开始计数。

OP问题的一个线性解决方案，即数字5的6位零表示，是:

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

Generalizing we'll get:

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

我使用

Utilities.formatString("%04d", iThe_TWO_to_FOUR_DIGIT)

哪个前导有4个0

注:这需要谷歌的应用程序脚本实用程序:

https://developers.google.com/apps-script/reference/utilities/utilities#formatstringtemplate-args

我有两个解。

第一个是最基本的用0来求一个数字如果你知道这就是你想快速做的。

第二个也会填充负数——就像“clever"答案似乎是最好的。

是:

// 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 minimum 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'));

一个简单优雅的解，n是数字，l是长度。

# EYZ0

这将保持长度，如果它是超过所需的，而不是改变数字。

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

我在这个表单中没有看到任何答案所以这里是我的正则表达式和字符串操作

(也适用于负和小数数字)

代码:

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'

以下提供了一个快速的解决方案:

function numberPadLeft(num , max, padder = "0"){
return "" == (num += "") ? "" :
( dif = max - num.length, dif > 0 ?
padder.repeat(dif < 0 ? 0 : dif) + num :
num )
}

我在写一个数字基础转换器时，想到了一个荒谬的单行程序。

// 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

或者，以一种不那么容易暴露我把灵魂出卖给黑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个字符长)，这是很方便的。

我不知道它的性能有多好，但是，嘿，至少它已经被缩小了!

这里有一个我认为很酷的小技巧:

(2/10000).toString().split(".")[1]
"0002"
(52/10000).toString().split(".")[1]
"0052"

使用ES6+ JavaScript:

你可以对数字进行“零填零”。使用如下函数:

/**
* @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"

ES2017 +:

/**
* @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"

post，如果这是你正在寻找的，将剩余的时间以毫秒为单位转换为字符串，如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;
}

一个愚蠢的递归方法是:

function paddingZeros(text, limit) {
if (text.length < limit) {
return paddingZeros("0" + text, limit);
} else {
return text;
}
}

这里的限制是你想要的字符串大小。

例:# EYZ0

我发现这个问题很有趣，我贡献了自己的一份力量

function zeroLeftComplete(value, totalCharters = 3) {
const valueString = value.toString() || '0'
const zeroLength = valueString.length - totalCharters
if (Math.sign(parseInt(zeroLength)) === -1) {
const zeroMissing = Array.from({ length: Math.abs(zeroLength) }, () => '0').join('')
return `${zeroMissing}${valueString}`
} else return valueString


};
console.log(zeroLeftComplete(0));
console.log(zeroLeftComplete(1));
console.log(zeroLeftComplete(50));
console.log(zeroLeftComplete(50561,3));