是否有JavaScript函数可以填充字符串以达到确定的长度？
我需要一个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>
但我不知道它在做什么，它似乎不适合我。
我在这里找到了这个解决方案，这对我来说简单得多：
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”的时间
一个更快的方法
如果你反复这样做，例如为数组填充值，性能是一个因素，下面的方法可以给你几乎100倍的速度优势 （ jsPerf ）超过目前在互联网上讨论的其他解决方案。 基本的想法是，你正在提供一个填充空字符串作为缓冲区的填充函数。 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.repeat快2倍，如修改后的JsPerf所示
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 right = Math.ceil((padlen = len - str.length) / 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; }
它更可读。
这是一个递归的方法。
function pad(width, string, padding) { return (width <= string.length) ? string : pad(width, padding + string, padding) }
一个例子…
pad(5, 'hi', '0') => "000hi"
使用ECMAScript 6方法String＃重复 ，一个pad函数就像下面这样简单：
String.prototype.padLeft = function(char, length) { return char.repeat(Math.max(0, length - this.length)) + this; }
String#repeat目前仅支持Firefox和Chrome浏览器。 对于其他实现，可以考虑下面的简单的polyfill：
String.prototype.repeat = String.prototype.repeat || function(n){ return n<=1 ? this : (this + this.repeat(n-1)); }
这两个解决方案的关键技巧是创建一个给定大小的array实例（比期望的长度多一个），然后立即调用join()方法来创建一个string 。 join()方法传递了填充string （可能是空格）。 由于array是空的，因此在将array连接到一个结果string的过程中，空单元格将呈现为空string ，并且只有填充将保留。 这是一个非常好的技术。
使用ECMAScript 6方法String＃repeat和Arrow函数 ，pad功能如下简单：
var leftPad = (s, c, n) => c.repeat(n - s.length) + s; leftPad("foo", "0", 5); //returns "00foo"
的jsfiddle
编辑：来自评论的建议：
const leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;
这样，当s.length大于n时，它不会抛出错误
编辑2：来自评论的建议：
const leftPad = (s, c, n) =>{ s = s.toString(); c = c.toString(); return s.length > n ? s : c.repeat(n - s.length) + s; }
这样，你可以使用函数的字符串和非字符串。
String.prototype.padStart()和String.prototype.padEnd()是当前的TC39候选提议：请参阅github.com/tc39/proposal-string-pad-start-end （仅在2016年4月的Firefox中提供; polyfill是可用）。
填充默认值
我注意到，我大多需要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 ..so：
如建议
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 ) */
现在，如果你试图用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" */
在ES8中，有两个选项用于填充。
你可以在文档中检查它们。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd
https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
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方法也被添加，以相同的方式工作。
对于浏览器兼容性（和一个有用的polyfill），请参阅此链接 。
这是我使用的一个简单的功能。
var pad=function(num,field){ var n = '' + num; var w = n.length; var l = field.length; var pad = w < l ? lw : 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
塞缪尔的想法，在这里向上。 并记住一个旧的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
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 ); });
基本上只有一行代码是一个简单的答案。
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);
与简单的字符串连接相比，数组操作非常慢。 当然，你的用例的基准。
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; };
@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'
我认为最好避免递归，因为它的代价很大。
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));
这是一个JavaScript函数，它添加了指定数量的带有自定义符号的填充。 该函数需要三个参数。
padMe - >字符串或数字，以左垫
垫 - >垫的数量
padSymble - >自定义符号，默认为“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()); }
/ *以下是一些结果： > leftPad（1） “1” > leftPad（1，4） “0001” > leftPad（1，4，“0”） “0001” > leftPad（1，4，“@”） “@@@ 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 "
如果你只是想要一个非常简单的单引号填充，只需要一个所需的最大填充长度的填充字符的字符串，然后子字符串到你想要填充的长度。
示例：使用空格填充字符串存储，长度为25个字符。
var e = "hello"; e = e + " ".substring(e.length)
结果： "hello "
如果你想做一个数字作为输入只需调用.toString()之前。
这是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=" "] 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"
如果你不介意包含一个实用程序库，lodash库有_.pad，_ . padLeft和_.padRight函数。
一位朋友询问使用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 />"));
- 不要在某处插入数据（特别是不要在开始的时候，像
str = pad + str;），因为数据每次都会被重新分配。 始终追加！ - 不要在循环中填充字符串。 保持独立，先建立你的垫字符串。 最后将它与主字符串连接起来。
- 不要每次分配填充字符串（如
str += pad;）。 将填充字符串附加到自身并提取第一个x-chars（解析器可以从第一个字符提取时可以高效地执行此操作）要快得多。 这是指数增长，这意味着它暂时浪费了一些内存（你不应该用非常大的文本来做这件事）。
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); } }
简短的说法：
(x=>(new Array(int-x.length+1)).join(char)+x)(String)
例：
(x=>(new Array(6-x.length+1)).join("0")+x)("1234")
返回：“001234”
这是我的要求
我不太确定它的性能，但我发现它比我在这里看到的其他选项更可读…
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); };
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)
基于这个问题的最好的答案，我已经做了一个名为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"
的jsfiddle
尝试这个：-
function leftPad(number) { return (number < 9)?'0'+number:number; } //call like this var month=3; month=leftPad(month);//output:- month=04
