une méthode plus rapide

si vous faites cela à plusieurs reprises, par exemple pour pad valeurs dans un tableau, et la performance est un facteur, l'approche suivante peut vous donner presque un 100x avantage dans la vitesse ( jsPerf ) sur les autres solutions qui sont actuellement discutées sur les réseaux inter. L'idée de base est que vous fournissez à la fonction pad une chaîne vide entièrement capitonnée à utiliser comme tampon. La fonction pad vient d'ajouter à la chaîne à ajouter à cette chaîne pré-capitonnée (une chaîne concat) et puis tranches ou garnit le résultat à la longueur désiré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 zéro pad un nombre à une longueur de 10 chiffres,

pad('0000000000',123,true);

pour garnir une chaîne de caractères avec des espaces, de sorte que la chaîne entière est de 255 caractères,

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

Essai De Performance

voir le jsPerf test ici .

et c'est plus rapide que ES6 string.repeat par 2x aussi, comme montré par 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 right = Math.ceil((padlen = len - str.length) / 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"

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

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

String#repeat est actuellement pris en charge dans Firefox et Chrome seulement. pour une autre mise en œuvre, on pourrait envisager le polyfill simple suivant:

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

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

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

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

Un padEnd méthode a également été ajoutée, qui fonctionne de la même manière.

pour la compatibilité du navigateur (et un polyfill utile) voir ce lien .

le truc clé dans ces deux solutions est de créer une instance array avec une taille donnée (une de plus que la longueur désirée), puis d'appeler immédiatement la méthode join() pour faire un string . La méthode join() est passé le rembourrage string (espaces probablement). Puisque le array est vide, les cellules vides seront rendues comme vides strings pendant le processus de joindre le array dans un résultat string , et seul le rembourrage sera rester. C'est vraiment une très belle technique.

en utilisant la méthode ECMAScript 6 String # repeat et Arrow functions , une fonction 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 tirée des commentaires:

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

de cette façon, il ne lancera pas une erreur quand s.length est plus grand que n

edit2: suggestion tirée 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.

pad avec les valeurs par défaut

j'ai remarqué que j'ai surtout besoin de la palette pour la conversion de temps / remplissage de nombre

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 supporte nombre ou chaîne comme entrée

le tampon par défaut est 2 caractères

par défaut char 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 0 Longueur vous obtenez 0undefined ..alors:

, comme l'a 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 aussi ê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)
}

fonctionne aussi avec:

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

et si vous voulez pouvoir pad dans les deux sens :

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

*/

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

dit que je vous donne un pourboire.

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

utiliser n'importe quel type de fonction à l'intérieur d'une boucle ralentit la boucle!!!

donc si vous voulez simplement pad laissé quelques numéros 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 max padding basé 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 y a deux options pour le rembourrage.

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/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

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

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

ça marche dans tous les cas que je peux imaginer:

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

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 est juste, les projets et propositions pour l'instant, mais si vous voulais suivre la compatibilité avec la spécification, votre pad fonctions de besoin:

1. support à plusieurs caractères.
2. Ne pas tronquer la chaîne d'entrée
3. Pad par défaut à l'espace

de ma bibliothèque polyfill, mais faites votre propre diligence raisonnable pour les extensions de prototypes.

// 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 dans une ligne, pour obtenir un résultat de "00035" dans ce cas est:

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

a été introduite dans une 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, cochez 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

sont vraiment lentes par rapport à la simple chaîne concat. Bien sûr, un benchmark pour votre étui.

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 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 Javascript pour masquer les chaînes de caractères. Ha!

Bare-bones: droit de la tablette avec des espaces

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

Fantaisie: pad avec les 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;
}

Usage (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"

je pense qu'il vaut mieux éviter la récursion à cause de son coût.

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 paddings avec le symbole personnalisé. la fonction prend trois paramètres.

    padMe --> string or number to left pad
    pads  --> number of pads
    padSymble --> custom symble, default is "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());
    }

/* Here are some results:

> 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 /q/repeat-string-javascript-19282/"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 très simple hacky à rembourrer, il suffit de faire une corde du caractère de rembourrage désiré de la longueur de rembourrage max désirée et puis la sous-couche à la longueur de ce que vous voulez garnir.

exemple: remplissage du stock de chaîne de caractères dans e avec des espaces de 25 caractères.

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

résultat: "hello "

Si vous voulez faire la même chose avec un nombre en entrée appelez simplement .toString() avant de.

si cela ne vous dérange pas d'inclure une bibliothèque utilitaire, lodash library a _.pad._ ,padLeft et _.padRight fonctions.

un ami a demandé à propos de L'utilisation D'une fonction JavaScript pour pad gauche. C'est devenu un peu l'effort entre certains d'entre nous dans le chat pour le code de golf. Ce fut le résultat:

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

il assure que la valeur à capitonner est une corde, et puis si ce n'est pas la longueur de la longueur totale désirée, il le rembourre une fois et puis de nouveau. Voici à quoi il ressemble avec un nom et une structure plus logique

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

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

l'exemple nous nous avons utilisé le was pour nous assurer que les numéros étaient rembourrés avec 0 à gauche pour faire une longueur maximale de 6. Voici un exemple:

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

1. N'insérez jamais de données quelque part (surtout pas au début, comme str = pad + str; ), puisque les données seront réallouées à chaque fois. Ajoutez toujours à la fin!
2. ne pas coller votre corde dans la boucle. Laissez-le tranquille et construisez d'abord votre chaîne. À la fin de concaténer avec votre chaîne principale.
3. N'assignez pas de chaîne de rembourrage à chaque fois (comme str += pad; ). Il est beaucoup plus rapide d'ajouter la chaîne de rembourrage à lui-même et extraire d'abord x-chars (l'analyseur peut le faire efficacement si vous extrayez du premier char). Il s'agit d'une croissance exponentielle, ce qui signifie qu'elle gaspille un peu de mémoire temporairement (vous ne devriez pas faire cela avec des textes extrêmement énormes).

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 prendre

Je ne suis pas si sûr de sa performance, mais je le trouve beaucoup plus lisible que d'autres options que j'ai vu 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);
};

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)

basé sur les meilleures réponses de cette question j'ai fait un prototype pour String appelé padLeft ( exactement comme nous avons dans C# ):

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

Utilisation:

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

JsFiddle