Ho bisogno di una funzione JavaScript che può prendere un valore e riempirlo per una determinata lunghezza (ho bisogno di spazi, ma qualsiasi cosa farebbe). Ho trovato questo:

Codice:

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

Esempio:

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

Ma non ho idea di cosa diavolo stia facendo e non sembra funzionare per me.

Ho trovato questa soluzione qui e per me è molto più semplice:

var n = 123

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

E qui ho fatto un'estensione per l'oggetto stringa:

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

Un esempio per usarlo:

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

Ciò restituirà un'ora nel formato "15:30"

Un metodo più veloce

Se lo si sta ripetendo ripetutamente, ad esempio per sommare i valori in un array, e le prestazioni sono un fattore, il seguente approccio può offrire un vantaggio quasi 100 volte maggiore della velocità ( jsPerf ) rispetto ad altre soluzioni attualmente discusse su Internet. L'idea di base è che stai fornendo alla funzione pad una stringa vuota completamente imbottita da usare come buffer. La funzione pad aggiunge semplicemente la stringa da aggiungere a questa stringa pre-riempita (una stringa concat) e quindi taglia o taglia il risultato alla lunghezza desiderata.

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

Ad esempio, per azzerare un numero a una lunghezza di 10 cifre,

pad('0000000000',123,true);

Per riempire una stringa con spazi bianchi, quindi l'intera stringa è di 255 caratteri,

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

Test della prestazione

Vedi il test jsPerf qui .

E questo è più veloce di ES6 anche string.repeatdi 2x, come mostrato dal JsPerf rivisto qui

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;

}

È molto più leggibile.

Ecco un approccio ricorsivo ad esso.

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

Un esempio...

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

String.prototype.padStart()e String.prototype.padEnd()sono attualmente proposte candidate TC39: vedi github.com/tc39/proposal-string-pad-start-end (disponibile solo in Firefox a partire da aprile 2016; è disponibile un polyfill ).

ECMAScript 2017 aggiunge un metodo padStart al prototipo String. Questo metodo riempie una stringa con spazi per una determinata lunghezza. Questo metodo accetta anche una stringa facoltativa che verrà utilizzata al posto degli spazi per il riempimento.

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

È stato anche aggiunto un metodo padEnd che funziona allo stesso modo.

Per la compatibilità del browser (e un utile polyfill) consultare questo link .

Utilizzando il metodo String # ripetizione ECMAScript 6 , una funzione pad è semplice come:

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

String#repeatè attualmente supportato solo in Firefox e Chrome. per altre implementazioni, si potrebbe considerare il seguente polyfill semplice:

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

Usando il metodo ECMAScript 6 String # repeat e le funzioni Arrow , una funzione pad è semplice come:

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

jsfiddle

modifica: suggerimento dai commenti:

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

in questo modo, non genererà un errore quando s.lengthè maggiore din

edit2: suggerimento dai commenti:

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

in questo modo, è possibile utilizzare la funzione per stringhe e non stringhe.

Il trucco chiave in entrambe queste soluzioni è creare arrayun'istanza con una determinata dimensione (una in più rispetto alla lunghezza desiderata) e quindi chiamare immediatamente il join()metodo per creare un string. Il join()metodo viene passato il riempimento string(spazi probabilmente). Dato che arrayè vuoto, le celle vuote verranno rese vuote stringsdurante il processo di unione arrayin un risultato stringe rimarrà solo l'imbottitura. È una tecnica davvero bella.

pad con valori predefiniti

Ho notato che per lo più ho bisogno del padLeft per la conversione del tempo / il riempimento del numero

così ho scritto questa funzione

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

Questa semplice funzione supporta il numero o la stringa come input

il pad predefinito è 2 caratteri

il carattere predefinito è 0

così posso semplicemente scrivere

padL(1);
// 01

se aggiungo il secondo argomento (larghezza del pad)

padL(1,3);
// 001

terzo parametro (pad char)

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

EDIT @BananaAcid se passi un valore indefinito o una stringa di lunghezza 0 ottieni 0undefined..so:

come suggerito

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

ma ciò può anche essere ottenuto in modo più breve.

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

funziona anche con:

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

E se vuoi essere in grado di eseguire il pad in entrambi i modi:

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

che può essere scritto in modo più breve senza usare 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 
)

*/

ora se provi a riempire 'averylongword' con 2 ... non è un mio problema.

Ho detto che ti do un consiglio.

La maggior parte delle volte, se lo rilasci, lo fai per lo stesso valore N volte.

L'uso di qualsiasi tipo di funzione all'interno di un loop rallenta il loop !!!

Quindi, se vuoi solo lasciare alcuni numeri all'interno di una lunga lista, non usare le funzioni per fare questa semplice cosa.

usa qualcosa del genere:

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

se non sai come la dimensione massima di riempimento in base ai numeri all'interno dell'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"
*/

Con ES8, ci sono due opzioni per il riempimento.

Puoi controllarli nella documentazione.

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

Raccogliere le idee di Samuel, verso l'alto qui. E ricorda un vecchio script SQL, ho provato con questo:

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

Funziona in tutti i casi che potrei immaginare:

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 stringa di riempimento è stata implementata nella nuova versione di JavaScript.

str.padStart(targetLength [, padString])

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

Se vuoi la tua funzione, controlla questo esempio:

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

Ecco una semplice funzione che uso.

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

Per esempio:

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

In breve:

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

Esempio:

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

ritorno: "001234"

es7 è solo bozze e proposte in questo momento, ma se si desidera monitorare la compatibilità con le specifiche, le funzioni del proprio pad devono:

1. Supporto pad multi-carattere.
2. Non troncare la stringa di input
3. Il pad è impostato di default sullo spazio

Dalla mia libreria Polyfill, ma applica la tua dovuta diligenza per le estensioni del prototipo.

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

Ecco una semplice risposta in una riga di codice.

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

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

Assicurati che il numero di caratteri nella tua spaziatura, zeri qui, sia almeno pari alla lunghezza minima prevista. Quindi davvero, per metterlo in una riga, per ottenere un risultato di "00035" in questo caso è:

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

Le manipolazioni di array sono molto lente rispetto al semplice concat per stringhe. Naturalmente, benchmark per il tuo caso d'uso.

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

Una variante della risposta di @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;
};

Per esempio:

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

È il 2014 e suggerisco una funzione di padding di stringhe Javascript. Ha!

Ossa nude: pad destro con spazi

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

Fantasia: pad con opzioni

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

Uso (fantasia):

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"

Se non ti dispiace includere una libreria di utilità, la libreria lodash ha le funzioni _.pad, _.padLeft e _.padRight .

Penso che sia meglio evitare la ricorsione perché è costoso.

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

Ecco una funzione JavaScript che aggiunge il numero specificato di padding con symble personalizzato. la funzione accetta tre parametri.

    padMe -> stringa o numero sul pad sinistro
    pad -> numero di pad
    padSymble -> symble personalizzato, il valore predefinito è "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());
    }

/ * Ecco alcuni risultati:

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

E poi puoi fare:

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

Se vuoi solo un padel hacky molto semplice da imbottire, crea una stringa del carattere di imbottitura desiderato della lunghezza di imbottitura massima desiderata e poi sottostringa alla lunghezza di ciò che vuoi imbottire.

Esempio: riempire l'archivio di stringhe econ spazi di 25 caratteri.

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

Risultato: "hello "

Se vuoi fare lo stesso con un numero come input, chiamalo .toString()prima.

ancora un altro approccio con la combinazione di un paio di soluzioni

/**
 * 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 amico ha chiesto di utilizzare una funzione JavaScript per spostarsi a sinistra. Si è trasformato in un piccolo sforzo tra alcuni di noi in chat per programmare il golf. Questo è stato il risultato:

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

Assicura che il valore da riempire sia una stringa e quindi, se non è la lunghezza della lunghezza totale desiderata, la riempirà una volta e poi ricomincerà. Ecco come appare con nomi e strutture più logici

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

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

L'esempio che stavamo usando era per assicurarci che i numeri fossero imbottiti 0a sinistra per fare una lunghezza massima di 6. Ecco un esempio:

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 po 'in ritardo, ma ho pensato di condividere comunque. Ho trovato utile aggiungere un'estensione prototipo a Object. In questo modo posso riempire numeri e stringhe, a sinistra oa destra. Ho un modulo con utilità simili che includo nei miei script.

// 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. Non inserire mai dati da qualche parte (specialmente non all'inizio, come str = pad + str;), poiché i dati verranno riallocati ogni volta. Aggiungi sempre alla fine!
2. Non inserire la stringa nel loop. Lascialo da solo e crea prima la stringa del pad. Alla fine concatenalo con la tua stringa principale.
3. Non assegnare ogni volta la stringa di riempimento (come str += pad;). È molto più veloce aggiungere la stringa di padding a se stessa ed estrarre i primi caratteri X (il parser può farlo in modo efficiente se si estrae dal primo carattere). Questa è una crescita esponenziale, il che significa che spreca temporaneamente un po 'di memoria (non dovresti farlo con testi estremamente grandi).

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

Ecco la mia opinione

Non sono così sicuro delle sue prestazioni, ma lo trovo molto più leggibile rispetto ad altre opzioni che ho visto qui intorno ...

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