Javascript 如何用前导零填充值？

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

注意：我所说的“零填充”是指数据库意义上的单词（其中数字5的6位零填充表示为“000005”）

读者注意

正如评论者所指出的，这个解决方案是“聪明的”，而且 聪明的解决方案通常是内存密集型的，而且相对来说 慢点。如果您担心性能问题，请不要使用此解决方案

可能过时的：ECMAScript 2017包括并自ECMAScript 3.1以来一直存在。例如：

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

…将输出“-0000.10”

…将输出“-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
}

---

如果您想保留名称空间或其他什么，可以将其烘焙到库中。就像。

这里有一个我想出的快速函数来完成这项工作。如果有人有更简单的方法，欢迎分享

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

如果数字大于填充，则数字将扩展到填充之外：

> zeroPad(51234, 3);
"51234"

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

小数也可以

> 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=函数（numZeros）{
var n=Math.abs（本）；
var zeros=Math.max（0，numZeros-Math.floor（n.toString（）.length）；
var zeroString=Math.pow（10，零）.toString（）.substr（1）；
如果（该值小于0）{
zeroString='-'+zeroString；
}
返回零字符串+n；
}

如果您希望小数占据填充空间：

> zeroPad(51234, 3);
"51234"

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

Number.prototype.leftZeroPad=函数（numZeros）{
var n=Math.abs（本）；
var zeros=Math.max（0，numZeros-n.toString（）.length）；
var zeroString=Math.pow（10，零）.toString（）.substr（1）；
如果（该值小于0）{
zeroString='-'+zeroString；
}
返回零字符串+n；
}

干杯

---

---

提出了一个似乎表现更好的对数变化

警告：如果num等于零，此功能将失败（例如zeropad（0，2））

function zeroPad（num，numZeros）{
var an=Math.abs（num）；
var digitCount=1+Math.floor（Math.log（an）/Math.LN10）；
如果（数字计数>=numZeros）{
返回num；
}
var zeroString=Math.pow（10，numZeros-digitCount）.toString（）.substr（1）；
返回num<0？'-'+zeroString+an:zeroString+an；
}

---

---

说到表演，（）。猜猜哪一个比另外两个表现更好？：）

这一个不是本地的，但可能是最快的

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

---

一些修补程序也能起作用

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"

---

快速和肮脏的方式：

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

---

这里的测试用例：

简单方法。您可以为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

功能板（toPad、padChar、长度）{
返回（字符串（toPad）.长度<长度）
新数组（长度-字符串（toPad）.长度+1）.连接（padChar）+字符串（toPad）
：toPad；
}

pad（5,0,6）

=

000005

pad（'10'，0，2）

=

10//如果没有必要，不要pad

pad（'S'，'O'，2）

=

SO

……等等

---

这里的聚会迟到了，干杯，但是我经常用这个结构来做一些值的临时填充，称为正小数：

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

其中，

偏移量

为10^^^位

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

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

这个的十六进制版本稍微详细一些：

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

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

我的解决方案

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

---

下面是我用来填充一个最多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;
}

/**在左边用0填充一个数字*/
功能归零板（数字、数字）{
var num=数字+“”；
while（数值长度<位数）{
num='0'+num；
}
返回num；
}

原型：

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

Number.prototype.zeroPad=函数（数字）{
var num=this+“”；
while（数值长度<位数）{
num='0'+num；
}
返回（num）；
};

非常直截了当，我看不出有什么方法能让这更简单。出于某种原因，我在这里已经多次出现，所以，人们总是不惜一切代价避免“For”和“while”循环。使用正则表达式可能会为这样一个微不足道的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种不同的功能/方法，我现在知道哪种是最好的（最通用和最快的）

我从这个问题的答案中提取了15个函数/方法，并编写了一个脚本来测量执行100个pad所需的时间。每个焊盘将用

2000

零填充数字

9

。这可能看起来有些过分，的确如此，但它让您对函数的缩放有了一个很好的了解

我使用的代码可以在这里找到：

您可以自己修改和测试代码

为了获得最通用的方法，必须使用循环。这是b

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

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

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'

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

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

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'

var numToPad = '5';

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

var amount = 5;

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

var amount = 5;

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

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

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

string.padStart(maxLength, "0");

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

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

numberStr.padStart(numberLength, "0");