web-dev-qa-db-fra.com

Existe-t-il une fonction JavaScript pouvant remplir une chaîne pour atteindre une longueur déterminée?

J'ai besoin d'une fonction JavaScript qui peut prendre une valeur et la raccourcir à une longueur donnée (j'ai besoin d'espaces, mais n'importe quoi 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.

246
Anthony Potts

J'ai trouvé cette solution ici et ceci 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 string:

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 retournera une heure dans le format "15:30"

477
Samuel

Une méthode plus rapide

Si vous faites cela régulièrement, par exemple pour remplir des valeurs dans un tableau, et que les performances sont un facteur, l'approche suivante peut vous donner un avantage de près de 100x en vitesse ( jsPerf ) par rapport à d'autres solutions actuellement discuté sur les sites Web. L'idée de base est que vous fournissez à la fonction pad une chaîne vide entièrement complétée à utiliser comme tampon. La fonction pad ajoute simplement à la chaîne à ajouter à cette chaîne pré-complétée (une chaîne concat), puis coupe ou réduit 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 ajouter à zéro un nombre de 10 chiffres,

pad('0000000000',123,true);

Pour remplir une chaîne avec des espaces, la chaîne entière est donc composée de 255 caractères,

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

Test de performance

Voir le jsPerf test here .

Et ceci est plus rapide que ES6 string.repeat de 2x également, comme le montre la version révisée de JsPerf here

114
Shyam Habarakada

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.

49
David

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"
39
hypno7oad

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

29
ChrisV

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 par Firefox et Chrome uniquement. 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)); 
}
22
Guss

ECMAScript 2017 ajoute une méthode padStart au prototype String. Cette méthode compresse une chaîne avec des espaces à une longueur donnée. Cette méthode utilise également une chaîne facultative qui sera utilisée à la place d'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), voir ce lien .

19
arMedBeta

L'astuce essentielle dans ces deux solutions consiste à créer une instance array avec une taille donnée (une de plus que la longueur souhaitée), puis à appeler immédiatement la méthode join() pour créer une string. La méthode join() reçoit le padding string (espaces probablement). Puisque la variable array est vide, les cellules vides seront rendues comme étant une variable vide strings lors du processus de jonction de la variable array dans un résultat string et seul le remplissage sera conservé. C'est une technique vraiment sympa.

14
Pointy

Avec la méthode ECMAScript 6 String # repeat _ et Fonctions de flèche , une fonction de pavé 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, une erreur ne sera pas générée lorsque s.lengthest supérieur à 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.

13
InsOp

pad avec les valeurs par défaut

J'ai remarqué que j'avais surtout besoin du padLeft pour la conversion du temps/le remplissage du 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 Number ou String as input

pad par défaut est 2 caractères

le caractère par défaut est 0

pour que je puisse simplement écrire

padL(1);
// 01

si j'ajoute le second argument (largeur du pad)

padL(1,3);
// 001

troisième paramètre (pad char)

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

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

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 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 jouer 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 tamponner 'averylongword' avec 2 ... ce n'est pas mon problème.


J'ai dit que je te donnais un pourboire.

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

Utiliser n'importe quel 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"
*/
10
cocco
9
Sornii

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

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

Cela fonctionne dans tous les cas que je pouvais 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
6
Alejandro Illecas

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  
4
Daniel LaFavers

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"

4
Matias Dominguez

es7 est juste des brouillons et des propositions pour le moment, mais si vous voulez suivre la compatibilité avec les spécifications, vos fonctions de pad ont besoin de:

  1. Prise en charge du pavé multi-caractères.
  2. Ne pas tronquer la chaîne d'entrée
  3. La touche par défaut est l'espace

De ma bibliothèque polyfill, mais appliquez 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 );
});
3
Adria

Voici une réponse simple en gros sur une 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, les zéros ici, est au moins égal à la longueur minimale souhaitée. Donc, vraiment, pour le mettre dans une ligne, obtenir un résultat de "00035" dans ce cas est:

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

Les manipulations de tableaux sont très lentes par rapport au concat simple chaîne. 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;
};
2
will Farrell

Une variante de @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;
};

Par exemple:

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

Nous sommes en 2014 et je suggère une fonction de remplissage de code Javascript. Ha!

Os nus: pad droit 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 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"
2
hashchange

Je pense qu'il vaut mieux éviter la récursion parce que c'est coûteux .

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

2
Sheikh Abdul Wahid

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

2
Brian M. Hunt

Un ami a demandé à propos de l'utilisation d'une fonction JavaScript pour pad gauche. Cela s'est transformé en un petit effort entre certains d'entre nous en chat pour coder le golf. C'était le résultat:

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

Il s'assure que la valeur à compléter est une chaîne. Si ce n'est pas la longueur totale souhaitée, il la remplit une fois puis est renvoyé. Voici à quoi il ressemble avec un nommage 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 consistait à nous assurer que les nombres étaient complétés par 0 à gauche pour obtenir 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
Travis J

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

 padMe -> chaîne ou numéro du pad de gauche 
 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: , 4, "0") 
 "0001" 
> LeftPad (1, 4, "@") 
 "@@@ 1" 
.__ * *.
1
yantaq

Si vous souhaitez simplement utiliser un hacky one-liner très simple, créez 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 souhaitez utiliser. 

Exemple: remplir le magasin de chaînes 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 numéro en entrée, appelez simplement .toString() dessus.

1
qwertzguy

Un peu tard, mais je pensais pouvoir partager quand même. J'ai trouvé utile d'ajouter une extension prototype à Object. De cette façon, je peux composer des chiffres 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
user5925630
  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. Ajouter toujours à la fin!
  2. Ne touchez pas votre corde dans la boucle. Laissez-le tranquille et construisez votre corde en premier. En fin de compte concaténer avec votre chaîne principale.
  3. Ne pas attribuer une 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 x-chars (l’analyseur peut le faire efficacement si vous extrayez du premier caractère). C'est une croissance exponentielle, ce qui signifie qu'elle gaspille de la mémoire temporairement (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);
    }
}

1
StanE
/**************************************************************************************************
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 alors tu peux faire:

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

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

encore une autre prise à la 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
};    
1
Jeremiah

Toutes les options incluses 

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

J'aime faire ceci au cas où vous auriez besoin de paver avec plusieurs caractères ou étiquettes (par exemple &nbsp;) pour l'affichage:

$.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;
}
0
td-lambda

utiliser repeter, ce serait plus simple.

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

vous pouvez l'utiliser comme: padeLeft ('Origin-str', '0', 20)

0
legendJSLC

Voici ma prise

Je ne suis pas sûr de ses performances, mais je les trouve beaucoup plus lisibles que d'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);
};
0
opensas

Essaye ça:-

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

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

Sur la base des meilleures réponses à cette question, j'ai créé un prototype pour String appelé padLeft (exactement comme nous avons en 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);
}

Usage:

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

JsFiddle

0
fabriciorissetto

Pour quelque chose comme ça, je pourrais créer une fonction d'une ligne au point où cela est nécessaire

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

Exemple: 

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

Une doublure si vous voulez quelque chose de compact:

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

0
Geordie
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)
0
kayz1

c'est ma version de fonction:

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

ma combinaison de solutions ci-dessus a été ajoutée à ma propre version en constante évolution :)

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

usage:

  1. "123".padLeft(2) renvoie: "123"
  2. "12".padLeft(2) renvoie: "12"
  3. "1".padLeft(2) renvoie: "01"
0
Yaniv.H