Ich benötige eine JavaScript-Funktion, die einen Wert annehmen und auf eine bestimmte Länge auffüllen kann (ich benötige Leerzeichen, aber alles würde funktionieren). Ich habe das gefunden:

Code:

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

Beispiel:

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

Aber ich habe keine Ahnung, was zum Teufel es tut und es scheint nicht für mich zu funktionieren.

Ich habe diese Lösung hier gefunden und das ist für mich viel einfacher:

var n = 123

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

Und hier habe ich das String-Objekt erweitert:

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

Ein Beispiel, um es zu verwenden:

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

Dies gibt eine Zeit im Format "15:30" zurück.

Eine schnellere Methode

Wenn Sie dies immer wieder tun, zum Beispiel Pad - Werte in einem Array, und die Leistung ist ein Faktor, kann der folgende Ansatz , den Sie gibt fast einen 100x Vorteil in der Geschwindigkeit ( jsPerf ) über andere Lösung , die derzeit auf den Zwischenstegen diskutiert werden. Die Grundidee ist, dass Sie der Pad-Funktion eine vollständig aufgefüllte leere Zeichenfolge zur Verfügung stellen, die als Puffer verwendet werden kann. Die Pad-Funktion hängt nur an die Zeichenfolge an, die zu dieser vorgepolsterten Zeichenfolge hinzugefügt werden soll (eine Zeichenfolge concat), und schneidet oder schneidet das Ergebnis dann auf die gewünschte Länge.

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

Wenn Sie beispielsweise eine Zahl mit einer Länge von 10 Ziffern auf Null setzen möchten,

pad('0000000000',123,true);

Um eine Zeichenfolge mit Leerzeichen aufzufüllen, sodass die gesamte Zeichenfolge 255 Zeichen umfasst,

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

Leistungstest

Sehen Sie hier den jsPerf- Test .

Und das ist auch string.repeat2x schneller als ES6 , wie der überarbeitete JsPerf hier zeigt

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;

}

Es ist viel besser lesbar.

Hier ist ein rekursiver Ansatz.

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

Ein Beispiel...

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

String.prototype.padStart()und String.prototype.padEnd()sind derzeit Vorschläge für TC39-Kandidaten: siehe github.com/tc39/proposal-string-pad-start-end (nur in Firefox ab April 2016 verfügbar ; eine Polyfüllung ist verfügbar).

ECMAScript 2017 fügt dem String-Prototyp eine padStart-Methode hinzu. Diese Methode füllt eine Zeichenfolge mit Leerzeichen auf eine bestimmte Länge auf. Diese Methode verwendet auch eine optionale Zeichenfolge, die anstelle von Leerzeichen zum Auffüllen verwendet wird.

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

Es wurde auch eine padEnd-Methode hinzugefügt, die auf die gleiche Weise funktioniert.

Informationen zur Browserkompatibilität (und einer nützlichen Polyfüllung) finden Sie unter diesem Link .

Mit der ECMAScript 6-Methode String # repeat ist eine Pad-Funktion so einfach wie:

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

String#repeatwird derzeit nur in Firefox und Chrome unterstützt. Für eine andere Implementierung könnte man die folgende einfache Polyfüllung in Betracht ziehen:

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

Mit der ECMAScript 6-Methode String # repeat und Arrow ist eine Pad-Funktion so einfach wie:

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

jsfiddle

bearbeiten: Vorschlag aus den Kommentaren:

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

Auf diese Weise wird kein Fehler ausgegeben, wenn er s.lengthgrößer als istn

edit2: Vorschlag aus den Kommentaren:

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

Auf diese Weise können Sie die Funktion sowohl für Zeichenfolgen als auch für Nicht-Zeichenfolgen verwenden.

Der wichtigste Trick bei beiden Lösungen besteht darin, eine arrayInstanz mit einer bestimmten Größe (eine mehr als die gewünschte Länge) zu erstellen und dann sofort die join()Methode zum Erstellen einer Instanz aufzurufen string. Der join()Methode wird die Auffüllung übergeben string(Leerzeichen wahrscheinlich). Da das arrayleer ist, werden die leeren Zellen stringswährend des Zusammenfügens arrayzu einem Ergebnis als leer gerendert string, und es bleibt nur die Auffüllung übrig. Es ist eine wirklich schöne Technik.

Pad mit Standardwerten

Mir ist aufgefallen, dass ich das padLeft hauptsächlich für die Zeitumrechnung / das Auffüllen von Zahlen benötige

Also habe ich diese Funktion geschrieben

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

Diese einfache Funktion unterstützt Number oder String als Eingabe

Standard-Pad ist 2 Zeichen

Standardzeichen ist 0

so kann ich einfach schreiben

padL(1);
// 01

wenn ich das zweite Argument hinzufüge (Padbreite)

padL(1,3);
// 001

dritter Parameter (Pad Char)

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

EDIT @BananaAcid Wenn Sie einen undefinierten Wert oder eine Zeichenfolge mit der Länge 0 übergeben, erhalten Sie 0undefined..so:

wie vorgeschlagen

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

Dies kann aber auch kürzer erreicht werden.

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

funktioniert auch mit:

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

Und wenn Sie in der Lage sein möchten, auf beide Arten zu polstern:

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

die kürzer geschrieben werden kann, ohne Slice zu verwenden.

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 
)

*/

Wenn Sie nun versuchen, 'Averylongword' mit 2 zu füllen, ist das nicht mein Problem.

Sagte, dass ich dir einen Tipp gebe.

Wenn Sie auffüllen, tun Sie dies meistens N-mal für denselben Wert.

Die Verwendung einer beliebigen Funktion innerhalb einer Schleife verlangsamt die Schleife !!!

Wenn Sie also nur einige Zahlen in einer langen Liste belassen möchten, verwenden Sie keine Funktionen, um diese einfache Sache zu erledigen.

benutze so etwas:

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

Wenn Sie nicht wissen, wie die maximale Auffüllgröße auf den Zahlen im Array basiert.

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

Mit ES8 gibt es zwei Möglichkeiten zum Auffüllen.

Sie können sie in der Dokumentation überprüfen.

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

Hier werden Samuels Ideen aufgegriffen. Und erinnere dich an ein altes SQL-Skript, das ich damit versucht habe:

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

Es funktioniert in allen Fällen, die ich mir vorstellen kann:

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

Die Füllzeichenfolge wurde in der neuen Javascript-Version implementiert.

str.padStart(targetLength [, padString])

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

Wenn Sie eine eigene Funktion wünschen, überprüfen Sie dieses Beispiel:

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

Hier ist eine einfache Funktion, die ich benutze.

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

Beispielsweise:

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

Ein kurzer Weg:

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

Beispiel:

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

Rückgabe: "001234"

es7 ist im Moment nur ein Entwurf und ein Vorschlag, aber wenn Sie die Kompatibilität mit der Spezifikation verfolgen möchten , benötigen Ihre Pad-Funktionen:

1. Unterstützung für mehrere Zeichen.
2. Schneiden Sie die Eingabezeichenfolge nicht ab
3. Das Pad ist standardmäßig auf Leerzeichen eingestellt

Aus meiner Polyfill-Bibliothek, aber wenden Sie Ihre eigene Due Diligence für Prototypenerweiterungen an.

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

Hier ist eine einfache Antwort in einer Codezeile.

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

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

Stellen Sie sicher, dass die Anzahl der Zeichen in Ihrem Abstand, hier Nullen, mindestens so hoch ist wie die beabsichtigte Mindestlänge. Um es in eine Zeile zu bringen und in diesem Fall ein Ergebnis von "00035" zu erhalten, gilt Folgendes:

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

Array-Manipulationen sind im Vergleich zu einfachen String-Concat sehr langsam. Natürlich Benchmark für Ihren Anwendungsfall.

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

Eine Variante der Antwort von @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;
};

Beispielsweise:

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

Es ist 2014 und ich schlage eine Javascript-Funktion zum Auffüllen von Zeichenfolgen vor. Ha!

Nackte Knochen: Rechtspolster mit Leerzeichen

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

Phantasie: Pad mit Optionen

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

Verwendung (Phantasie):

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"

Wenn es Ihnen nichts ausmacht, eine Dienstprogrammbibliothek einzuschließen, verfügt die lodash- Bibliothek über die Funktionen _.pad, _.padLeft und _.padRight .

Ich denke, es ist besser, eine Rekursion zu vermeiden, weil es teuer ist.

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

Hier ist eine JavaScript-Funktion, die eine bestimmte Anzahl von Auffüllungen mit benutzerdefiniertem Symble hinzufügt. Die Funktion akzeptiert drei Parameter.

    padMe -> Zeichenfolge oder Nummer zum linken Pad
    Pads -> Anzahl der Pads
    padSymble -> benutzerdefiniertes Symble, Standard ist "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());
    }

/ * Hier einige Ergebnisse:

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

Und dann können Sie tun:

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

Wenn Sie nur einen sehr einfachen, hackigen Einzeiler zum Auffüllen benötigen, erstellen Sie einfach eine Zeichenfolge mit dem gewünschten Auffüllcharakter der gewünschten maximalen Auffülllänge und teilen Sie sie dann auf die Länge des gewünschten Auffüllens auf.

Beispiel: Auffüllen des Zeichenfolgenspeichers emit Leerzeichen bis zu 25 Zeichen.

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

Ergebnis: "hello "

Wenn Sie dasselbe mit einer Nummer als Eingabe tun möchten, rufen Sie .toString()sie einfach vorher an.

Noch eine Einstellung mit der Kombination einiger Lösungen

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

Ein Freund fragte nach der Verwendung einer JavaScript-Funktion, um links aufzufüllen. Es wurde zu einem kleinen Unterfangen zwischen einigen von uns im Chat, Golf zu spielen. Dies war das Ergebnis:

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

Es stellt sicher, dass der aufzufüllende Wert eine Zeichenfolge ist. Wenn er nicht der Länge der gewünschten Gesamtlänge entspricht, wird er einmal aufgefüllt und dann wiederholt. So sieht es mit logischerer Benennung und Struktur aus

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

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

Das Beispiel, das wir verwendet haben, war sicherzustellen, dass die Zahlen 0links aufgefüllt wurden , um eine maximale Länge von 6 zu erreichen. Hier ein Beispielsatz:

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

Ein bisschen spät, dachte aber, ich könnte es trotzdem teilen. Ich fand es nützlich, Object eine Prototyp-Erweiterung hinzuzufügen. Auf diese Weise kann ich links und rechts Zahlen und Zeichenfolgen auffüllen. Ich habe ein Modul mit ähnlichen Dienstprogrammen, die ich in meine Skripte einbinde.

// 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. str = pad + str;Fügen Sie niemals irgendwo Daten ein (insbesondere nicht am Anfang, wie ), da die Daten jedes Mal neu zugewiesen werden. Immer am Ende anhängen!
2. Füllen Sie Ihre Saite nicht in die Schleife. Lass es in Ruhe und baue zuerst deine Pad-Saite. Am Ende verketten Sie es mit Ihrer Hauptzeichenfolge.
3. Weisen Sie nicht jedes Mal eine Füllzeichenfolge zu (wie str += pad;). Es ist viel schneller, die Füllzeichenfolge an sich selbst anzuhängen und die ersten x-Zeichen zu extrahieren (der Parser kann dies effizient ausführen, wenn Sie aus dem ersten Zeichen extrahieren). Dies ist ein exponentielles Wachstum, was bedeutet, dass vorübergehend Speicherplatz verschwendet wird (Sie sollten dies nicht mit extrem großen Texten tun).

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

Hier ist meine Einstellung

Ich bin mir über die Leistung nicht so sicher, aber ich finde es viel besser lesbar als andere Optionen, die ich hier gesehen habe ...

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