我需要一个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;
};
例:
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)
);
但我不知道它在做什么,这似乎对我不起作用。
我在这里找到了这个解决方案,这对我来说要简单得多:
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”格式返回时间
更快的方法
如果您重复执行此操作(例如,将值填充到数组中),并且性能是一个因素,那么与Internet上当前讨论的其他解决方案相比,以下方法可以为您带来近100倍的速度(jsPerf)优势。基本思想是为pad函数提供完全填充的空字符串以用作缓冲区。pad函数只是附加到要添加到此预填充字符串(一个字符串连接)的字符串上,然后将结果切片或修整为所需的长度。
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 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;
}
它更具可读性。
这是一种递归方法。
function pad(width, string, padding) {
return (width <= string.length) ? string : pad(width, padding + string, padding)
}
一个例子...
pad(5, 'hi', '0')
=> "000hi"
String.prototype.padStart()
而String.prototype.padEnd()
目前TC39候选人的提案:见github.com/tc39/proposal-string-pad-start-end(仅在Firefox可作为2016年4月的;一个填充工具可用)。
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),请参见此链接。
使用ECMAScript 6方法String#repeat,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));
}
使用ECMAScript 6方法String#repeat和Arrow函数,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; }
这样,您可以将函数用于字符串和非字符串。
这两种解决方案中的关键技巧是创建一个array
具有给定大小(比所需长度大一倍)的实例,然后立即调用该join()
方法来制作一个string
。该join()
方法通过了填充string
(可能是空格)。由于的array
值为空,因此strings
在将array
合并为一个结果的过程中,空单元格将变为空string
,并且仅保留填充。这是一个非常好的技术。
使用默认值填充
我注意到我最需要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
第三个参数(填充字符)
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/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
在这里接受塞缪尔的想法。并记住一个旧的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
在新的javascript版本中添加了padding字符串。
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
这是我使用的一个简单函数。
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
一个简短的方法:
(x=>(new Array(int-x.length+1)).join(char)+x)(String)
例:
(x=>(new Array(6-x.length+1)).join("0")+x)("1234")
返回:“ 001234”
es7目前只是草稿和建议,但是如果您想跟踪与规范的兼容性,则pad功能需要:
- 多字符键盘支持。
- 不要截断输入字符串
- 填充默认为空格
从我的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);
确保填充中的字符数(此处为零)至少与预期的最小长度一样多。因此,实际上,将其放在一行中,在这种情况下获得“ 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'
现在是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函数。
我认为最好避免递归,因为这样做代价高昂。
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函数,它使用自定义symble添加指定数量的padding。该函数采用三个参数。
padMe->左键盘的字符串或数字 垫->垫数 padSymble->自定义symble,默认为“ 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 "
如果您只想填充一个非常简单的hacker单层衬纸,只需创建一个具有所需最大填充长度的所需填充字符的字符串,然后将其子字符串化为要填充的长度即可。
示例:将字符串存储区中e
的空格填充为25个字符长。
var e = "hello"; e = e + " ".substring(e.length)
结果: "hello "
如果要对输入的数字做相同的操作,请先调用.toString()
它。
结合几个解决方案的另一种观点
/**
* 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
};
一位朋友询问如何使用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 />"));
有点晚了,但以为我还是可以分享。我发现向对象添加原型扩展很有用。这样,我就可以左右填充数字和字符串。我的脚本中包含一个包含类似实用程序的模块。
// 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;
}
};
- 永远不要在任何地方插入数据(尤其是不要在开始时,例如
str = pad + str;
),因为每次都会重新分配数据。始终附加在最后! - 不要将字符串插入循环中。放任不管,并首先构建您的填充字符串。最后,将其与您的主字符串连接在一起。
- 不要每次都指定填充字符串(例如
str += pad;
)。将填充字符串附加到其自身并提取第一个x字符要快得多(如果从第一个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);
}
}
这是我的
我不确定它的性能,但是我发现它比我在这里看到的其他选项更具可读性...
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);
};
文章标签:javascript , string
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!
评论已关闭!