Gibt es eine JavaScript-Funktion, mit der eine Zeichenfolge aufgefüllt werden kann, um eine bestimmte Länge zu erreichen?

Eine schnellere Methode

Wenn Sie dies wiederholt ausführen, um beispielsweise Werte in einem Array aufzufüllen, und die Leistung ein Faktor ist, können Sie mit der folgenden Methode einen 100-fachen Vorteil erzielen in der Geschwindigkeit ( jsPerf ) gegenüber anderen Lösungen, die derzeit auf den Zwischenwebseiten diskutiert werden. Die Grundidee ist, dass Sie die Pad-Funktion mit einer vollständig aufgefüllten leeren Zeichenfolge versehen, die als Puffer verwendet werden soll. Die Pad-Funktion hängt nur an die Zeichenfolge an, die zu dieser vorab aufgefüllten Zeichenfolge (eine Zeichenfolge concat) hinzugefügt werden soll, und schneidet oder schneidet das Ergebnis 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 10-stellige Zahl auf null setzen möchten,

pad('0000000000',123,true);

So füllen Sie eine Zeichenfolge mit Leerzeichen auf: Die gesamte Zeichenfolge besteht aus 255 Zeichen.

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

Leistungstest

Siehe den jsPerf Test hier .

Und das ist schneller als ES6 string.repeat auch 2x, wie das ü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 lesbarer.

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 Kandidaten für TC39-Kandidaten: siehe github.com/tc39/proposal-string-pad-start-end (nur in Firefox ab April 2016 verfügbar; eine polyfill ist verfügbar).

Bei Verwendung 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#repeat wird derzeit nur in Firefox und Chrome unterstützt. Für andere Implementierungen kann man die folgende einfache Polyfill in Betracht ziehen:

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

ECMAScript 2017 fügt dem String-Prototyp eine padStart-Methode hinzu. Diese Methode füllt einen String mit Leerzeichen auf eine bestimmte Länge auf. Diese Methode benötigt auch eine optionale Zeichenfolge, die anstelle von Leerzeichen für das 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"

Eine PadEnd-Methode wurde hinzugefügt, die auf dieselbe Weise funktioniert.

Zur Browserkompatibilität (und einem nützlichen Polyfill) siehe diesen Link .

Der Schlüsseltrick in diesen beiden Lösungen besteht darin, eine array-Instanz mit einer bestimmten Größe (eine mehr als die gewünschte Länge) zu erstellen und dann sofort die join()-Methode aufzurufen, um eine string zu erstellen. Die join()-Methode wird an die Auffüllung string übergeben (wahrscheinlich Leerzeichen). Da die Variable array leer ist, werden die leeren Zellen während des Prozesses des Verbindens der Variable strings in ein Ergebnis array als leere Variable string dargestellt, und es bleibt nur noch die Auffüllung. Es ist eine wirklich schöne Technik.

Bei Verwendung der ECMAScript 6-Methode String # repeat und Arrow-Funktionen ist eine Pad-Funktion so einfach wie folgt:

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

jsfiddle

edit: 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 s.length größer ist als n.

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 für Strings und Nicht-Strings gleichermaßen verwenden.

pad mit Standardwerten

Mir ist aufgefallen, dass ich meistens das padLeft zur Zeitkonvertierung/Zahlenauffüllung brauche

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

standardwert ist 0

also kann ich einfach schreiben

padL(1);
// 01

wenn ich das zweite Argument hinzufüge (Padbreite)

padL(1,3);
// 001

dritter Parameter (Pad-Zeichen)

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

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

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 auf kürzere Weise 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)
}

arbeitet auch mit:

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

Und wenn Sie in der Lage sein wollen, 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)
}

das kann kürzer geschrieben werden, 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 
)

*/

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

Sagte, dass ich dir einen Tipp gebe.

Meistens, wenn Sie auffüllen, tun Sie dies 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 eingeben möchten, verwenden Sie keine Funktionen, um diese einfache Sache auszuführen.

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 basierend auf den Zahlen im Array ist.

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

Bei ES8 gibt es zwei Optionen 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/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Nimm die Ideen von Samuel hier auf. Und erinnere mich an ein altes SQL-Skript, das ich mit diesem 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

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

Zum Beispiel:

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

die Füllzeichenfolge wurde in die neue Javascript-Version eingefügt.

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

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ückkehr: "001234"

es7 ist momentan nur Entwürfe und Vorschläge, aber wenn Sie die Kompatibilität mit der Spezifikation verfolgen möchten, benötigen Ihre Pad-Funktionen:

1. Multi-Character-Pad-Unterstützung.
2. Schneiden Sie die Eingabezeichenfolge nicht ab
3. Das Pad ist standardmäßig auf Leerzeichen eingestellt

Wenden Sie Ihre eigene Due-Diligence-Prüfung für Prototyp-Erweiterungen 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 im Wesentlichen 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 Ihrer Auffüllung, hier Nullen, mindestens so hoch ist wie Ihre beabsichtigte Mindestlänge. Um es in einer Zeile zusammenzufassen, in diesem Fall ein Ergebnis von "00035" zu erhalten, lautet:

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

Array-Manipulationen sind im Vergleich zu einfachen String-Concats sehr langsam. Natürlich Benchmark für Ihren Use Case.

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 von @Daniel LaFavers ' answer.

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

Zum Beispiel:

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: rechte Unterlage mit Leerzeichen

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

Fancy: 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"

Ich denke, es ist besser, Rekursion zu vermeiden, weil es kostspielig 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));

Wenn Sie nichts dagegen haben, eine Utility-Bibliothek hinzuzufügen, verfügt die lodash-Bibliothek über die Funktionen _.pad, _.padLeft und _.padRight .

Ein Freund fragte nach der Verwendung einer JavaScript-Funktion zum Auffüllen von Links. Es entwickelte sich zu einer kleinen Anstrengung zwischen einigen von uns im Chat, um Golf zu codieren. Das war das Ergebnis:

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

Es stellt sicher, dass der aufgefüllte Wert eine Zeichenfolge ist. Wenn es nicht die Länge der gewünschten Gesamtlänge ist, wird es einmal aufgefüllt und dann erneut aufgerufen. So sieht es mit mehr logischer 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 verwendeten, war, um sicherzustellen, dass die Zahlen mit 0 auf der linken Seite aufgefüllt wurden, um eine maximale Länge von 6 zu erreichen.

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

Hier ist eine JavaScript-Funktion, die die angegebene Anzahl von Füllungen mit benutzerdefinierten Symbolen hinzufügt. Die Funktion hat drei Parameter.

 padMe -> Zeichenfolge oder Nummer zum linken Pad 
 Pads -> Anzahl der Pads 
 padSymble -> Benutzerdefiniertes Symbol, Standardeinstellung 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" 

 */

Wenn Sie nur einen sehr einfachen, hackigen One-Liner zum Auffüllen benötigen, machen Sie einfach eine Zeichenfolge des gewünschten Auffüllzeichens mit der gewünschten maximalen Auffülllänge, und geben Sie dann die Länge der gewünschten Auffüllung an. 

Beispiel: Auffüllen des Zeichenfolgenspeichers in e mit Leerzeichen auf 25 Zeichen.

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

Ergebnis: "hello "

Wenn Sie dasselbe mit einer Nummer als Eingabe machen möchten, rufen Sie vorher .toString() auf.

Etwas spät, dachte ich könnte es trotzdem erzählen. Ich fand es nützlich, eine Prototyperweiterung zu Object hinzuzufügen. Auf diese Weise kann ich Zahlen und Zeichenfolgen links oder rechts auffüllen. Ich habe ein Modul mit ähnlichen Dienstprogrammen, die ich in meine Skripte einfüge.

// 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. Fügen Sie niemals irgendwo Daten ein (besonders nicht am Anfang, wie str = pad + str;), da die Daten jedes Mal neu zugewiesen werden. Füge immer am Ende hinzu!
2. Füllen Sie Ihre Schnur nicht in der Schleife auf. Lass es in Ruhe und erstelle deinen Pad-String. Am Ende verketten Sie es mit Ihrer Hauptzeichenfolge.
3. Weisen Sie nicht jedes Mal eine Auffüllzeichenfolge zu (wie str += pad;). Es ist viel schneller, die Auffüllzeichenfolge an sich selbst anzuhängen und die ersten X-Zeichen zu extrahieren (der Parser kann dies effizient tun, wenn Sie aus dem ersten Zeichen extrahieren). Dies ist ein exponentielles Wachstum, das bedeutet, dass vorübergehend Speicherplatz verschwendet wird (dies sollte bei extrem großen Texten nicht erfolgen).

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

/**************************************************************************************************
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 kannst du tun:

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

mit padStart 

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

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

noch ein anderer mit einer Kombination von ein paar 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
};    

Alle Optionen enthalten 

function padding(stringToBePadded, paddingCharacter, totalLength, padLeftElseRight){
    //will pad any string provided in first argument, with padding character provide in 2nd argument and truncate to lenght provided in third argument, padding left if 4th argument true or undefined, right if false. 
    // i.e. padding("lode","x","10")  -->  "xxxxxxlode"
    // i.e. padding("lode","x","10",true)  -->  "xxxxxxlode"
    // i.e. padding("lode","x","10",false)  -->  "lodexxxxxx"
    // i.e. padding("12","0","5")  -->  "00012"
    {
        padLeftElseRight = typeof padLeftElseRight !== 'undefined' ? padLeftElseRight : true;
    }
    if (stringToBePadded.length > totalLength){
        // console.log("string too long to be padded");
        return stringToBePadded;
    }
    var paddingString = paddingCharacter.repeat(totalLength);//make long string of padding characters
    if ( padLeftElseRight){
        return String(paddingString+stringToBePadded).slice(-totalLength);
    }else{ 
        return String(stringToBePadded+paddingString).slice(0,totalLength); 
    }
}

Ich mache das gerne, wenn Sie mit mehreren Zeichen oder Tags (z. B.  ) für die Anzeige auffüllen müssen:

$.padStringLeft = function(s, pad, len) {
    if(typeof s !== 'undefined') {
        var c=s.length; while(len > c) {s=pad+s;c++;}
    }
    return s;
}    

$.padStringRight = function(s, pad, len) {
    if(typeof s !== 'undefined') {
        var c=s.length; while(len > c) {s += pad;c++;}
    }
    return s;
}

verwenden Sie wiederholen, wäre es einfacher.

    var padLeft=function(str, pad, fw){
        return fw>str.length ? pad.repeat(fw-str.length)+str : str;
    }

sie können es wie folgt verwenden: padeLeft ('Origin-str', '0', 20)

Hier ist mein Take

Ich bin nicht so sicher, was die Leistung angeht, aber ich finde es viel lesbarer 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);
};

Versuche dies:-

function leftPad(number) {
     return (number < 9)?'0'+number:number;
}

//call like this
var month=3;
month=leftPad(month);//output:- month=04

Basierend auf den besten Antworten dieser Frage habe ich einen Prototyp für String mit dem Namen padLeft (genau wie in C #) erstellt:

String.prototype.padLeft = function (paddingChar, totalWidth) {
    if (this.toString().length >= totalWidth)
        return this.toString();

    var array = new Array(totalWidth); 

    for (i = 0; i < array.length; i++)
        array[i] = paddingChar;

    return (array.join("") + this.toString()).slice(-array.length);
}

Verwendungszweck:

var str = "12345";
console.log(str.padLeft("0", 10)); //Result is: "0000012345"

JsFiddle

Für so etwas könnte ich eine einzeilige Funktion an dem Punkt erstellen, an dem sie benötigt wird:

var padleft = (s,c,len) => { while(s.length < len) s = c + s; return s; }

Beispiel: 

> console.log( padleft( '110', '0', 8) );
> 00000110

Ein Liner, wenn Sie etwas Kompaktes wollen:

String.prototype.pad = function(len, chr){
        return((((new Array(len)).fill(chr)).join("") +this).substring(this.length));
}

1. function
var _padLeft = function(paddingString, width, replacementChar) {
    return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');
};

2. String prototype
String.prototype.padLeft = function(width, replacementChar) {
        return this.length >= width ? this.toString() : (replacementChar + this).padLeft(width, replacementChar || ' ');
};

3. slice
('00000' + paddingString).slice(-5)

das ist meine Version der Funktion:

function str_pad(str, size, char, right) {
    var s = str + "";
    while (s.length < size) {
        if (right) {
            s = s + char;
        } else {
            s = char + s;
        }
    }
    return s;
}

meine Kombination aus oben genannten Lösungen wurde zu meiner eigenen, ständig weiterentwickelten Version hinzugefügt :)

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


'abc'.lpad(5,'.') == '..abc'
String(5679).lpad(10,0) == '0000005679'
String().lpad(4,'-') == '----' // repeat string

String.prototype.padLeft = function(pad) {
        var s = Array.apply(null, Array(pad)).map(function() { return "0"; }).join('') + this;
        return s.slice(-1 * Math.max(this.length, pad));
    };

verwendungszweck:

1. "123".padLeft(2) gibt zurück: "123"
2. "12".padLeft(2) gibt zurück: "12"
3. "1".padLeft(2) gibt zurück: "01"