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


272

我需要一个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>

但是我不知道它在做什么,这似乎对我不起作用。


8
“乔纳斯” .padStart(7,““)developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
奥斯

Answers:


515

我在这里找到了这个解决方案,这对我来说要简单得多:

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”的格式返回时间


11
我发现的最易读,最简洁的方法;非常简单,我通常都不会为原型扩展而烦恼(至少对于应用程序中的少数用途)。做得好。
2013年

32
请注意,此解决方案将缩短比slice参数更长的字符串(即此处为5个字符)。
Denis V

1
嗨,亚尼夫。您对修改算法有很好的建议。但是,就我而言,要求总是先于此问题,因为当我尝试格式化某些内容时,我总是对要处理的值具有最低限度的规范,在这种情况下,规范将纠正此问题。例如,如果我有一个要格式化的电话号码,并且我只在加拿大使用电话,那么在格式化之前,我将验证该电话号码是否包含10个字符。无论如何,您的解决方案也很棒。:)
塞缪尔

1
如果您经常这样做(例如,将较长的值列表填充到页面或其他应用程序中的某种列表中),还可以在stackoverflow.com/questions/2686855/…上找到一种更快的方法的答案
Shyam Habarakada

6
迫切需要对此进行更新以使用JS StringString.padStart()以及String.padEnd()进行左右填充。
SudoKid

119

更快的方法

如果您反复执行此操作(例如,将值填充到数组中),并且性能是一个因素,那么与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 这里


5
+1与StackOverflow有关的问题是版主无法根据明显优越的答案更改投票。这是其中一种情况。
杰森·塞布林2014年

1
正如其他人在后来的jsPerf(上面添加的链接)中证明的那样,这种方法比ES6 string.repeat方法快约2倍。因此,如果您要进行大量的字符串填充,请一定尝试一下。
Shyam Habarakada

5
我对Jason的评论感到困惑-这个答案与被接受的答案有何不同?
corwin.amber16年

1
我看着你的jsPerf。这些测试是针对您的函数的,并且使用了while()循环,而其他的高答案都没有使用。我不确定这意味着更快吗?
HoldOffHunger

48

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;

}

它更具可读性。


1
似乎没有工作的时候垫一个空间:pad("hello", 20) = "hello "
Cillié马兰

40

这是一种递归方法。

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

一个例子...

pad(5, 'hi', '0')
=> "000hi"

7
还有一个整数乘法的递归定义...永远记住递归中有一个“诅咒” ...
flow

32
街上也有独角鲸和一个醉汉,但两者都不相关。递归的诅咒仅适用于程序员不知道何时合适的情况。
hypno7oad 2013年

12
“递归的诅咒仅在程序员不知道什么时候适合时才适用”,或者当他们不知道递归是不合适的时候。如用于简单的弦垫功能。
Danation

这非常优雅,非常适合我的用例。如果您需要填充空格以对齐文本,只需输入最长字符串的长度=)
Damon Aw 2014年

12
它很优雅,但是在每次函数迭代时也会创建一个新的字符串。此函数为O(n),而@Samuel最受欢迎的解决方案是O(1)。两者都很优雅,但是效率更高。也就是说,这是一种整洁的方法,使用另一种语言可能会更快。
暗恋

40

String.prototype.padStart()String.prototype.padEnd()目前TC39候选人的提案:见github.com/tc39/proposal-string-pad-start-end(仅在Firefox可作为2016年4月的;一个填充工具可用)。


13
现在受所有(现代)浏览器支持:developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/…–
Sphinxxx

对于懒惰:myString.padStart(padLength [, padString])myString.padEnd(padLength [, padString])
约翰Dettmar

1
现在,所有现代浏览器都支持这种用法,请添加一些示例用法。应该鼓励这一点。
富兰克林于

天哪,直到今天我怎么还没听说过?应该是公认的答案。
electrovir

29

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),请参见此链接


现在最好的答案在这里!2019!
彼得·克劳斯

22

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

对于那些使用Node.js的人,那里也支持String.repeat。
jkt123 '18

15

使用ECMAScript 6方法String#repeatArrow函数,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

edit2: 来自评论的建议:

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

这样,您可以将函数用于字符串和非字符串。


1
这很好,但是如果s.length大于n它会抛出。建议:let leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;
David G

它不适用于非字符串。就像在leftPad(12, ' ', 5)。虽然我严格来说知道这可能是好的,但这可能是最常见的用例之一(填充数字)。也许吧function leftPad(s, c, n) { s = s.toString(); return s.length > len ? s : c.repeat(n - s.length) + s; }。使用function方式leftPad可以位于文件的底部。否则,您应该使用constnot var或not let
gman

@gman感谢您的建议,但是您的变量是len多少?
InsOp

Doh len应该是n
gman

14

这两种解决方案的关键技巧是创建一个array具有给定大小(比所需长度大一倍)的实例,然后立即调用该join()方法来制作一个string。该join()方法通过了填充string(可能是空格)。由于的array值为空,因此strings在将array合并为一个结果的过程中,空单元格将变为空string,并且仅保留填充。这是一种非常好的技术。


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

第三个参数(填充字符)

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

非常好!产生一个相同的结果,就像一条注释:这将字符串连接到给定的最大长度,并且空字符串将是一个字符,太短,并且未定义的str将导致使用“未定义”的蜂音,并且拼接可能会引发错误-结合。return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2))。和往常一样:你们在那里,不要只是复制您不了解的代码。
BananaAcid 2014年

1
(new Array(b || 2).join(c || 0)+(a || c || 0))。slice(-b)... shorter
cocco 2014年


9

在这里接受塞缪尔的想法。并记住一个旧的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

5

在新的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

该答案已被其他多个答案提及,因此它是重复的,不添加任何新信息。请先搜索后再回答。
富兰克林于

这是第一个带有完整签名的人。到目前为止,它肯定是唯一的答案。
d_f

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  


3

es7目前只是草稿和建议,但是如果您想跟踪与规范的兼容性,则pad功能需要:

  1. 多字符键盘支持。
  2. 不要截断输入字符串
  3. 填充默认为空格

从我的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 );
});

3

这基本上是一行代码的简单答案。

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

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

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'

2

现在是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"


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


1

这是一个JavaScript函数,使用自定义symble添加指定数量的填充。该函数采用三个参数。

    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”

* /

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 "

不要搞乱原型!
Rihards

1

如果您只想填充一个非常简单的hacker内衬,则只需创建一个具有所需最大填充长度的所需填充字符的字符串,然后将其子字符串化为您要填充的长度即可。

示例:将字符串存储区中e的空格填充为25个字符长。

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

结果: "hello "

如果要对输入的数字进行相同的操作,请先调用.toString()它。


这实际上很整洁,而不是用作通用功能-但我可以将其视为在某些情况下可以保存循环的有效技巧。
2014年

有趣的主意。@ankr要将其用作通用功能,可以使用Array(n).join(c)来配置填充长度和填充字符,例如Array(26).join(' ')
WynandB

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

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 />"));


1

有点晚了,但是我想还是可以分享。我发现向对象添加原型扩展很有用。这样,我就可以左右填充数字和字符串。我有一个包含与脚本中相似的实用程序的模块。

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

1
  1. 切勿在任何地方插入数据(尤其是不要在开头插入数据str = pad + str;),因为每次都会重新分配数据。始终附加在最后!
  2. 不要将字符串插入循环中。放任不管,并首先构建您的填充字符串。最后,将其与您的主字符串连接在一起。
  3. 不要每次都指定填充字符串(例如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);
    }
}


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);
};
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.