关于javascript：如何使用前导零填充值？


How can I pad a value with leading zeros?

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

注：在"零填充"一词的数据库意义上，我指的是它(其中数字5的6位零填充表示为"000005")。

相关讨论

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

1
2
3
var pad ="000000";
var n = '5';
var result = (pad+n).slice(-pad.length);

作为一个函数，

1
2
3
4
5
6
7
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
var zerofilled = ('0000'+n).slice(-4);
相关讨论

Note to readers!

As commenters have pointed out, this solution is"clever", and as
clever solutions often are, it's memory intensive and relatively
slow. If performance is a concern for you, don't use this solution!

Potentially outdated: ECMAScript 2017 includes String.prototype.padStart and Number.prototype.toLocaleString is there since ECMAScript 3.1. Example:

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

...will output"-0000.10".

1
2
3
// or
const padded = (.1+"").padStart(6,"0");
`-${padded}`

...will output"-0000.1".

你只需要一个简单的函数

1
2
3
4
5
6
7
8
9
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的扩展一样。

相关讨论

我最近真的不得不想出这样的办法。我想必须有一种不用循环的方法。

这就是我想到的。

1
2
3
4
5
6
7
8
9
10
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;
}

然后使用它提供一个数字到零的填充：

1
2
> zeroPad(50,4);
"0050"

如果数字大于填充，则数字将超出填充范围：

1
2
> zeroPad(51234, 3);
"51234"

小数也可以！

1
2
> zeroPad(51.1234, 4);
"0051.1234"

如果您不介意污染全局命名空间，可以直接将其添加到数字：

1
2
3
4
5
6
7
8
9
10
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;
}

如果你想让小数占据填充空间：

1
2
3
4
5
6
7
8
9
10
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))，则此函数失败。

1
2
3
4
5
6
7
8
9
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个字符的数字。

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

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

编辑：如果要使其更通用，可以执行以下操作：

1
("0".repeat(padding) + number).slice(-padding)
相关讨论

不幸的是，对于这个问题有很多不必要的复杂建议，通常包括编写自己的函数来进行数学或字符串操作，或者调用第三方实用程序。但是，在基本JavaScript库中，只有一行代码可以实现这一点。将这一行代码包装在函数中可能是值得的，这样可以避免指定您不希望更改的参数(如本地名称或样式)。

1
2
3
4
5
6
7
8
var amount = 5;

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

这将产生文本值"005"。您还可以使用数字的toLocaleString函数将0填充到小数点的右侧。

1
2
3
4
5
6
7
8
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()可能忽略任何参数。

完整的例子

相关讨论

如果预先知道填充数字不超过某个值，则有另一种方法可以在不使用循环的情况下执行此操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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/

相关讨论

在建议的(第3阶段)ES2017方法.padStart()中，您现在可以简单地做(在实施/支持时)：

1
string.padStart(maxLength,"0"); //max length is the max string length, not max # of fills
相关讨论

快速而肮脏的方式：

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

如果x=5且count=6，则y="000005"

相关讨论

这是我为完成这项工作而设计的一个快速功能。如果有人有更简单的方法，请随意分享！

1
2
3
4
5
6
7
8
9
10
11
12
function zerofill(number, length) {
    // Setup
    var result = number.toString();
    var pad = length - result.length;

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

    return result;
}
相关讨论

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

功能：

1
2
3
4
5
6
7
8
/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

原型：

1
2
3
4
5
6
7
Number.prototype.zeroPad=function(digits){
    var num=this+"";
    while(num.length < digits){
        num='0'+num;
    }
    return(num);
};

非常简单，我看不出这是怎么简单的。出于某种原因，我在这里已经出现过很多次了，所以人们只是尽量避免以任何代价出现"for"和"while"循环。对于这样一个8位数的填充，使用regex可能会花费更多的周期。

在这里参加聚会较晚，但我经常用这个结构来做一些值的特殊填充，比如说cx1〔6〕，我们知道它是一个正的小数：

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

其中，offset为10 ^ ^位。

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

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

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

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

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

相关讨论

我用这个剪子得到一个5位数的表示

1
(value+100000).toString().slice(-5) //"00123" with value=123
相关讨论

数学的力量！

x=要填充的整数Y=要填充的零个数

1
2
3
4
5
6
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()时，它从右边开始计数。

运算问题的一个线性解决方案，即数字5的6位零填充表示，是：

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

概括起来，我们会得到：

1
2
3
4
5
6
7
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));

相关讨论

这是ES6解决方案。

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

相关讨论

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

1
2
3
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
}

所以

1
2
3
4
5
6
7
8
9
10
           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'

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

杰西德

1
2
3
var numToPad = '5';

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

经过一段漫长的测试，在这个问题中找到了15种不同的功能/方法，我现在知道哪一种是最好的(最通用和最快的)。

我从这个问题的答案中选择了15个函数/方法，并编写了一个脚本来测量执行100个PAD所花费的时间。每个pad都会用20000填充数字9。这可能看起来太过分了，确实如此，但它为您提供了一个关于函数缩放的好主意。

我使用的代码可以在这里找到：https://gist.github.com/nextotnothing/6325915

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

为了获得最通用的方法，必须使用循环。这是因为有大量的人可能会失败，而这将是成功的。

那么，使用哪个循环呢？好吧，那将是一个while循环。一个for循环仍然很快，但是一个while循环只是稍微快一点(几毫秒)并且更干净。

像Wilco、Aleksandar Toplek或Vitim.us这样的答案将完美地完成这项工作。

就我个人而言，我尝试了一种不同的方法。我尝试使用递归函数填充字符串/数字。它的效果比加入数组的方法要好，但仍然不如for循环工作得快。

我的功能是：

1
2
3
4
function pad(str, max, padder) {
  padder = typeof padder ==="undefined" ?"0" : padder;
  return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}

可以使用my函数来设置填充变量，也可以不设置填充变量。像这样：

1
2
3
pad(1, 3); // Returns '001'
// - Or -
pad(1, 3,"x"); // Returns 'xx1'

就我个人而言，在测试之后，我会使用一个while循环的方法，比如Aleksandar Toplek或Vitim.us。但是，我会稍微修改它，以便您能够设置填充字符串。

因此，我将使用以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
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'

您也可以将其用作原型函数，方法是使用以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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'
相关讨论

ECMAScript 2017年：使用padstart或padsend

1
2
3
'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/en-us/docs/web/javascript/reference/global_objects/string/padstart
相关讨论

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

1
numberStr.padStart(numberLength,"0");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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

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

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

相关讨论

最新的方法要简单得多：

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

output:"02"

相关讨论

只是另一个解决方案，但我觉得它更清晰。

1
2
3
4
5
6
7
8
function zeroFill(text, size)
{
  while (text.length < size){
    text ="0" + text;
  }
 
  return text;
}

相关讨论

我的解决方案

1
2
3
4
5
6
7
Number.prototype.PadLeft = function (length, digit) {
    var str = '' + this;
    while (str.length < length) {
        str = (digit || '0') + str;
    }
    return str;
};

用法

1
2
3
4
5
var a = 567.25;
a.PadLeft(10); // 0000567.25

var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25

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

1
2
3
4
5
6
7
zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};
相关讨论

为什么不使用递归？

1
2
3
4
function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}
相关讨论

1
2
3
4
5
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。

……等

干杯

相关讨论

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

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

它也不会截断超过填充长度的数字

如果性能真的很关键(循环超过数百万条记录)，可以预先生成一个填充字符串数组，避免每次调用都这样做。

时间复杂度：O(1)。空间复杂性：O(1)。

1
2
3
4
5
6
const zeroPads = Array.from({ length: 10 }, (_, v) => '0'.repeat(v))

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

相关讨论

一些MonkeyPatching也可以工作

1
2
3
4
5
6
7
8
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"
相关讨论

最简单、最直接的解决方案。

1
2
3
4
5
6
7
function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}

这种方法速度不快，但相当原始。

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

一个简单的用例(填充毫秒永远不会超过999)您可以为自己调整零的数量，或者根据需要使用更通用的方法。

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * @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);
}

也许我太天真了，但我认为这只适用于一行简单有效的代码(对于正数)：

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

只要根据一组值(如任何零填充中的值)保持长度正常，这就应该有效。

步骤如下：

  • 将10的幂加上正确的0's[69+1000=1069]
  • 用+"[1069=>"1069"]转换为字符串
  • 对第一个1进行切片，这是第一次乘法的结果["1069"=>"069"]

    • 对于自然列表(文件、目录…)非常有用。

    相关讨论

    好吧，好吧，我真不敢相信我在为这个问题提交另一个答案，但我认为我的方法有点不同。我需要填充一个数字的原因是将它显示在元素(屏幕日志的一部分)中，所以它最终将成为一个字符串。我编写了一个简单的函数，将字符串值覆盖在掩码字符串上，而不是进行任何数学运算：

    1
    2
    3
    function overlayr(m, s) {
      return m.length > s.length ? m.substr(0, m.length - s.length) + s : s;
    }

    这样做的好处是，我可以将它用于各种字符串对齐任务。要调用它，只需将掩码和数字作为字符串传递：

    1
    2
    > overlayr('00000', (5).toString())
    <"00005"

    作为额外的奖励，它正确处理溢出：

    1
    2
    > overlayr('00000', (555555).toString())
    <"555555"

    当然，它不限于0填充：

    1
    2
    > overlayr('*****', (55).toString())
    <"***55"
    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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;
    }
    相关讨论

    我对这个主题的小小贡献(https://gist.github.com/lucasferreira/a881606894dde5568029)：

    1
    2
    3
    4
    5
    /* 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;
    };

    用途：

    1
    2
    3
    fz(9) & fz(9, 2) =="09"
    fz(-3, 2) =="-03"
    fz(101, 7) =="0000101"

    我知道，这是一个非常脏的函数，但它速度很快，甚至可以与负数一起使用；)

    1
    2
    3
    4
    5
    function zFill(n,l){
        return
          (l > n.toString().length) ?
            ( (Array(l).join('0') + n).slice(-l) ) : n;
    }
    1
    2
    3
    4
    5
    6
    7
    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
    }

    对彼得的法典作了细微的修改。如果输入为(1.2，3)，则返回的值应为01.2，但返回的值为1.2。这里的更改应该可以纠正这个问题。

    只是想发表评论(但我没有足够的分数)，让最高投票数的答案以负数和小数的形式失败。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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"

    sprintf.js is a complete open source JavaScript sprintf implementation
    for the browser and node.js.

    Its prototype is simple:

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

    我想推荐Alexandru M公司的sprintf模块。R？？整个解决方案中的Teanu看起来很简单：

    1
    2
    3
    4
    var sprintf = require('sprintf');
    var zeroFilled = sprintf('%06d', 5);

    console.log(zeroFilled); // 000005

    Note: I'm answering this question 6 years later but it seems that this
    question becomes a"javascript zero leading" reference considering
    it's high number of views and answers.

    还有另一个版本：

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

    我用这个简单的方法

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

    甚至在晚会的晚些时候。

    1
    2
    3
    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)
    }

    它处理负数和数字长于字段宽度的情况。和浮点。

    ES6使这变得相当简单：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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'

    我有两个解决方案。第一个问题是真正的基本问题，如果你知道这就是你想要快速完成的全部工作，那么就用零来破坏一个数字。

    第二种方法也会加上负数，这和"聪明"的解决方案一样，似乎有最好的答案分数。

    下面是：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // 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'));

    我用ECMAScript6(打字稿)写了一些东西，也许有人可以使用它：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    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)蒸腾过程如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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;
    }());

    一个简单的函数：

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

    如果您的环境中有npm可用，可以使用一些现成的软件包：www.npmjs.com/browse/keyword/zeropad。

    我喜欢零填充。

    安装

    1
    $ npm install zero-fill

    用法

    1
    2
    3
    4
    5
    var zeroFill = require('zero-fill')

    zeroFill(4, 1)      // '0001'
    zeroFill(4, 1, '#') // '###1' custom padding
    zeroFill(4)(1)      // '0001' partials
    1
    exports.pad = (num, length) =>"0".repeat(length - num.toString().length) + num;

    这是我编写的一个角度提供者，它使用@profitehloz的答案，但使用了memoization，因此常用的pad-length pad字符组合不会不必要地调用数组构建连接：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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);
           };
    }]);
    1
    2
    3
    4
    5
    6
    function uint_zerofill(num, width) {
        var pad = ''; num += '';
        for (var i = num.length; i < width; i++)
            pad += '0';
        return pad + num;
    }

    只是一个提示，更清晰，更可读的语法imho

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    "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"强制为字符；回答我的问题如果我想填充其他字符或在其他方向(右填充)，我该怎么做，同时保持易于键入和清除读。很肯定这也是最枯燥的例子，实际前导零填充函数体的代码最少(因为其他依赖函数在很大程度上与问题无关)。

    此代码可通过gist从该github用户(代码的原始源)获得以供评论。https://gist.github.com/lewiscowles1986/86ed44f428a376eaa67f

    在控制台和脚本测试中，数字文本似乎需要括号或变量来调用方法，因此2.pad(…)将导致错误，而(2).pad(0，)将不会。所有的数字都是一样的

    1
    2
    3
    4
    5
    function numPadding (padding,i) {
        return padding.substr(0, padding.length - (Math.floor(i).toString().length)) + Math.floor(i );
    }

    numPadding("000000000",234); ->"000000234"

    或

    1
    2
    3
    4
    5
    6
    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";

    如果你用罗达什。

    1
    2
    3
    4
    5
    6
    7
    var n = 1;

    alert( _.padLeft(n, 2, 0) ); // 01

    n = 10;

    alert( _.padLeft(n, 2, 0) ); // 10
    1
    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.0/lodash.min.js">

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

    1
    2
    3
    4
    5
    6
    7
    8
    function zerofill(number, width) {
        var num = '';
        while (width-- > 0) {
            num += '0';
        }

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

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

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

    我的贡献：

    我假设您希望字符串的总长度包括"点"。如果不是这样的话，如果数字是浮点数的话，重写它来加一个额外的零还是很简单的。

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

    一个简单而优雅的解决方案，其中n是数字，l是长度。

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

    如果长度超出了期望值，这将保持长度，而不会改变数字。

    1
    2
    3
    4
    5
    6
    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;}

    一点数学可以给你一个单行函数：

    1
    2
    3
    function zeroFill( number, width ) {
      return Array(width - parseInt(Math.log(number)/Math.LN10) ).join('0') + number;
    }

    假设number是一个不比width宽的整数。如果调用例程不能保证，函数将需要进行一些检查：

    1
    2
    3
    4
    function zeroFill( number, width ) {
        var n = width - parseInt(Math.log(number)/Math.LN10);
        return (n < 0) ? '' + number : Array(n).join('0') + number;
    }

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

    1
    2
    3
    4
    5
    6
    7
    function padleft (YourNumber, OutputLength){
        if (YourNumber.length >= OutputLength) {
            return YourNumber;
        } else {
            return padleft("0" +YourNumber, OutputLength);
        }
    }
    • 您的号码是输入号码。
    • OutputLength是首选的输出数字长度(左侧填充0)。

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

    可变长度填充函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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);    
        }
    }

    我们的测试是伪造的，因为我的有错别字。

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

    保罗是最快的，但我认为。SUBSTR比.slice快，即使它多了一个字符；)

    是来找标准的。和保罗和乔纳森有同样的想法…他们的超级可爱，这里有一个可怕的可爱版本：

    1
    2
    3
    function zeroPad(n,l,i){
        return (i=n/Math.pow(10,l))*i>1?''+n:i.toFixed(l).replace('0.','');
    }

    也可以(我们假设整数，是吗？)…

    1
    2
    3
    4
    5
    6
    7
    8
    > 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'

    要在数字末尾填充，请使用num.tofixed

    例如：

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

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

    Mnah…我没有看到这个问题的"终极"答案，如果你面临同样的挑战，我必须为你节省一些时间，说很遗憾，在javascript上没有内置函数；但是在PHP中有一个很棒的函数，它在填充字符串以及带有单个字符或任意字符串的数字方面做得很好，所以在SOM之后在JS上没有合适的工具(主要是针对零填充的数字，通常是为了调整字符串以适应固定长度)和过度的编码工作时，我决定编写自己的函数，它与梦想的PHP函数具有相同的功能[几乎相同]，但使用舒适的客户端JavaScript。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    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行为，我可以用一段时间和一个更舒适的键盘来添加它。您可以调用该函数并测试它；如果您不介意内部代码使用西班牙语中的一个或两个单词，您一定会喜欢它的。我想没什么大不了的。我没有为"水印"添加注释，因此您可以在工作中无缝地使用它，也没有为增强可读性而压缩代码。使用它并像这样测试，然后传播代码：

    1
    alert("str_pad('murcielago',20,'123','STR_PAD_RIGHT')="+str_pad('murcielago',20,'123','STR_PAD_RIGHT')+'.');
    相关讨论

    我用过

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

    最多放弃4个前导0

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

    https://developers.google.com/apps script/reference/utilities/utilities formatstringtemplate参数

    相关讨论

    1
    function zeroPad(num,digits){ return ((num/Math.pow(10,digits))+'').slice(2) }
    相关讨论