J'ai besoin d'une fonction JavaScript qui peut prendre une valeur et la remplir à une longueur donnée (j'ai besoin d'espaces, mais tout ferait l'affaire). J'ai trouvé ça:

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

Exemple:

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

Mais je n'ai aucune idée de ce que ça fait et ça ne semble pas fonctionner pour moi.

J'ai trouvé cette solution ici et c'est pour moi beaucoup plus simple:

var n = 123

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

Et ici, j'ai fait une extension à l'objet chaîne:

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

Un exemple pour l'utiliser:

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

Cela renverra une heure au format "15:30"

Une méthode plus rapide

Si vous effectuez cette opération à plusieurs reprises, par exemple pour ajouter des valeurs dans un tableau, et que les performances sont un facteur, l'approche suivante peut vous donner un avantage de vitesse presque 100 fois supérieur ( jsPerf ) par rapport à d'autres solutions qui sont actuellement discutées sur les sites Web. L'idée de base est que vous fournissez la fonction pad avec une chaîne vide entièrement rembourrée à utiliser comme tampon. La fonction pad ajoute simplement à la chaîne à ajouter à cette chaîne pré-remplie (une chaîne concat), puis tranche ou ajuste le résultat à la longueur souhaitée.

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

Par exemple, pour mettre à zéro un nombre sur une longueur de 10 chiffres,

pad('0000000000',123,true);

Pour remplir une chaîne avec des espaces, afin que la chaîne entière soit de 255 caractères,

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

Test de performance

Voir le test jsPerf ici .

Et cela est également plus rapide que ES6 string.repeatde 2x, comme le montre le JsPerf révisé ici

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;

}

C'est beaucoup plus lisible.

Voici une approche récursive.

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

Un exemple...

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

String.prototype.padStart()et String.prototype.padEnd()sont actuellement des propositions de candidats TC39: voir github.com/tc39/proposal-string-pad-start-end (uniquement disponible dans Firefox à partir d'avril 2016; un polyfill est disponible).

ECMAScript 2017 ajoute une méthode padStart au prototype String. Cette méthode remplira une chaîne avec des espaces à une longueur donnée. Cette méthode prend également une chaîne facultative qui sera utilisée à la place des espaces pour le remplissage.

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

Une méthode padEnd a également été ajoutée et fonctionne de la même manière.

Pour la compatibilité du navigateur (et un polyfill utile), consultez ce lien .

En utilisant la méthode ECMAScript 6 String # repeat , une fonction pad est aussi simple que:

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

String#repeatest actuellement pris en charge uniquement dans Firefox et Chrome. pour d'autres implémentations, on pourrait envisager le polyfill simple suivant:

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

En utilisant la méthode ECMAScript 6 , les fonctions de répétition de chaîne et de flèche , une fonction de pad est aussi simple que:

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

jsfiddle

edit: suggestion des commentaires:

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

de cette façon, il ne générera pas d'erreur quand il s.lengthest supérieur àn

edit2: suggestion des commentaires:

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

de cette façon, vous pouvez utiliser la fonction pour les chaînes et les non-chaînes.

L'astuce clé dans ces deux solutions est de créer une arrayinstance avec une taille donnée (une de plus que la longueur souhaitée), puis d'appeler immédiatement la join()méthode pour créer un string. La join()méthode est passée le remplissage string(espaces probablement). Puisque le arrayest vide, les cellules vides seront rendues vides stringspendant le processus de jointure du arrayrésultat en un seul résultat string, et seul le remplissage restera. C'est une technique vraiment sympa.

pad avec des valeurs par défaut

J'ai remarqué que j'avais surtout besoin de padLeft pour la conversion de temps / le remplissage des nombres

donc j'ai écrit cette fonction

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

Cette fonction simple prend en charge Number ou String en entrée

le pavé par défaut est de 2 caractères

le caractère par défaut est 0

donc je peux simplement écrire

padL(1);
// 01

si j'ajoute le deuxième argument (largeur du tampon)

padL(1,3);
// 001

troisième paramètre (pad char)

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

EDIT @BananaAcid si vous passez une valeur non définie ou une chaîne de longueur 0, vous obtenez 0undefined..so:

comme suggéré

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

mais cela peut également être réalisé de manière plus courte.

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

travaille également avec:

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

Et si vous voulez être en mesure de remplir les deux façons:

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

qui peut être écrit de manière plus courte sans utiliser de tranche.

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 
)

*/

maintenant si vous essayez de garnir 'averylongword' avec 2 ... ce n'est pas mon problème.

Dit que je vous donne un pourboire.

La plupart du temps, si vous remplissez, vous le faites pour la même valeur N fois.

L'utilisation de tout type de fonction dans une boucle ralentit la boucle !!!

Donc, si vous voulez simplement laisser quelques chiffres dans une longue liste, n'utilisez pas de fonctions pour faire cette chose simple.

utilisez quelque chose comme ceci:

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

si vous ne savez pas comment la taille de remplissage maximale est basée sur les nombres à l'intérieur du tableau.

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

Avec ES8, il existe deux options de remplissage.

Vous pouvez les vérifier dans la documentation.

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

Reprenant les idées de Samuel, vers le haut ici. Et rappelez-vous un ancien script SQL, j'ai essayé avec ceci:

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

Cela fonctionne dans tous les cas que j'imagine:

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

la chaîne de remplissage a été insérée dans la nouvelle version javascript.

str.padStart(targetLength [, padString])

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

Si vous voulez votre propre fonction, vérifiez cet exemple:

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

Voici une fonction simple que j'utilise.

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

Par exemple:

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

Un court chemin:

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

Exemple:

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

retour: "001234"

es7 n'est que des ébauches et des propositions en ce moment, mais si vous voulez suivre la compatibilité avec la spécification, vos fonctions de pad ont besoin de:

1. Prise en charge du clavier multi-caractères.
2. Ne tronquez pas la chaîne d'entrée
3. Le pad par défaut est l'espace

Depuis ma bibliothèque polyfill, mais appliquez votre propre diligence raisonnable pour les extensions de prototype.

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

Voici une réponse simple en une seule ligne de code.

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

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

Assurez-vous que le nombre de caractères dans votre remplissage, zéros ici, est au moins autant que votre longueur minimale prévue. Donc, vraiment, pour le mettre sur une seule ligne, obtenir un résultat de "00035" dans ce cas est:

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

Les manipulations de tableaux sont vraiment lentes par rapport à la simple concaténation de chaînes. Bien sûr, référence pour votre cas d'utilisation.

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

Une variante de la réponse de @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;
};

Par exemple:

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

Nous sommes en 2014, et je suggère une fonction de remplissage de chaîne Javascript. Ha!

Bare-bones: pad droit avec espaces

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

Fantaisie: pad avec options

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

Utilisation (fantaisie):

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"

Si cela ne vous dérange pas d'inclure une bibliothèque d'utilitaires, la bibliothèque lodash a les fonctions _.pad, _.padLeft et _.padRight .

Je pense qu'il vaut mieux éviter la récursivité car c'est cher.

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

Voici une fonction JavaScript qui ajoute un nombre spécifié de rembourrages avec symble personnalisé. la fonction prend trois paramètres.

    padMe -> chaîne ou nombre à gauche pad
    pads -> nombre de pads
    padSymble -> symble personnalisé, la valeur par défaut est "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());
    }

/ * Voici quelques résultats:

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

Et puis vous pouvez faire:

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

Si vous voulez juste une doublure hacky très simple à garnir, faites simplement une chaîne du caractère de remplissage souhaité de la longueur de remplissage maximale souhaitée, puis sous-chaîne à la longueur de ce que vous voulez garnir.

Exemple: remplissage du magasin de chaînes eavec des espaces de 25 caractères.

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

Résultat: "hello "

Si vous voulez faire de même avec un numéro en entrée, appelez- .toString()le avant.

encore une autre prise avec une combinaison de quelques solutions

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

Un ami a demandé à utiliser une fonction JavaScript pour remplir à gauche. Cela s'est transformé en un petit effort entre certains d'entre nous dans le chat pour coder le golf. Voici le résultat:

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

Il garantit que la valeur à remplir est une chaîne, puis si ce n'est pas la longueur de la longueur totale souhaitée, elle la remplira une fois, puis répétera. Voici à quoi cela ressemble avec une dénomination et une structure plus logiques

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

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

L'exemple que nous utilisions était de s'assurer que les nombres étaient remplis 0vers la gauche pour faire une longueur maximale de 6. Voici un exemple d'ensemble:

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

Un peu tard, mais j'ai pensé que je pourrais quand même partager. J'ai trouvé utile d'ajouter une extension de prototype à Object. De cette façon, je peux remplir des nombres et des chaînes, à gauche ou à droite. J'ai un module avec des utilitaires similaires que j'inclus dans mes scripts.

// 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. N'insérez jamais de données quelque part (surtout pas au début, comme str = pad + str;), car les données seront réallouées à chaque fois. Ajoutez toujours à la fin!
2. Ne remplissez pas votre chaîne dans la boucle. Laissez-le tranquille et construisez d'abord votre chaîne de pad. À la fin, concaténez-le avec votre chaîne principale.
3. N'attribuez pas de chaîne de remplissage à chaque fois (comme str += pad;). Il est beaucoup plus rapide d'ajouter la chaîne de remplissage à elle-même et d'extraire les premiers caractères X (l'analyseur peut le faire efficacement si vous extrayez du premier caractère). Il s'agit d'une croissance exponentielle, ce qui signifie qu'elle gaspille temporairement de la mémoire (vous ne devriez pas le faire avec des textes extrêmement volumineux).

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

Voici mon avis

Je ne suis pas sûr de ses performances, mais je le trouve beaucoup plus lisible que les autres options que j'ai vues ici ...

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