Ben bir değer alıp verilen bir uzunluğa pad (bir boşluk gerekir, ama her şey yaparım) bir JavaScript işlevine ihtiyacım var. Bunu buldum:

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

Misal:

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

Ama ne halt yaptığını bilmiyorum ve bu benim için işe yaramıyor gibi görünüyor.

Bu çözümü burada buldum ve bu benim için çok daha basit:

var n = 123

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

Ve burada dize nesnesine bir uzantı yaptım:

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

Kullanmak için bir örnek:

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

Bu, "15:30" biçiminde bir zaman döndürür

Daha hızlı bir yöntem

Bunu tekrarlı olarak yapıyorsanız, örneğin bir dizideki değerleri doldurmak ve performans bir faktörse , aşağıdaki yaklaşım, webler arasında tartışılan diğer çözümlere göre yaklaşık 100 kat daha hızlı bir avantaj sağlayabilir ( jsPerf ). Temel fikir, tampon işlevine tampon olarak kullanmak için tamamen dolgulu boş bir dize sağlamanızdır. Pad işlevi, bu önceden doldurulmuş dizeye eklenecek dizgiye eklenir (bir dizgi concat) ve ardından sonucu istenen uzunluğa göre keser veya düzeltir.

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

Örneğin, bir sayıyı 10 basamak uzunluğunda sıfırlamak için,

pad('0000000000',123,true);

Bir dizeyi boşlukla doldurmak için dizenin tamamı 255 karakterdir,

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

Performans testi

Burada jsPerf testine bakın .

Ve bu hızlı ES6 daha string.repeatrevize JsPerf ile gösterildiği gibi, 2x sıra burada

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;

}

Çok daha okunabilir.

İşte özyinelemeli bir yaklaşım.

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

Bir örnek...

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

String.prototype.padStart()ve String.prototype.padEnd()şu anda TC39 aday önerileri şunlardır: bkz github.com/tc39/proposal-string-pad-start-end (Nisan 2016 tarihinden itibaren Firefox'ta sadece; bir polyfill mevcuttur).

ECMAScript 2017, String prototipine bir padStart yöntemi ekler. Bu yöntem, boşlukları olan bir dizeyi belirli bir uzunlukta doldurur. Bu yöntem, dolgu için boşluklar yerine kullanılacak isteğe bağlı bir dize de alır.

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

Aynı şekilde çalışan bir padEnd yöntemi de eklendi.

Tarayıcı uyumluluğu (ve kullanışlı bir çoklu dolgu) için bu bağlantıya bakın .

ECMAScript 6 yöntemi olan String # repeat yöntemini kullanarak , bir pad işlevi aşağıdaki kadar basittir:

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

String#repeatşu anda yalnızca Firefox ve Chrome'da desteklenmektedir. diğer uygulamalar için, aşağıdaki basit çoklu dolgular düşünülebilir:

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

ECMAScript 6 yöntemi String # repeat ve Arrow işlevlerini kullanarak , bir pad işlevi aşağıdaki kadar basittir:

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

jsfiddle

edit: yorumlardan öneri:

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

bu şekilde, s.lengthdaha büyük olduğunda bir hata atmazn

edit2: yorumlardan öneri:

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

bu şekilde, dizeler ve dizeler olmayanlar için bu işlevi kullanabilirsiniz.

Bu çözümlerin her ikisinde de önemli arrayolan, belirli bir boyuta (istenen uzunluktan bir tane daha fazla) sahip bir örnek oluşturmak ve hemen join()a string. join()Yöntem, dolgu geçirilir string(muhtemelen boşluk). arrayBoş olduğu için , boş hücreler bir sonuca stringskatılma işlemi sırasında boş olarak işlenir ve sadece dolgu kalır. Gerçekten güzel bir teknik.arraystring

varsayılan değerlere sahip ped

Çoğunlukla zaman dönüşümü / sayı dolgusu için padLeft'e ihtiyacım olduğunu fark ettim

bu yüzden bu işlevi yazdım

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

Bu basit işlev Sayı veya Dize'yi destekler giriş olarak

varsayılan ped 2 karakterdir

varsayılan karakter 0

bu yüzden yazabilirim

padL(1);
// 01

ikinci argümanı eklersem (ped genişliği)

padL(1,3);
// 001

üçüncü parametre (pad char)

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

Tanımsız bir değer veya 0 uzunluklu bir dize iletirseniz @BananaAcid DÜZENLE ..so 0undefined:

önerildiği gibi

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

ancak bu daha kısa bir yolla da gerçekleştirilebilir.

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

şunlarla da çalışır:

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

Ve her iki şekilde de ped yapabilmek istiyorsanız:

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

dilimi kullanmadan daha kısa bir şekilde yazılabilir.

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 
)

*/

şimdi eğer 'averylongword' 2 ile pad denerseniz ... bu benim sorunum değil.

Sana bir ipucu verdiğimi söyledi.

Çoğu zaman ped yaparsanız aynı değeri N kez yaparsınız.

Bir döngü içinde herhangi bir fonksiyonun kullanılması döngüyü yavaşlatır !!!

Yani sadece uzun bir liste içinde bazı sayılar bırakmak istiyorsanız bu basit şeyi yapmak için fonksiyonları kullanmayın.

böyle bir şey kullan:

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

dizinin içindeki sayılara göre maksimum dolgu boyutunun nasıl olduğunu bilmiyorsanız.

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 ile dolgu için iki seçenek vardır.

Bunları belgelerden kontrol edebilirsiniz.

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

Samuel'in düşüncelerini burada üst üste almak. Ve eski bir SQL komut dosyası hatırlıyorum, bununla denedim:

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

Hayal edebileceğim tüm durumlarda işe yarıyor:

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

dolgu dizesi yeni javascript sürümünde eklenmiştir.

str.padStart(targetLength [, padString])

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

Kendi işlevinizi istiyorsanız bu örneği kontrol edin:

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

İşte benim kullandığım basit bir işlev.

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

Örneğin:

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

Kısa bir yol:

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

Misal:

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

dönüş: "001234"

es7 şu anda sadece taslaklar ve teklifler, ancak spesifikasyonla uyumluluğu izlemek istiyorsanız, pad işlevlerinizin aşağıdakilere ihtiyacı vardır:

1. Çok karakterli ped desteği.
2. Giriş dizesini kısaltmayın
3. Pad varsayılan olarak boşluktur

Çoklu doldurma kitaplığımdan, ancak prototip uzantıları için gereken özeni gösterin.

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

Temel olarak bir kod satırında basit bir cevap.

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

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

Doldurma işleminizdeki karakter sayısının, burada sıfırların, en azından istediğiniz minimum uzunluk kadar olduğundan emin olun. Yani gerçekten, tek bir satıra koymak, bu durumda "00035" bir sonucu elde etmek için:

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

Dizi manipülasyonları basit string concat ile karşılaştırıldığında gerçekten yavaştır. Tabii ki, kullanım durumunuz için kriter.

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'ın cevabının bir çeşidi .

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

Örneğin:

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

Bu 2014 ve bir Javascript dize doldurma işlevi öneririm. Ha!

Çıplak kemikler: boşluklu sağ yastık

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

Süslü: seçenekli ped

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

Kullanımı (fantezi):

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"

Yardımcı program kitaplığı eklemenin bir sakıncası yoksa, Lodash kitaplığında _.pad, _.padLeft ve _.padRight işlevleri bulunur.

Ben pahalı çünkü özyineleme önlemek için daha iyi olduğunu düşünüyorum.

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

Özel symble ile belirtilen sayıda dolgu ekleyen bir JavaScript işlevi. işlev üç parametre alır.

    padMe -> dize veya sayı sol yüzeye
    ped sayısı -> ped sayısı
    padSymble -> özel symble, varsayılan "0" dır. 

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

/ * İşte bazı sonuçlar:

> sol Tuş Takımı (1)
"1"
> solPad (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;
}

Ve sonra şunları yapabilirsiniz:

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

Sadece basit bir hacky tek astarlı ped istiyorsanız, istediğiniz maksimum dolgu uzunluğuna sahip istenen dolgu karakterinin bir dizesini yapın ve ardından ped yapmak istediğiniz şeyin uzunluğuna indirin.

Örnek: dize deposunu e25 karakter uzunluğunda boşluklarla doldurmak .

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

Sonuç: "hello "

Giriş olarak bir numara ile aynı şeyi yapmak istiyorsanız .toString(), daha önce arayın .

bir başka çözüm ise birkaç çözümün birleşimi

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

Bir arkadaş sola kaydırmak için bir JavaScript işlevi kullanmayı sordu. Biraz kod golf sohbet için bazılarımız arasında bir çaba biraz dönüştü. Sonuç buydu:

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

Doldurulacak değerin bir dize olmasını sağlar ve daha sonra istenen toplam uzunluğun uzunluğu değilse, bir kez doldurur ve sonra geri çeker. Daha mantıklı adlandırma ve yapı ile işte böyle görünüyor

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

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

Kullandığımız örnek, 0maksimum 6 uzunluğu yapmak için sayıların sola doldurulduğundan emin olmaktı . İşte bir örnek set:

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

Biraz geç, ama yine de paylaşabileceğimi düşündüm. Object için bir prototip uzantısı eklemek yararlı buldum. Bu şekilde sayıları ve karakter dizilerini sola veya sağa doldurabilirim. Komut dosyalarıma eklediğim benzer yardımcı programlara sahip bir modül var.

// 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. Verileri asla bir yere yerleştirmeyin (özellikle başlangıçta değil, gibi str = pad + str;) çünkü veriler her seferinde yeniden tahsis edilecektir. Her zaman sonuna ekleyin!
2. Dizenizi döngüye sokmayın. Yalnız bırakın ve önce pad dizenizi oluşturun. Sonunda ana dizenizle birleştirin.
3. Her seferinde dolgu dizesi atamayın (gibi str += pad;). Dolgu dizesini kendisine eklemek ve ilk x karakterlerini ayıklamak çok daha hızlıdır (ilk karakterden ayıklarsanız ayrıştırıcı bunu verimli bir şekilde yapabilir). Bu üstel bir büyümedir, yani geçici olarak bir miktar hafızayı boşa harcar (bunu son derece büyük metinlerle yapmamalısınız).

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

İşte benim almam

Performansından o kadar emin değilim, ama burada gördüğüm diğer seçeneklerden çok daha okunabilir buluyorum ...

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