现在是2014年，我建议使用JavaScript字符串填充函数。哈!

基本的:带空格的右垫

function pad (str, length) {
    var padding = (new Array(Math.max(length - str.length + 1, 0))).join(" ");
    return str + padding;
}

花式:选项垫

/**
 * @param {*}       str                         Input string, or any other type (will be converted to string)
 * @param {number}  length                      Desired length to pad the string to
 * @param {Object}  [opts]
 * @param {string}  [opts.padWith=" "]          Character to use for padding
 * @param {boolean} [opts.padLeft=false]        Whether to pad on the left
 * @param {boolean} [opts.collapseEmpty=false]  Whether to return an empty string if the input was empty
 * @returns {string}
 */
function pad(str, length, opts) {
    var padding = (new Array(Math.max(length - (str + "").length + 1, 0))).join(opts && opts.padWith || " "),
        collapse = opts && opts.collapseEmpty && !(str + "").length;
    return collapse ? "" : opts && opts.padLeft ? padding + str : str + padding;
}

使用(的):

pad("123", 5);
// Returns "123  "

pad(123, 5);
// Returns "123  " - non-string input

pad("123", 5, { padWith: "0", padLeft: true });
// Returns "00123"

pad("", 5);
// Returns "     "

pad("", 5, { collapseEmpty: true });
// Returns ""

pad("1234567", 5);
// Returns "1234567"

一个朋友问我如何使用JavaScript函数向左填充。它变成了我们中的一些人在聊天中努力编码高尔夫球。结果是:

function l(p,t,v){
    v+="";return v.length>=t?v:l(p,t,p+v); 
}

它确保要填充的值是一个字符串，然后如果它不是所需的总长度，它将填充一次，然后递归。下面是它看起来更有逻辑的命名和结构

function padLeft(pad, totalLength, value){
    value = value.toString();

    if( value.length >= totalLength ){
        return value;
    }else{
        return padLeft(pad, totalLength, pad + value);
    }
}

我们所使用的示例是确保数字在左边用0填充，使最大长度为6。下面是一个例子:

函数l (p t v) {v + = " ";返回v.length > = t ? v: l (p t, p + v);} Var vals = [6451,123,466750]; Var pad = l(0,6,vals[0]);// pad为0，最大长度为6 Var pads = vals.map(函数(i){返回l(0,6,i)}); document . write(垫。加入(“< br / > "));

ECMAScript 2017在String原型中增加了一个padStart方法。这个方法将用空格填充字符串到给定的长度。此方法还接受一个可选字符串，该字符串将用于代替空格作为填充。

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

还添加了以相同方式工作的padEnd方法。

关于浏览器兼容性(和一个有用的填充)，请参见此链接。

这里有一个简单的答案，基本上只有一行代码。

var value = 35 // the numerical value
var x = 5 // the minimum length of the string

var padded = ("00000" + value).substr(-x);

确保你填充的字符数量，这里的0，至少和你预期的最小长度一样多。因此，实际上，把它放在一行中，在这种情况下，得到“00035”的结果是:

var padded = ("00000" + 35).substr(-5);

继承塞缪尔的想法，在上面这里。记住一个旧的SQL脚本，我尝试了这个:

a=1234;
'0000'.slice(a.toString().length)+a;

它适用于我能想到的所有情况:

a=     1 result  0001
a=    12 result  0012
a=   123 result  0123
a=  1234 result  1234
a= 12345 result 12345
a=  '12' result  0012

一种更快的方法

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站点已不再在线。不幸的是，这意味着我们无法得到那些测试结果。虽然悲伤，但事实如此。