如何用前导零填充值？

在JavaScript中建议零填充值的推荐方法是什么？我想我可以构建一个自定义函数以将零填充到类型转换值上，但是我想知道是否还有更直接的方法可以做到这一点？

注意： “零填充”是指该词在数据库中的含义（其中数字5的6位零填充表示为“ 000005”）。

敬请读者注意！

正如评论者所指出的那样，此解决方案是“聪明的”，而且通常就像聪明的解决方案一样，它占用大量内存并且相对较慢。如果您担心性能，请不要使用此解决方案！

可能已过时：自ECMAScript 3.1起，ECMAScript2017包含 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
}

如果您想保留名称空间或其他内容，可以将其烘烤到库中。就像jQuery的extend一样。

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

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

我不敢相信这里有所有复杂的答案...只需使用：

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提出了对数变化形式，表现似乎更好。

警告：如果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)

编辑2：请注意，自ES2017起，您可以使用String.prototype.padStart：

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

现代浏览器现在支持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"

不幸的是，对于这个问题有很多不必要的复杂建议，通常涉及编写您自己的函数来进行数学或字符串操作或调用第三方实用程序。但是，在基本的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()with locales和optionsarguments 是在ECMA-402中而不是在ECMAScript中单独标准化的。截至今天，某些浏览器仅实现基本支持，即toLocaleString()可以忽略任何参数。

完整的例子

如果事先知道填充数不超过某个值，那么还有另一种方法可以不循环：

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/

快速而肮脏的方式：

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

对于x = 5和count = 6，您将拥有y =“ 000005”

这是我想出的一项快速功能来完成这项工作。如果有人有更简单的方法，请随时分享！

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

十六进制版本稍微冗长一些：

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

注意1：我也喜欢@profitehlolz的解决方案，它是使用slice（）的漂亮的负索引功能的字符串版本。

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

功能：

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

非常简单，我看不出有什么方法可以如此简单。由于某种原因，我在SO上看过很多次了，人们只是试图不惜一切代价避免“ for”和“ while”循环。对于这种琐碎的8位填充，使用正则表达式可能会花费更多的周期。

我使用此摘要获取5位数字的表示形式

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

ECMAScript 2017：使用padStart或padEnd

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

更多信息：

• https://github.com/tc39/proposal-string-pad-start-end
• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

数学的力量！

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

经过很长很长一段时间的测试，在这个问题答案中发现了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;
}

无论是否设置了padding变量，都可以使用我的函数。像这样：

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'

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

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'

不要重新发明轮子，请使用下划线字符串：

jsFiddle

var numToPad = '5';

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

这是ES6解决方案。

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

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

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/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

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

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

执行此操作的最新方法要简单得多：

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

output: "02"

只是另一种解决方案，但我认为它更清晰。

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

这不是本地语言，但可能是最快的...

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

我的解决方案

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

为什么不使用递归？

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

一些猴子补丁也有效

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

...等等。

干杯

在最简单，最直接的解决方案，你会发现。

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