有点晚了，但我还是想分享一下。我发现向Object添加一个原型扩展很有用。这样我就可以填充数字和字符串，向左或向右。我有一个模块与类似的实用程序，我包括在我的脚本。

// include the module in your script, there is no need to export
var jsAddOns = require('<path to module>/jsAddOns');

~~~~~~~~~~~~ jsAddOns.js ~~~~~~~~~~~~

/* 
 * method prototype for any Object to pad it's toString()
 * representation with additional characters to the specified length
 *
 * @param padToLength required int
 *     entire length of padded string (original + padding)
 * @param padChar optional char
 *     character to use for padding, default is white space
 * @param padLeft optional boolean
 *     if true padding added to left
 *     if omitted or false, padding added to right
 *
 * @return padded string or
 *     original string if length is >= padToLength
 */
Object.prototype.pad = function(padToLength, padChar, padLeft) {    

    // get the string value
    s = this.toString()

    // default padToLength to 0
    // if omitted, original string is returned
    padToLength = padToLength || 0;

    // default padChar to empty space
    padChar = padChar || ' ';


    // ignore padding if string too long
    if (s.length >= padToLength) {
        return s;
    }

    // create the pad of appropriate length
    var pad = Array(padToLength - s.length).join(padChar);

    // add pad to right or left side
    if (padLeft) {
        return pad  + s;        
    } else {
        return s + pad;
    }
};

一种更快的方法

If you are doing this repeatedly, for example to pad values in an array, and performance is a factor, the following approach can give you nearly a 100x advantage in speed (jsPerf) over other solution that are currently discussed on the inter webs. The basic idea is that you are providing the pad function with a fully padded empty string to use as a buffer. The pad function just appends to string to be added to this pre-padded string (one string concat) and then slices or trims the result to the desired length.

function pad(pad, str, padLeft) {
  if (typeof str === 'undefined') 
    return pad;
  if (padLeft) {
    return (pad + str).slice(-pad.length);
  } else {
    return (str + pad).substring(0, pad.length);
  }
}

例如，要将一个数字零填充为10位，

pad('0000000000',123,true);

要用空格填充字符串，使整个字符串为255个字符，

var padding = Array(256).join(' '), // make a string of 255 spaces
pad(padding,123,true);

性能测试

请在这里查看jsPerf测试。

这比ES6字符串快。重复2倍，正如这里修改后的JsPerf所示

请注意，jsPerf不再联机

请注意，我们最初用来对各种方法进行基准测试的jsPerf站点已不再在线。不幸的是，这意味着我们无法得到那些测试结果。虽然悲伤，但事实如此。

使用默认值的填充

我注意到我主要需要padLeft进行时间转换/数字填充。

所以我写了这个函数:

function padL(a, b, c) { // string/number, length=2, char=0
  return (new Array(b || 2).join(c || 0) + a).slice(-b)
}

这个简单的函数支持数字或字符串作为输入。

默认的pad是两个字符。

默认字符为0。

所以我可以简单地写:

padL(1);
// 01

如果我添加第二个参数(pad width):

padL(1, 3);
// 001

第三个参数(填充字符)

padL('zzz', 10, 'x');
// xxxxxxxzzz

@BananaAcid:如果你传递一个未定义的值或长度为0的字符串，你会得到0undefined，所以:

作为建议

function padL(a, b, c) { // string/number, length=2, char=0
  return (new Array((b || 1) + 1).join(c || 0) + (a || '')).slice(-(b || 2))
}

但这也可以用更短的方式实现。

function padL(a, b, c) { // string/number, length=2, char=0
  return (new Array(b || 2).join(c || 0) + (a || c || 0)).slice(-b)
}

它还适用于:

padL(0)
padL(NaN)
padL('')
padL(undefined)
padL(false)

如果你想用两种方式填充:

function pad(a, b, c, d) { // string/number, length=2, char=0, 0/false=Left-1/true=Right
  return a = (a || c || 0), c = new Array(b || 2).join(c || 0), d ? (a + c).slice(0, b) : (c + a).slice(-b)
}

不用slice就可以写得更简洁。

function pad(a, b, c, d) {
  return a = (a || c || 0) + '', b = new Array((++b || 3) - a.length).join(c || 0), d ? a+b : b+a
}
/*

Usage:

pad(
 input // (int or string) or undefined, NaN, false, empty string
       // default:0 or PadCharacter
 // Optional
 ,PadLength // (int) default:2
 ,PadCharacter // (string or int) default:'0'
 ,PadDirection // (bolean) default:0 (padLeft) - (true or 1) is padRight
)

*/

现在如果你试着用2填充'averylongword'…那不是我的问题。

---

我说过我会给你小费。

大多数情况下，如果你填充，你会做N次相同的值。

在循环中使用任何类型的函数都会降低循环的速度!!

所以如果你只是想在一个长列表中填充一些数字，不要使用函数来做这个简单的事情。

可以这样说:

var arrayOfNumbers = [1, 2, 3, 4, 5, 6, 7],
    paddedArray = [],
    len = arrayOfNumbers.length;
while(len--) {
  paddedArray[len] = ('0000' + arrayOfNumbers[len]).slice(-4);
}

如果你不知道如何根据数组内的数字来确定最大填充大小。

var arrayOfNumbers = [1, 2, 3, 4, 5, 6, 7, 49095],
    paddedArray = [],
    len = arrayOfNumbers.length;

// Search the highest number
var arrayMax = Function.prototype.apply.bind(Math.max, null),
// Get that string length
padSize = (arrayMax(arrayOfNumbers) + '').length,
// Create a Padding string
padStr = new Array(padSize).join(0);
// And after you have all this static values cached start the loop.
while(len--) {
  paddedArray[len] = (padStr + arrayOfNumbers[len]).slice(-padSize); // substr(-padSize)
}
console.log(paddedArray);

/*
0: "00001"
1: "00002"
2: "00003"
3: "00004"
4: "00005"
5: "00006"
6: "00007"
7: "49095"
*/

这里有一个你可以使用的内置方法-

str1.padStart(2, '0')

String.prototype.padLeft = function(pad) {
        var s = Array.apply(null, Array(pad)).map(function() { return "0"; }).join('') + this;
        return s.slice(-1 * Math.max(this.length, pad));
    };

用法:

“123”.padLeft（2） 返回：“123” “12”.padLeft（2） 返回：“12” “1”.padLeft（2） 返回：“01”

Never insert data somewhere (especially not at beginning, like str = pad + str;), since the data will be reallocated everytime. Append always at end! Don't pad your string in the loop. Leave it alone and build your pad string first. In the end concatenate it with your main string. Don't assign padding string each time (like str += pad;). It is much faster to append the padding string to itself and extract first x-chars (the parser can do this efficiently if you extract from first char). This is exponential growth, which means that it wastes some memory temporarily (you should not do this with extremely huge texts).

if (!String.prototype.lpad) { String.prototype.lpad =函数(pad, len) { 而(pad。长度< len) { Pad += Pad; ｝ 返回垫。Substr (0, lens -this.length) + this; ｝ ｝ if (!String.prototype.rpad) { String.prototype.rpad = function(pad, len) { 而(pad。长度< len) { Pad += Pad; ｝ 返回这个+ pad。substr (0, len-this.length); ｝ ｝