【问题标题】:Is there a JavaScript function that can pad a string to get to a determined length?是否有一个 JavaScript 函数可以填充字符串以达到确定的长度?
【发布时间】:2011-02-10 19:49:28
【问题描述】:

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

【问题讨论】:

标签: javascript string


【解决方案1】:

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;

}

它更具可读性。

【讨论】:

  • pad 是空格时似乎不起作用:pad("hello", 20) = "hello "
【解决方案2】:

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

【讨论】:

    【解决方案3】:

    我找到了这个解决方案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”的时间

    【讨论】:

    • 我发现的最易读、最简洁的方法;足够简单,我通常甚至不会为原型扩展而烦恼(至少对于应用程序中的少数用途)。干得好。
    • 请注意,此解决方案将缩短比 slice 参数长的字符串(即此处为 5 个字符)。
    • 嗨亚尼夫。你有一个很好的建议来修改算法。但是,在我的情况下,需求总是先于这个问题,因为当我尝试格式化某些东西时,我总是对我必须处理的值有最少的规范,在这种情况下,规范将纠正这个问题。例如,如果我有一个要格式化的电话号码并且我只在加拿大处理电话,我将在格式化之前验证电话号码是否有 10 个字符。无论如何,您的解决方案也很棒。 :)
    • 如果您经常这样做(例如,在您的页面或其他应用程序的某种列表中填充一长串值),也可以使用 更快的方法查看答案stackoverflow.com/questions/2686855/…
    • 这非常需要更新以使用 JS StringString.padStart()String.padEnd() 进行左/右填充。
    【解决方案4】:

    这是一种递归方法。

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

    一个例子……

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

    【讨论】:

    • 还有一个整数乘法的递归定义......永远记住递归中有一个“诅咒”......
    • 街上还有独角鲸和醉汉,但两者都不相关。递归的诅咒仅适用于程序员不知道何时合适的情况。
    • “递归的诅咒只适用于程序员不知道什么时候合适”或者他们没有意识到它不合适的时候。比如一个简单的字符串填充函数。
    • 这非常优雅,非常适合我的用例。如果您需要填充空格来对齐文本,只需输入最长字符串的长度 =)
    • 它很优雅,但它也会在函数的每次迭代中创建一个新字符串。这个函数是 O(n) 而@Samuel 最流行的解决方案是 O(1)。两者都很优雅,但一个效率更高。也就是说,这是一种简洁的方法,并且在不同的语言中可能会更快。
    【解决方案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;
    };
    

    【讨论】:

      【解决方案6】:

      这是我的看法

      我不太确定它的性能,但我发现它比我在这里看到的其他选项更具可读性...

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

      【讨论】:

        【解决方案7】:
        /**************************************************************************************************
        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 "
        

        【讨论】:

        • 不要乱用原型!
        【解决方案8】:

        这是我使用的一个简单函数。

        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  
        

        【讨论】:

          【解决方案9】:

          @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'
          

          【讨论】:

            【解决方案10】:

            这是一个 JavaScript 函数,它使用自定义符号添加指定数量的填充。该函数接受三个参数。

            padMe --> 字符串或数字到左边的pad 焊盘 --> 焊盘数量 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());
                }
            
            /* 以下是一些结果: > 左垫(1) “1” > leftPad(1, 4) “0001” > leftPad(1, 4, "0") “0001” > leftPad(1, 4, "@") “@@@1” */

            【讨论】:

              【解决方案11】:

              使用默认值填充

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

              所以我写了这个函数

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

              这个简单的函数支持NumberString作为输入

              默认填充是 2 个字符

              默认字符为 0

              所以我可以简单地写

              padL(1);
              // 01
              

              如果我添加第二个参数(焊盘宽度)

              padL(1,3);
              // 001
              

              第三个参数(填充字符)

              padL('zzz',10,'x');
              // xxxxxxxzzz
              

              编辑 @香蕉酸 如果你传递一个未定义的值或一个长度为 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))。和往常一样:你们在那里,不要只是复制你不理解的代码。
              • (new Array(b||2).join(c||0)+(a||c||0)).slice(-b)...更短
              【解决方案12】:
              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)
              

              【讨论】:

                【解决方案13】:

                如果您只想要一个非常简单的 hacky one-liner 来填充,只需制作一个具有所需最大填充长度的所需填充字符的字符串,然后将其子串为您想要填充的长度。

                示例:用空格填充 e 中的字符串存储到 25 个字符长。

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

                结果:"hello "

                如果您想对输入的数字执行相同的操作,只需在此之前调用 .toString()

                【讨论】:

                • 这实际上非常简洁,而不是作为通用功能 - 但我可以将其视为在某些情况下有效的 hack 以保存循环。
                • 有趣的想法。 @ankr 要将其用作通用功能,您可以使用 Array(n).join(c) 使填充长度和填充字符可配置,例如Array(26).join(' ').
                【解决方案14】:

                更快的方法

                如果您重复执行此操作,例如填充数组中的值,并且性能是一个因素,则以下方法可以让您在速度 (jsPerf) 上获得几乎 100 倍的优势目前在互联网上讨论的其他解决方案。基本思想是您为 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 测试 here

                这也比 ES6 string.repeat 快 2 倍,如修改后的 JsPerf here 所示

                请注意jsPerf 不再在线

                请注意,我们最初用于对各种方法进行基准测试的 jsPerf 站点已不再在线。不幸的是,这意味着我们无法获得这些测试结果。悲伤但真实。

                【讨论】:

                • +1 我对 StackOverflow 的部分问题是版主无法根据明显优越的答案更改投票。这是其中一种情况。
                • 正如其他人在后来的 jsPerf 中证明的那样(上面添加的链接),这种方法比 ES6 string.repeat 方法快 2 倍左右。所以如果你做了很多字符串填充,一定要试试这个。
                • 我对 Jason 的评论感到困惑 – 这个答案与接受的答案有何不同?
                • 我看了你的 jsPerf。这些测试适用于您的函数和使用 while() 循环的东西,没有其他高评价的答案使用。我不确定这是否意味着它更快?
                • 我对这种方法的唯一观察是,如果实际str 长度大于pad 长度,那么输出将在最后被截断。这意味着str 将返回到pad 的长度。这可能不是预期或预期的行为。
                【解决方案15】:

                根据这个问题的最佳答案,我为 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"
                

                JsFiddle

                【讨论】:

                  【解决方案16】:

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

                  【讨论】:

                    【解决方案17】:

                    使用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。
                    【解决方案18】:

                    试试这个:-

                    function leftPad(number) {
                         return (number < 9)?'0'+number:number;
                    }
                    
                    //call like this
                    var month=3;
                    month=leftPad(month);//output:- month=04
                    

                    【讨论】:

                      【解决方案19】:

                      结合几个解决方案的另一种方法

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

                      【讨论】:

                        【解决方案20】:

                        采纳塞缪尔的想法,在此向上。还记得一个旧的 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
                        

                        【讨论】:

                          【解决方案21】:
                          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));
                              };
                          

                          用法:

                          1. "123".padLeft(2) 返回:"123"
                          2. "12".padLeft(2) 返回:"12"
                          3. "1".padLeft(2) 返回:"01"

                          【讨论】:

                            【解决方案22】:

                            包括所有选项

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

                            【讨论】:

                              【解决方案23】:

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

                              1. 多字符键盘支持。
                              2. 不要截断输入字符串
                              3. 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 );
                              });
                              

                              【讨论】:

                                【解决方案24】:

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

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

                                【讨论】:

                                  【解决方案25】:

                                  我喜欢这样做,以防您需要填充多个字符或标签(例如&amp;nbsp;)以进行显示:

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

                                  【讨论】:

                                    【解决方案26】:

                                    我将上述解决方案的组合添加到我自己的、不断发展的版本中 :)

                                    //in preperation for ES6
                                    String.prototype.lpad || (String.prototype.lpad = function( length, charOptional )
                                    {
                                        if (length <= this.length) return this;
                                        return ( new Array((length||0)+1).join(String(charOptional)||' ') + (this||'') ).slice( -(length||0) );
                                    });
                                    
                                    
                                    'abc'.lpad(5,'.') == '..abc'
                                    String(5679).lpad(10,0) == '0000005679'
                                    String().lpad(4,'-') == '----' // repeat string
                                    

                                    【讨论】:

                                      【解决方案27】:

                                      如果您不介意包含实用程序库,lodash 库有 _.pad, _.padLeft and _.padRight 函数。

                                      【讨论】:

                                        【解决方案28】:

                                        我认为最好避免递归,因为它的成本很高。

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

                                        【讨论】:

                                          【解决方案29】:

                                          一位朋友询问使用 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 />"));

                                          【讨论】:

                                            【解决方案30】:

                                            有点晚了,但我想我还是可以分享一下。我发现向 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;
                                                }
                                            };
                                            

                                            【讨论】:

                                              猜你喜欢
                                              • 2010-11-19
                                              • 1970-01-01
                                              • 2011-08-07
                                              • 1970-01-01
                                              • 1970-01-01
                                              • 1970-01-01
                                              • 2021-11-30
                                              • 1970-01-01
                                              • 1970-01-01
                                              相关资源
                                              最近更新 更多