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.
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"
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
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 candidates pour TC39: voir github.com/tc39/proposal-string-pad-start-end (uniquement disponible dans Firefox à partir d'avril 2016; un polyfill est disponible).
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));
}
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 .
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.
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"
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.
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"
*/
Avec ES8, il existe deux options pour le 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/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
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
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 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:
- Prise en charge du pavé multi-caractères.
- Ne pas tronquer la chaîne d'entrée
- 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 );
});
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);
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;
};
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'
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"
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));Si cela ne vous dérange pas d'inclure une bibliothèque d'utilitaires, la bibliothèque lodash a _.pad, _.padLeft et _.padRight functions.
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 />"));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" .__ * *.
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.
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;
}
};
- 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! - 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.
- 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);
}
}/**************************************************************************************************
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 "
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
};
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);
}
}
J'aime faire ceci au cas où vous auriez besoin de paver avec plusieurs caractères ou étiquettes (par exemple ) 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;
}
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)
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);
};
Essaye ça:-
function leftPad(number) {
return (number < 9)?'0'+number:number;
}
//call like this
var month=3;
month=leftPad(month);//output:- month=04
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"
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
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));
}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)
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;
}
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
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:
"123".padLeft(2)renvoie:"123""12".padLeft(2)renvoie:"12""1".padLeft(2)renvoie:"01"