是否有JavaScript函数可以填充字符串以达到确定的长度？

我需要一个JavaScript函数，它可以获取一个值并将其填充到给定的长度（我需要空格，但任何东西都可以）。我发现：

代码：

String.prototype.pad=函数（l、s、t）{
返回s | |（s=”“），（l-=this.length）>0？（s=新数组（Math.ceil（l/s.length）
+1.join（s））.substr（0，t=！t？l:t==1？0:Math.ceil（l/2））
+this+s.substr（0，l-t）：this；
};

示例：

var s=“Jonas”；
document.write(
'S='.bold（），S，“，
'S.pad（20，“[]”，0）='.bold（），S.pad（20，“[]”，0），“
”，
'S.pad（20，“[=”，1）='.bold（），S.pad（20，[=”，1），“
，”，
'S.pad（20，“~”，2）='.bold（），S.pad（20，“~”，2）
);

但我不知道它到底在做什么，而且它似乎对我不起作用。

---

这两种解决方案的关键技巧是创建一个具有给定大小（比所需长度多一个）的

数组
实例，然后立即调用
join（）
方法生成
字符串。
join（）。由于
数组
为空，因此在将
数组
加入一个结果
字符串
的过程中，空单元格将被呈现为空的
字符串
，并且仅保留填充。这是一种非常好的技术。
我找到了这个解决方案，这对我来说简单得多：

var n = 123

String("00000" + n).slice(-5); // returns 00123
("00000" + n).slice(-5); // returns 00123
("     " + n).slice(-5); // returns "  123" (with two spaces)

这里我对string对象做了一个扩展：

String.prototype.paddingLeft = function (paddingValue) {
   return String(paddingValue + this).slice(-paddingValue.length);
};

使用它的示例：

function getFormattedTime(date) {
  var hours = date.getHours();
  var minutes = date.getMinutes();

  hours = hours.toString().paddingLeft("00");
  minutes = minutes.toString().paddingLeft("00");

  return "{0}:{1}".format(hours, minutes);
};

String.prototype.format = function () {
    var args = arguments;
    return this.replace(/{(\d+)}/g, function (match, number) {
        return typeof args[number] != 'undefined' ? args[number] : match;
    });
};

这将以“15:30”的格式返回时间，这里有一个递归方法

function pad(width, string, padding) { 
  return (width <= string.length) ? string : pad(width, padding + string, padding)
}

与简单的字符串concat相比，数组操作非常慢。当然，为您的用例提供基准

function(string, length, pad_char, append) {
    string = string.toString();
    length = parseInt(length) || 1;
    pad_char = pad_char || ' ';

    while (string.length < length) {
        string = append ? string+pad_char : pad_char+string;
    }
    return string;
};

函数（字符串、长度、填充字符、追加）{
string=string.toString（）；
长度=parseInt（长度）| | 1；
pad_char=pad_char | |“”；
while（string.length

然后你可以做：

alert( "3".pad("0", 3) ); //shows "003"
alert( "hi".pad(" ", 3) ); //shows " hi"
alert( "hi".pad(" ", 3, true) ); //shows "hi "

这里有一个我使用的简单函数

var pad=function(num,field){
    var n = '' + num;
    var w = n.length;
    var l = field.length;
    var pad = w < l ? l-w : 0;
    return field.substr(0,pad) + n;
};

答案的变体

例如：

pad    (20,'     ');    //   20
pad   (321,'     ');    //  321
pad (12345,'     ');    //12345
pad (   15,'00000');    //00015
pad (  999,'*****');    //**999
pad ('cat','_____');    //__cat  

mask('00000', 11  );   // '00011'
mask('00011','00' );   // '00000'
mask( 2     , 3   );   // '3'
mask('0'    ,'111');   // '1'
mask('fork' ,'***');   // 'f***'
mask('_____','dog');   // '__dog'

下面是一个JavaScript函数，它使用自定义符号添加指定数量的填充。该函数采用三个参数。


padMe-->左焊盘的字符串或数字
焊盘-->焊盘数量
padSymble-->自定义符号，默认值为“0”

函数leftPad（padMe、pads、padSymble）{
if（padMe类型==“未定义”）{
padMe=“”；
}
如果（焊盘类型==“未定义”）{
pads=0；
}
如果（padSymble的类型==“未定义”）{
padSymble=“0”；
}
var symble=“”；
var结果=[]；
对于（变量i=0；i

/*以下是一些结果：
>左键盘（1）
"1"
>左键盘（1，4）
"0001"
>左键盘（1,4，“0”）
"0001"
>左键盘（1，4，“@”）
"@@@1"
*/
用默认值填充

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

所以我写了这个函数

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

此简单函数支持数字或字符串作为输入

默认填充为2个字符

默认字符为0

所以我可以简单地写

padL(1);
// 01

如果我添加第二个参数（焊盘宽度）

第三个参数（pad char）

编辑
@香蕉酸
如果传递未定义的值或长度为0的字符串，则会得到
0未定义的
。因此：

按照建议

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)

如果您希望能够以两种方式进行pad：

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”。。。那不是我的问题


说我给你小费。

大多数情况下，如果你使用pad，你会使用相同的值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"
*/

如果您只想填充一个非常简单的hacky单行线，只需将所需填充字符的字符串设置为所需的最大填充长度，然后将其子串为所需填充长度

示例：在
e
中用空格填充字符串存储，长度为25个字符

var e = "hello"; e = e + "                         ".substring(e.length)

结果：
“你好”

如果你想对一个数字做同样的输入，只需在它前面调用
.toString（）
。
一个更快的方法
如果您重复执行此操作，例如在数组中填充值，并且性能是一个因素，那么与目前在inter Web上讨论的其他解决方案相比，以下方法可以在速度上为您提供近100倍的优势。基本思想是为pad函数提供一个完全填充的空字符串作为缓冲区。pad函数只是将要添加到此预填充字符串（一个字符串concat）的字符串追加，然后将结果切片或修剪到所需的长度

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
string要快。同样重复2次，如修改后的JsPerf所示

请注意
jsPerf
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)
}

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 
)

*/

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"
*/

var e = "hello"; e = e + "                         ".substring(e.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);
  }
}

pad('0000000000',123,true);

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

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=" "]          char 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"

String.prototype.padLeft = function(char, length) { 
    return char.repeat(Math.max(0, length - this.length)) + this;
}

String.prototype.repeat = String.prototype.repeat || function(n){ 
    return n<=1 ? this : (this + this.repeat(n-1)); 
}

/**
 * pad string on left
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingLeft = function (b,c) {
    if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),b+this
};

/**
 * pad string on right
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingRight = function (b,c) {
  if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),this+b
};    

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

// Tests
'hello'.lpad(4) === 'hello'
'hello'.rpad(4) === 'hello'
'hello'.lpad(10) === '     hello'
'hello'.rpad(10) === 'hello     '
'hello'.lpad(10, '1234') === '41234hello'
'hello'.rpad(10, '1234') === 'hello12341'

String.prototype.lpad || (String.prototype.lpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str = pad + str;
    }

    return str.substr( -length );
});

String.prototype.rpad || (String.prototype.rpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str += pad;
    }

    return str.substr( 0, length );
});

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

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

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

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

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

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

var leftPad = (s, c, n) => c.repeat(n - s.length) + s;
leftPad("foo", "0", 5); //returns "00foo"

const leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;

const leftPad = (s, c, n) =>{ s = s.toString(); c = c.toString(); return s.length > n ? s : c.repeat(n - s.length) + s; }

(x=>(new Array(int-x.length+1)).join(char)+x)(String)

(x=>(new Array(6-x.length+1)).join("0")+x)("1234")

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

const myString = 'Welcome to my house';
String.prototype.padLeft = function(times = 0, str = ' ') {
    return (Array(times).join(str) + this);
}
console.log(myString.padLeft(12, ':'));
//:::::::::::Welcome to my house

str1.padStart(2, '0')