我需要一个JavaScript函数，它可以获取一个值并将其填充到给定的长度（我需要空格，但任何事情都可以）。我发现了这个：
代码：
String.prototype.pad = function(l, s, t){
return s || (s = " "), (l -= this.length) > 0 ? (s = new Array(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;
};
示例：
<script type="text/javascript">
//<![CDATA[
var s = "Jonas";
document.write(
'<h2>S = '.bold(), s, "</h2>",
'S.pad(20, "[]", 0) = '.bold(), s.pad(20, "[]", 0), "<br />",
'S.pad(20, "[====]", 1) = '.bold(), s.pad(20, "[====]", 1), "<br />",
'S.pad(20, "~", 2) = '.bold(), s.pad(20, "~", 2)
);
//]]>
</script>
但我不知道它在做什么，它似乎对我不起作用。
答案 0 :(得分：484)
我找到了这个解决方案here，这对我来说简单得多：
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.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”格式的时间
答案 1 :(得分：115)
如果您反复执行此操作，例如填充数组中的值，并且性能是一个因素，则以下方法可以为您提供近乎 100x优势的速度（jsPerf ）目前在网络上讨论的其他解决方案。基本思想是为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 测试here。
这比ES6 string.repeat快2倍，如修订后的JsPerf here
答案 2 :(得分：49)
http://www.webtoolkit.info/javascript_pad.html
/**
*
* Javascript string pad
* http://www.webtoolkit.info/
*
**/
var STR_PAD_LEFT = 1;
var STR_PAD_RIGHT = 2;
var STR_PAD_BOTH = 3;
function pad(str, len, pad, dir) {
if (typeof(len) == "undefined") { var len = 0; }
if (typeof(pad) == "undefined") { var pad = ' '; }
if (typeof(dir) == "undefined") { var dir = STR_PAD_RIGHT; }
if (len + 1 >= str.length) {
switch (dir){
case STR_PAD_LEFT:
str = Array(len + 1 - str.length).join(pad) + str;
break;
case STR_PAD_BOTH:
var padlen = len - str.length;
var right = Math.ceil( padlen / 2 );
var left = padlen - right;
str = Array(left+1).join(pad) + str + Array(right+1).join(pad);
break;
default:
str = str + Array(len + 1 - str.length).join(pad);
break;
} // switch
}
return str;
}
它更具可读性。
答案 3 :(得分：39)
这是一种递归方法。
function pad(width, string, padding) {
return (width <= string.length) ? string : pad(width, padding + string, padding)
}
一个例子......
pad(5, 'hi', '0')
=> "000hi"
答案 4 :(得分：32)
String.prototype.padStart()和String.prototype.padEnd()目前是TC39候选提案：请参阅github.com/tc39/proposal-string-pad-start-end（仅适用于2016年4月的Firefox; polyfill可用。）
答案 5 :(得分：22)
使用ECMAScript 6方法String#repeat，pad函数非常简单：
String.prototype.padLeft = function(char, length) {
return char.repeat(Math.max(0, length - this.length)) + this;
}
String#repeat。对于其他实现，可以考虑以下简单的polyfill：
String.prototype.repeat = String.prototype.repeat || function(n){
return n<=1 ? this : (this + this.repeat(n-1));
}
答案 6 :(得分：21)
ECMAScript 2017将一个padStart方法添加到String原型中。此方法将使用空格填充给定长度的字符串。此方法还采用可选字符串，而不是填充空格。
use local version 4.4.0还添加了一个padEnd方法，其工作方式相同。
对于浏览器兼容性（以及有用的polyfill），请参阅this link。
答案 7 :(得分：14)
这两种解决方案的关键技巧是创建一个具有给定大小的array实例（比所需长度多一个），然后立即调用join()方法生成{{ 1}}。 string方法传递了填充join()（可能是空格）。由于string为空，因此在将array加入到一个结果strings的过程中，空单元格将呈现为空array，并且仅保留填充。这是一个非常好的技术。
答案 8 :(得分：14)
使用ECMAScript 6方法String#repeat和Arrow functions，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;
这样，当s.length大于n
<强> EDIT2： 意见建议：
const leftPad = (s, c, n) =>{ s = s.toString(); c = c.toString(); return s.length > n ? s : c.repeat(n - s.length) + s; }
这样，您可以将函数用于字符串和非字符串等。
答案 9 :(得分：10)
使用默认值填充
我注意到我主要需要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
如果我添加第二个参数（打击垫宽度）
padL(1,3);
// 001
第三个参数（pad char）
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)
}
可以在不使用切片的情况下以较短的方式写入。
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
)
*/
现在，如果你试图填写“averylongword＆＃39; 2 ...这不是我的问题。
说我给你一个提示。
大多数情况下，如果你用相同的数值填充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"
*/
答案 10 :(得分：9)
使用ES8，有两个填充选项。
您可以在文档中查看它们。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
答案 11 :(得分：8)
接受塞缪尔的想法，在这里向上。并记住一个旧的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
答案 12 :(得分：4)
简短的方法：
(x=>(new Array(int-x.length+1)).join(char)+x)(String)
示例：
(x=>(new Array(6-x.length+1)).join("0")+x)("1234")
返回：＆＃34; 001234＆＃34;
答案 13 :(得分：4)
这是我使用的一个简单功能。
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
答案 14 :(得分：4)
填充字符串已在新的javascript版本中添加。
str.padStart(targetLength [, padString])
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart
如果您需要自己的功能，请查看以下示例：
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
答案 15 :(得分：3)
基本上是一行代码中的简单答案。
var value = 35 // the numerical value
var x = 5 // the minimum length of the string
var padded = ("00000" + value).substr(-x);
确保填充中的字符数（此处为零）至少与预期的最小长度一样多。所以，真的，把它放到一行，得到＆＃34; 00035＆＃34;在这种情况下是：
var padded = ("00000" + 35).substr(-5);
答案 16 :(得分：3)
es7目前只是草案和提案，但如果您想跟踪规范的兼容性，那么您的打击垫功能需要：
从我的polyfill库中，但对原型扩展应用您自己的尽职调查。
// 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 );
});
答案 17 :(得分：2)
这是您可以使用的内置方法 -
str1.padStart(2, '0')
答案 18 :(得分：2)
我认为最好避免递归，因为它代价高昂。
function padLeft(str,size,padwith) {
if(size <= str.length) {
// not padding is required.
return str;
} else {
// 1- take array of size equal to number of padding char + 1. suppose if string is 55 and we want 00055 it means we have 3 padding char so array size should be 3 + 1 (+1 will explain below)
// 2- now join this array with provided padding char (padwith) or default one ('0'). so it will produce '000'
// 3- now append '000' with orginal string (str = 55), will produce 00055
// why +1 in size of array?
// it is a trick, that we are joining an array of empty element with '0' (in our case)
// if we want to join items with '0' then we should have at least 2 items in the array to get joined (array with single item doesn't need to get joined).
// <item>0<item>0<item>0<item> to get 3 zero we need 4 (3+1) items in array
return Array(size-str.length+1).join(padwith||'0')+str
}
}
alert(padLeft("59",5) + "\n" +
padLeft("659",5) + "\n" +
padLeft("5919",5) + "\n" +
padLeft("59879",5) + "\n" +
padLeft("5437899",5));
答案 19 :(得分：2)
如果您不介意包含实用程序库，则lodash库具有_.pad, _.padLeft and _.padRight个函数。
答案 20 :(得分：2)
与简单的字符串连接相比，数组操作非常慢。当然，您的用例的基准。
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;
};
答案 21 :(得分：2)
2014年，我建议使用Javascript字符串填充功能。哈！
Bare-bones：带空格的右键垫
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"
答案 22 :(得分：2)
@Daniel LaFavers'答案的变体。
var mask = function (background, foreground) {
bg = (new String(background));
fg = (new String(foreground));
bgl = bg.length;
fgl = fg.length;
bgs = bg.substring(0, Math.max(0, bgl - fgl));
fgs = fg.substring(Math.max(0, fgl - bgl));
return bgs + fgs;
};
例如：
mask('00000', 11 ); // '00011'
mask('00011','00' ); // '00000'
mask( 2 , 3 ); // '3'
mask('0' ,'111'); // '1'
mask('fork' ,'***'); // 'f***'
mask('_____','dog'); // '__dog'
答案 23 :(得分：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
};
答案 24 :(得分：1)
使用padStart
'abc'.padStart(10); // " abc"
'abc'.padStart(10, "foo"); // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
https://developer.mozilla.org/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart
答案 25 :(得分：1)
/**************************************************************************************************
Pad a string to pad_length fillig it with pad_char.
By default the function performs a left pad, unless pad_right is set to true.
If the value of pad_length is negative, less than, or equal to the length of the input string, no padding takes place.
**************************************************************************************************/
if(!String.prototype.pad)
String.prototype.pad = function(pad_char, pad_length, pad_right)
{
var result = this;
if( (typeof pad_char === 'string') && (pad_char.length === 1) && (pad_length > this.length) )
{
var padding = new Array(pad_length - this.length + 1).join(pad_char); //thanks to http://stackoverflow.com/questions/202605/repeat-string-javascript/2433358#2433358
result = (pad_right ? result + padding : padding + result);
}
return result;
}
然后你可以这样做：
alert( "3".pad("0", 3) ); //shows "003"
alert( "hi".pad(" ", 3) ); //shows " hi"
alert( "hi".pad(" ", 3, true) ); //shows "hi "
答案 26 :(得分：1)
一位朋友询问使用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.这是一个示例集：
function l(p,t,v){v+="";return v.length>=t?v:l(p,t,p+v);}
var vals = [6451,123,466750];
var pad = l(0,6,vals[0]);// pad with 0's, max length 6
var pads = vals.map(function(i){ return l(0,6,i) });
document.write(pads.join("<br />"));
答案 27 :(得分：1)
有点晚了，但我想我可能会分享。我发现向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;
}
};
答案 28 :(得分：1)
如果您只是想要一个非常简单的hacky单行填充，只需创建所需填充长度所需填充字符的字符串，然后将其子串到您想要填充的长度。
示例：在e中填充字符串存储区，空格为25个字符。
var e = "hello"; e = e + " ".substring(e.length)
结果："hello "
如果您想使用输入数字进行相同操作，请先调用.toString()。
答案 29 :(得分：1)
这是一个JavaScript函数，可以使用自定义符号添加指定数量的布丁。该函数有三个参数。
padMe --> string or number to left pad
pads --> number of pads
padSymble --> custom symble, default is "0"
function leftPad(padMe, pads, padSymble) {
if( typeof padMe === "undefined") {
padMe = "";
}
if (typeof pads === "undefined") {
pads = 0;
}
if (typeof padSymble === "undefined") {
padSymble = "0";
}
var symble = "";
var result = [];
for(var i=0; i < pads ; i++) {
symble += padSymble;
}
var length = symble.length - padMe.toString().length;
result = symble.substring(0, length);
return result.concat(padMe.toString());
}
/* Here are some results: > leftPad(1) "1" > leftPad(1, 4) "0001" > leftPad(1, 4, "0") "0001" > leftPad(1, 4, "@") "@@@1" */
答案 30 :(得分：1)
str = pad + str;），因为每次都会重新分配数据。始终追加！str += pad;）。将填充字符串附加到自身并提取第一个x-chars要快得多（如果从第一个char中提取，解析器可以有效地执行此操作）。这是指数增长，这意味着它暂时浪费了一些内存（你不应该用非常大的文本来做这件事）。
if (!String.prototype.lpad) {
String.prototype.lpad = function(pad, len) {
while (pad.length < len) {
pad += pad;
}
return pad.substr(0, len-this.length) + this;
}
}
if (!String.prototype.rpad) {
String.prototype.rpad = function(pad, len) {
while (pad.length < len) {
pad += pad;
}
return this + pad.substr(0, len-this.length);
}
}
答案 31 :(得分：0)
包括所有选项
function padding(stringToBePadded, paddingCharacter, totalLength, padLeftElseRight){
//will pad any string provided in first argument, with padding character provide in 2nd argument and truncate to lenght provided in third argument, padding left if 4th argument true or undefined, right if false.
// i.e. padding("lode","x","10") --> "xxxxxxlode"
// i.e. padding("lode","x","10",true) --> "xxxxxxlode"
// i.e. padding("lode","x","10",false) --> "lodexxxxxx"
// i.e. padding("12","0","5") --> "00012"
{
padLeftElseRight = typeof padLeftElseRight !== 'undefined' ? padLeftElseRight : true;
}
if (stringToBePadded.length > totalLength){
// console.log("string too long to be padded");
return stringToBePadded;
}
var paddingString = paddingCharacter.repeat(totalLength);//make long string of padding characters
if ( padLeftElseRight){
return String(paddingString+stringToBePadded).slice(-totalLength);
}else{
return String(stringToBePadded+paddingString).slice(0,totalLength);
}
}
答案 32 :(得分：0)
这是我的看法
我不太确定它的性能，但我发现它比我在这里看到的其他选项更具可读性......
var replicate = function(len, char) {
return Array(len+1).join(char || ' ');
};
var padr = function(text, len, char) {
if (text.length >= len) return text;
return text + replicate(len-text.length, char);
};
答案 33 :(得分：0)
对于这样的事情，我可能会在需要的地方创建一个单行函数：
var padleft = (s,c,len) => { while(s.length < len) s = c + s; return s; }
示例：
> console.log( padleft( '110', '0', 8) );
> 00000110
答案 34 :(得分：0)
这是我的功能版本：
function str_pad(str, size, char, right) {
var s = str + "";
while (s.length < size) {
if (right) {
s = s + char;
} else {
s = char + s;
}
}
return s;
}
答案 35 :(得分：0)
如果你想要紧凑的东西，可以使用一个衬垫：
String.prototype.pad = function(len, chr){
return((((new Array(len)).fill(chr)).join("") +this).substring(this.length));
}
答案 36 :(得分：0)
使用重复，这会更简单。
var padLeft=function(str, pad, fw){
return fw>str.length ? pad.repeat(fw-str.length)+str : str;
}
您可以像以下一样使用它： padeLeft（'origin-str'，'0'，20）
答案 37 :(得分：0)
1. function
var _padLeft = function(paddingString, width, replacementChar) {
return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');
};
2. String prototype
String.prototype.padLeft = function(width, replacementChar) {
return this.length >= width ? this.toString() : (replacementChar + this).padLeft(width, replacementChar || ' ');
};
3. slice
('00000' + paddingString).slice(-5)
答案 38 :(得分：0)
根据这个问题的最佳答案，我为 String 制作了一个名为padLeft的原型（与C＃完全相同）：
String.prototype.padLeft = function (paddingChar, totalWidth) {
if (this.toString().length >= totalWidth)
return this.toString();
var array = new Array(totalWidth);
for (i = 0; i < array.length; i++)
array[i] = paddingChar;
return (array.join("") + this.toString()).slice(-array.length);
}
用法：
var str = "12345";
console.log(str.padLeft("0", 10)); //Result is: "0000012345"
答案 39 :(得分：0)
我喜欢这样做，以防你需要填充多个字符或标签（例如 ）进行展示：
$.padStringLeft = function(s, pad, len) {
if(typeof s !== 'undefined') {
var c=s.length; while(len > c) {s=pad+s;c++;}
}
return s;
}
$.padStringRight = function(s, pad, len) {
if(typeof s !== 'undefined') {
var c=s.length; while(len > c) {s += pad;c++;}
}
return s;
}
答案 40 :(得分：0)
试试这个： -
function leftPad(number) {
return (number < 9)?'0'+number:number;
}
//call like this
var month=3;
month=leftPad(month);//output:- month=04
答案 41 :(得分：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" 答案 42 :(得分：-1)
与PHP一样：
const STR_PAD_RIGHT = 1;
const STR_PAD_LEFT = 0;
const STR_PAD_BOTH = 2;
/**
* @see http://php.net/str_pad
* @param mixed input
* @param integer length
* @param string string
* @param integer type
* @return string
*/
function str_pad(input, length, string, type) {
if (type === undefined || (type !== STR_PAD_LEFT && type !== STR_PAD_BOTH)) {
type = STR_PAD_RIGHT
}
if (input.toString().length >= length) {
return input;
} else {
if (type === STR_PAD_BOTH) {
input = (string + input + string);
} else if (type == STR_PAD_LEFT) {
input = (string + input);
} else {
input = (input + string);
}
return str_pad(input.toString(), length, string, type);
}
}