Potrzebuję funkcji JavaScript, która może przyjąć wartość i dopełnić ją do określonej długości (potrzebuję spacji, ale wszystko by zrobiło). Znalazłem to:

Kod:

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

Przykład:

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

Ale nie mam pojęcia, co do cholery robi i wydaje mi się, że to nie działa.

Znalazłem to rozwiązanie tutaj i jest to dla mnie znacznie prostsze:

var n = 123

String("00000" + n).slice(-5); // returns 00123
("00000" + n).slice(-5); // returns 00123
("     " + n).slice(-5); // returns "  123" (with two spaces)

I tutaj zrobiłem rozszerzenie do obiektu string:

String.prototype.paddingLeft = function (paddingValue) {
   return String(paddingValue + this).slice(-paddingValue.length);
};

Przykład użycia:

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

Zwróci czas w formacie „15:30”

Szybsza metoda

Jeśli robisz to wielokrotnie, na przykład aby uzupełnić wartości w tablicy, a wydajność jest czynnikiem, poniższe podejście może dać ci prawie 100- krotną przewagę szybkości ( jsPerf ) w porównaniu z innymi rozwiązaniami, które są obecnie omawiane w Internecie . Podstawową ideą jest to, że udostępniasz funkcję padu w pełni wypełnionym pustym ciągiem, który ma być używany jako bufor. Funkcja padu po prostu dołącza się do łańcucha, który ma zostać dodany do tego wstępnie wypełnionego łańcucha (jeden konkat łańcucha), a następnie kroi lub przycina wynik do pożądanej długości.

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

Na przykład, aby wyzerować pad do liczby o długości 10 cyfr,

pad('0000000000',123,true);

Aby wstawić ciąg znaków spacją, aby cały ciąg miał 255 znaków,

var padding = Array(256).join(' '), // make a string of 255 spaces
pad(padding,123,true);

Test wydajności

Zobacz test jsPerf tutaj .

Jest to również szybsze niż ES6 string.repeato 2x, jak pokazuje poprawiony JsPerf tutaj

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;

}

Jest o wiele bardziej czytelny.

Oto rekurencyjne podejście do tego.

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

Przykład...

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

String.prototype.padStart()i String.prototype.padEnd()są obecnie propozycjami TC39: patrz github.com/tc39/proposal-string-pad-start-end (dostępny tylko w Firefoksie od kwietnia 2016 r.; dostępny jest polifill ).

ECMAScript 2017 dodaje metodę padStart do prototypu String. Ta metoda wypełni łańcuch ze spacjami do określonej długości. Ta metoda pobiera również opcjonalny ciąg znaków, który będzie używany zamiast spacji do wypełnienia.

'abc'.padStart(10);         // "       abc"
'abc'.padStart(10, "foo");  // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
'abc'.padStart(8, "0");     // "00000abc"
'abc'.padStart(1);          // "abc"

Dodano również metodę padEnd, która działa w ten sam sposób.

W celu uzyskania zgodności z przeglądarką (i przydatnego wypełnienia) zobacz ten link .

Za pomocą metody ECMAScript 6 String # repeat funkcja pad jest tak prosta, jak:

String.prototype.padLeft = function(char, length) { 
    return char.repeat(Math.max(0, length - this.length)) + this;
}

String#repeatjest obecnie obsługiwany tylko w Firefoksie i Chrome. dla innych wdrożeń można rozważyć następującą prostą polifill:

String.prototype.repeat = String.prototype.repeat || function(n){ 
    return n<=1 ? this : (this + this.repeat(n-1)); 
}

Za pomocą metody ECMAScript 6 Ciąg # powtórz i Funkcje strzałek funkcja pad jest tak prosta, jak:

var leftPad = (s, c, n) => c.repeat(n - s.length) + s;
leftPad("foo", "0", 5); //returns "00foo"

jsfiddle

edycja: sugestia z komentarzy:

const leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;

w ten sposób nie wyrzuca błędu, gdy s.lengthjest większy niżn

edit2: sugestia z komentarzy:

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

w ten sposób możesz użyć funkcji zarówno dla łańcuchów, jak i dla łańcuchów.

Kluczową sztuczką w obu tych rozwiązaniach jest utworzenie arrayinstancji o danym rozmiarze (o jeden więcej niż pożądana długość), a następnie natychmiastowe wywołanie join()metody w celu utworzenia string. join()Sposób przepuszcza wyściółka string(miejsca prawdopodobnie). Ponieważ pole arrayjest puste, puste komórki będą renderowane jako puste stringspodczas procesu łączenia arrayw jeden wynik stringi pozostanie tylko wypełnienie. To naprawdę fajna technika.

pad z wartościami domyślnymi

Zauważyłem, że najczęściej potrzebuję padLeft do przeliczania czasu / uzupełniania liczb

więc napisałem tę funkcję

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

Ta prosta funkcja obsługuje liczbę lub ciąg znaków jako dane wejściowe

domyślny pad to 2 znaki

domyślny znak to 0

więc mogę po prostu pisać

padL(1);
// 01

jeśli dodam drugi argument (szerokość padu)

padL(1,3);
// 001

trzeci parametr (pad char)

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

EDYCJA @BananaAcid, jeśli przekażesz niezdefiniowaną wartość lub ciąg o długości 0, otrzymasz 0undefined: więc:

jak proponowano

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

ale można to również osiągnąć w krótszy sposób.

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

współpracuje również z:

padL(0)
padL(NaN)
padL('')
padL(undefined)
padL(false)

A jeśli chcesz mieć możliwość wypełniania na dwa sposoby:

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

które można zapisać w krótszy sposób bez użycia wycinka.

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 
)

*/

teraz, jeśli spróbujesz uzupełnić słowo „averylongword” 2, to nie mój problem.

Powiedział, że dam ci wskazówkę.

Przez większość czasu, jeśli padasz, robisz to dla tej samej wartości N razy.

Użycie dowolnego rodzaju funkcji w pętli spowalnia pętlę !!!

Więc jeśli chcesz po prostu zostawić kilka liczb na długiej liście, nie używaj funkcji do robienia tej prostej rzeczy.

użyj czegoś takiego:

var arrayOfNumbers=[1,2,3,4,5,6,7],
    paddedArray=[],
    len=arrayOfNumbers.length;
while(len--){
 paddedArray[len]=('0000'+arrayOfNumbers[len]).slice(-4);
}

jeśli nie wiesz, w jaki sposób maksymalny rozmiar wypełnienia oparty na liczbach w tablicy.

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

W ES8 dostępne są dwie opcje wypełnienia.

Możesz to sprawdzić w dokumentacji.

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

Podejście do pomysłów Samuela, tutaj w górę. I pamiętaj stary skrypt SQL, próbowałem z tym:

a=1234;
'0000'.slice(a.toString().length)+a;

Działa we wszystkich przypadkach, jakie mogłem sobie wyobrazić:

a=     1 result  0001
a=    12 result  0012
a=   123 result  0123
a=  1234 result  1234
a= 12345 result 12345
a=  '12' result  0012

łańcuch wypełniający został dodany w nowej wersji javascript.

str.padStart(targetLength [, padString])

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart

Jeśli chcesz mieć własną funkcję, sprawdź ten przykład:

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

Oto prosta funkcja, której używam.

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

Na przykład:

pad    (20,'     ');    //   20
pad   (321,'     ');    //  321
pad (12345,'     ');    //12345
pad (   15,'00000');    //00015
pad (  999,'*****');    //**999
pad ('cat','_____');    //__cat  

Krótka droga:

(x=>(new Array(int-x.length+1)).join(char)+x)(String)

Przykład:

(x=>(new Array(6-x.length+1)).join("0")+x)("1234")

return: „001234”

es7 to teraz tylko szkice i propozycje, ale jeśli chcesz śledzić zgodność ze specyfikacją, funkcje pada wymagają:

1. Obsługa padów wieloznakowych.
2. Nie obcinaj ciągu wejściowego
3. Domyślnie pad jest spacją

Z mojej biblioteki polyfill, ale zastosuj swoją własną należytą staranność w odniesieniu do rozszerzeń prototypów.

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

Oto prosta odpowiedź w zasadzie w jednym wierszu kodu.

var value = 35 // the numerical value
var x = 5 // the minimum length of the string

var padded = ("00000" + value).substr(-x);

Upewnij się, że liczba znaków w twoim wypełnieniu, tutaj zer, jest co najmniej taka, jak zamierzona minimalna długość. Tak naprawdę, umieszczenie go w jednej linii, aby uzyskać wynik „00035” w tym przypadku to:

var padded = ("00000" + 35).substr(-5);

Manipulacje tablicami są bardzo powolne w porównaniu do prostego ciągu łańcuchowego. Oczywiście benchmark dla twojego przypadku użycia.

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

Wariant odpowiedzi @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;
};

Na przykład:

mask('00000', 11  );   // '00011'
mask('00011','00' );   // '00000'
mask( 2     , 3   );   // '3'
mask('0'    ,'111');   // '1'
mask('fork' ,'***');   // 'f***'
mask('_____','dog');   // '__dog'

Jest rok 2014 i sugeruję funkcję dopełniania napisów Javascript. Ha!

Gołe kości: prawa podkładka ze spacjami

function pad ( str, length ) {
    var padding = ( new Array( Math.max( length - str.length + 1, 0 ) ) ).join( " " );
    return str + padding;
}

Fantazyjne: podkładka z opcjami

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

Zastosowanie (fantazyjne):

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"

Jeśli nie masz nic przeciwko dołączeniu biblioteki narzędziowej, biblioteka Lodash ma funkcje _.pad, _.padLeft i _.padRight .

Myślę, że lepiej unikać rekurencji, ponieważ jest to kosztowne.

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

Oto funkcja JavaScript, która dodaje określoną liczbę wypełnień z niestandardowym symble. funkcja przyjmuje trzy parametry.

    padMe -> ciąg znaków lub liczba do lewej wkładki
    pady -> liczba padów
    padSymble -> niestandardowy symble, domyślnie „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());
    }

/ * Oto kilka wyników:

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

A potem możesz zrobić:

alert( "3".pad("0", 3) ); //shows "003"
alert( "hi".pad(" ", 3) ); //shows " hi"
alert( "hi".pad(" ", 3, true) ); //shows "hi "

Jeśli chcesz tylko bardzo prostą, wyszywaną wkładką do wypełnienia, po prostu ułóż ciąg pożądanego charakteru wypełnienia o pożądanej maksymalnej długości wypełnienia, a następnie podciągnij go do długości tego, co chcesz wypełnić.

Przykład: wypełnienie magazynu ciągów espacjami o długości do 25 znaków.

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

Wynik: "hello "

Jeśli chcesz zrobić to samo z liczbą jako wejściem, po prostu zadzwoń .toString()na nią wcześniej.

jeszcze jedno podejście z kombinacją kilku rozwiązań

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

Znajomy zapytał o użycie funkcji JavaScript do padnięcia w lewo. To stało się trochę staraniem między niektórymi z nas na czacie, aby kodować golfa. To był wynik:

function l(p,t,v){
    v+="";return v.length>=t?v:l(p,t,p+v); 
}

Zapewnia, że ​​wartość do uzupełnienia jest łańcuchem, a następnie, jeśli nie jest ona długością całkowitej pożądanej długości, wstawi ją raz, a następnie powtórzy. Oto jak to wygląda z bardziej logiczną nazwą i strukturą

function padLeft(pad, totalLength, value){
    value = value.toString();

    if( value.length >= totalLength ){
        return value;
    }else{
        return padLeft(pad, totalLength, pad + value);
    }
}

Przykład, którego używaliśmy, to dopilnowanie, aby liczby były 0uzupełnione po lewej stronie, aby uzyskać maksymalną długość 6. Oto przykładowy zestaw:

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

Trochę późno, ale pomyślałem, że i tak mogę się podzielić. Przydało mi się dodanie prototypowego rozszerzenia do Object. W ten sposób mogę wprowadzać liczby i ciągi znaków, w lewo lub w prawo. Mam moduł z podobnymi narzędziami, które włączam do swoich skryptów.

// 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. Nigdy nie wstawiaj gdzieś danych (szczególnie nie na początku, np. str = pad + str;), Ponieważ dane będą każdorazowo ponownie przydzielane. Dołącz zawsze na końcu!
2. Nie wkładaj nici do pętli. Zostaw to w spokoju i najpierw zbuduj łańcuch pada. Na koniec połącz to z głównym ciągiem.
3. Nie przypisuj za każdym razem łańcucha dopełniającego (jak str += pad;). Znacznie szybsze jest dołączanie łańcucha dopełniania do siebie i wyodrębnianie pierwszych znaków X (parser może to zrobić skutecznie, jeśli wyodrębnisz go z pierwszego znaku). Jest to wzrost wykładniczy, co oznacza, że ​​tymczasowo marnuje trochę pamięci (nie powinieneś tego robić z bardzo dużymi tekstami).

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

Oto moje zdanie

Nie jestem pewien co do jego wydajności, ale uważam ją za bardziej czytelną niż inne opcje, które widziałem tutaj ...

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