Saya membutuhkan fungsi JavaScript yang dapat mengambil nilai dan membatasinya sampai batas tertentu (saya perlu spasi, tapi apa pun bisa dilakukan). Aku menemukan ini:

Kode:

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

Contoh:

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

Tapi saya tidak tahu apa yang sedang dilakukan dan sepertinya tidak berhasil untuk saya.

Saya menemukan solusi ini di sini dan ini bagi saya jauh lebih sederhana:

var n = 123

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

Dan di sini saya membuat ekstensi ke objek string:

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

Contoh untuk menggunakannya:

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

Ini akan mengembalikan waktu dalam format "15:30"

Metode yang lebih cepat

Jika Anda melakukan ini berulang kali, misalnya untuk menambahkan nilai dalam array, dan kinerja adalah faktor, pendekatan berikut ini dapat memberi Anda hampir 100x keunggulan dalam kecepatan ( jsPerf ) dibandingkan solusi lain yang saat ini dibahas di web antar. Ide dasarnya adalah bahwa Anda menyediakan fungsi pad dengan string kosong penuh untuk digunakan sebagai buffer. Fungsi pad hanya menambahkan string yang akan ditambahkan ke string pra-empuk ini (satu string concat) dan kemudian mengiris atau memangkas hasilnya dengan panjang yang diinginkan.

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

Misalnya, untuk nol pad nomor dengan panjang 10 digit,

pad('0000000000',123,true);

Untuk mengisi string dengan spasi, sehingga seluruh string adalah 255 karakter,

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

Uji kinerja

Lihat tes jsPerf di sini .

Dan ini lebih cepat dari ES6 string.repeat2x juga, seperti yang ditunjukkan oleh JsPerf yang direvisi di sini

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;

}

Ini jauh lebih mudah dibaca.

Inilah pendekatan rekursif untuk itu.

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

Sebuah contoh...

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

String.prototype.padStart()dan String.prototype.padEnd()saat ini adalah proposal kandidat TC39: lihat github.com/tc39/proposal-string-pad-start-end (hanya tersedia di Firefox pada April 2016; polyfill tersedia).

ECMAScript 2017 menambahkan metode padStart ke prototipe String. Metode ini akan mengisi string dengan spasi hingga panjang tertentu. Metode ini juga mengambil string opsional yang akan digunakan alih-alih ruang untuk pengisi.

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

Metode padEnd juga ditambahkan yang bekerja dengan cara yang sama.

Untuk kompatibilitas browser (dan polyfill yang berguna) lihat tautan ini .

Menggunakan metode ECMAScript 6 metode String # repeat , fungsi pad semudah:

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

String#repeatsaat ini hanya didukung di Firefox dan Chrome. untuk implementasi lain, seseorang dapat mempertimbangkan polyfill sederhana berikut:

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

Menggunakan metode ECMAScript 6 fungsi String # repeat dan Arrow , fungsi pad sesederhana:

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

jsfiddle

sunting: saran dari komentar:

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

dengan cara ini, ia tidak akan melempar kesalahan ketika s.lengthlebih besar darin

sunting2: saran dari komentar:

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

dengan cara ini, Anda dapat menggunakan fungsi untuk string dan non-string.

Trik kunci dalam kedua solusi tersebut adalah membuat arrayinstance dengan ukuran yang diberikan (satu lebih dari panjang yang diinginkan), dan kemudian segera memanggil join()metode untuk membuat a string. The join()Metode dilewatkan padding string(spasi mungkin). Karena arraykosong, sel-sel kosong akan dirender sebagai kosong stringsselama proses bergabung arraymenjadi satu hasil string, dan hanya bantalan yang akan tetap. Ini teknik yang sangat bagus.

pad dengan nilai default

Saya perhatikan bahwa saya sebagian besar memerlukan padLeft untuk konversi waktu / nomor padding

jadi saya menulis fungsi ini

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

Fungsi sederhana ini mendukung Angka atau String sebagai input

pad default adalah 2 karakter

karakter default adalah 0

jadi saya bisa menulis

padL(1);
// 01

jika saya menambahkan argumen kedua (lebar pad)

padL(1,3);
// 001

parameter ketiga (pad char)

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

EDIT @BananaAcid jika Anda memberikan nilai yang tidak ditentukan atau string 0 panjang yang Anda dapatkan 0undefined..so:

seperti yang disarankan

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

tetapi ini juga bisa dicapai dengan cara yang lebih singkat.

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

bekerja juga dengan:

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

Dan jika Anda ingin dapat menggunakan keduanya:

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

yang dapat ditulis dengan cara yang lebih singkat tanpa menggunakan slice.

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 
)

*/

sekarang jika Anda mencoba untuk pad 'averylongword' dengan 2 ... itu bukan masalah saya.

Mengatakan bahwa saya memberi Anda tip.

Sebagian besar waktu jika Anda pad Anda melakukannya untuk nilai yang sama N kali.

Menggunakan semua jenis fungsi di dalam sebuah loop memperlambat loop !!!

Jadi jika Anda hanya ingin memasukkan beberapa angka di dalam daftar yang panjang jangan gunakan fungsi untuk melakukan hal sederhana ini.

gunakan sesuatu seperti ini:

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

jika Anda tidak tahu bagaimana ukuran bantalan maksimum berdasarkan angka-angka di dalam array.

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

Dengan ES8, ada dua opsi untuk bantalan.

Anda dapat memeriksanya di dokumentasi.

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

Mengambil ide-ide Samuel, naik ke sini. Dan ingat skrip SQL lama, saya coba dengan ini:

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

Ini berfungsi dalam semua kasus yang dapat saya bayangkan:

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

string padding telah diterapkan dalam versi javascript baru.

str.padStart(targetLength [, padString])

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

Jika Anda ingin fungsi Anda sendiri, periksa contoh ini:

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

Inilah fungsi sederhana yang saya gunakan.

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

Sebagai contoh:

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

Cara singkat:

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

Contoh:

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

kembali: "001234"

es7 hanyalah draft dan proposal saat ini, tetapi jika Anda ingin melacak kompatibilitas dengan spec, fungsi pad Anda perlu:

1. Dukungan pad multi-karakter.
2. Jangan memotong string input
3. Pad standar ke angkasa

Dari perpustakaan polyfill saya, tetapi terapkan uji tuntas Anda sendiri untuk ekstensi prototipe.

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

Inilah jawaban sederhana pada dasarnya satu baris kode.

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

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

Pastikan jumlah karakter dalam padding Anda, nol di sini, setidaknya sebanyak panjang minimum yang Anda inginkan. Jadi sungguh, untuk membuatnya menjadi satu baris, untuk mendapatkan hasil "00035" dalam kasus ini adalah:

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

Manipulasi array sangat lambat dibandingkan dengan string concat sederhana. Tentu saja, patokan untuk kasus penggunaan Anda.

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

Varian dari jawaban @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;
};

Sebagai contoh:

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

Ini tahun 2014, dan saya menyarankan fungsi string-padding Javascript. Ha!

Bare-tulang: bantalan kanan dengan spasi

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

Fancy: pad dengan opsi

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

Penggunaan (mewah):

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"

Jika Anda tidak keberatan menyertakan perpustakaan utilitas, perpustakaan lodash memiliki fungsi _.pad, _.padLeft dan _.padRight .

Saya pikir lebih baik menghindari rekursi karena mahal.

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

Ini adalah fungsi JavaScript yang menambahkan jumlah bantalan tertentu dengan symble khusus. fungsi ini mengambil tiga parameter.

    padMe -> string atau angka ke pad kiri
    bantalan -> jumlah bantalan
    padSymble -> custom symble, standarnya adalah "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());
    }

/ * Berikut adalah beberapa hasil:

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

Dan kemudian Anda dapat melakukan:

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

Jika Anda hanya ingin pad satu-liner yang sangat simpel untuk pad, buat saja string karakter padding yang diinginkan dari panjang max padding yang diinginkan dan kemudian substring ke panjang apa yang ingin Anda pad.

Contoh: mengisi string store edengan spasi hingga 25 karakter.

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

Hasil: "hello "

Jika Anda ingin melakukan hal yang sama dengan nomor sebagai input panggil .toString()saja sebelumnya.

namun lain mengambil kombinasi dari beberapa solusi

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

Seorang teman bertanya tentang menggunakan fungsi JavaScript untuk menulis di sebelah kiri. Itu berubah menjadi sedikit usaha antara kami dalam obrolan untuk kode golf itu. Ini hasilnya:

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

Ini memastikan bahwa nilai yang akan empuk adalah string, dan kemudian jika bukan panjang total panjang yang diinginkan itu akan pad itu sekali dan kemudian muncul kembali. Berikut ini tampilannya dengan penamaan dan struktur yang lebih logis

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

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

Contoh yang kami gunakan adalah untuk memastikan bahwa angka-angka diisi dengan 0ke kiri untuk membuat panjang maksimal 6. Berikut adalah contoh yang ditetapkan:

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

Sedikit terlambat, tetapi tetap berpikir saya mungkin akan berbagi. Saya merasa berguna untuk menambahkan ekstensi prototipe ke Object. Dengan begitu saya bisa memasukkan angka dan string, kiri atau kanan. Saya memiliki modul dengan utilitas serupa yang saya sertakan dalam skrip saya.

// 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. Jangan pernah memasukkan data di suatu tempat (terutama tidak di awal, seperti str = pad + str;), karena data akan dialokasikan kembali setiap kali. Tambahkan selalu di akhir!
2. Jangan letakkan tali Anda di loop. Biarkan saja dan bangun string pad Anda terlebih dahulu. Pada akhirnya gabungkan dengan string utama Anda.
3. Jangan berikan string padding setiap kali (seperti str += pad;). Jauh lebih cepat untuk menambahkan string padding ke dirinya sendiri dan mengekstrak x-chars pertama (parser dapat melakukan ini secara efisien jika Anda mengekstrak dari char pertama). Ini adalah pertumbuhan eksponensial, yang berarti ia membuang beberapa memori untuk sementara waktu (Anda tidak harus melakukan ini dengan teks yang sangat besar).

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

Inilah pendapat saya

Saya tidak begitu yakin tentang kinerjanya, tapi saya merasa itu lebih mudah dibaca daripada opsi lain yang saya lihat di sini ...

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