文字列をパディングして決められた長さにするJavaScript関数はありますか?


272

値を受け取り、指定された長さに埋め込むJavaScript関数が必要です(スペースが必要ですが、何でもできます)。私はこれを見つけました:

コード:

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

例:

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

しかし、私はそれが一体何をしているのか全く分かりません、そしてそれは私にとってはうまくいかないようです。


8
"ジョナス" .padStart(7 "、「)developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...

回答:


516

私はこの解決策をここで見つけましたが、これは私にとってはるかに簡単です:

var n = 123

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

そして、ここで文字列オブジェクトを拡張しました。

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

それを使用する例:

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

これは、「15:30」の形式で時間を返します


11
私が見つけた最も読みやすく簡潔なアプローチは簡単です。私は通常、プロトタイプ拡張機能を気にすることさえないほど簡単です(少なくともアプリでのいくつかの使用については)。よくやった。
ブリッチン2013年

32
このソリューションでは、slice引数より長い文字列(つまり、ここでは5文字)が短くなることに注意してください。
Denis V

1
こんにちはヤニブ。アルゴリズムを変更するための非常に良い提案があります。ただし、私の場合、何かをフォーマットしようとすると、処理する必要のある値に関する最低限の仕様が常にあり、この場合、仕様によってこの問題が修正されるため、要件は常にこの問題よりも優先されます。たとえば、フォーマットする電話番号があり、カナダでのみ電話を処理する場合、フォーマットする前に電話番号が10文字であることを確認します。いずれにせよ、あなたのソリューションも素晴らしいです。:)
サミュエル

1
これを
頻繁に

6
これは、JS String ライブラリを使用するため、String.padStart()およびString.padEnd()左/右のパディングのために更新する必要があります。
SudoKid 2018

119

より速い方法

たとえば、配列の値を埋め込むためにこれを繰り返し行う場合、パフォーマンスが要因である場合、次のアプローチにより、現在Webで議論されている他のソリューションに比べて速度(jsPerfがほぼ100倍になります。基本的な考え方は、バッファーとして使用するために、完全に埋め込まれた空の文字列をpad関数に提供することです。pad関数は、この事前にパディングされた文字列(1つの文字列連結)に追加される文字列に追加するだけで、結果を目的の長さにスライスまたはトリミングします。

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

たとえば、10桁の長さに数値をゼロ埋めするには、

pad('0000000000',123,true);

文字列に空白を埋め込むため、文字列全体が255文字になるようにするには、

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

性能試験

こちらのjsPerfテストをご覧ください

そしてこれはstring.repeatここで改訂されたJsPerfによって示されているように、ES6よりも2倍高速です。


5
+1 StackOverflowに関する私の問題の一部は、モデレーターが明らかに優れた回答に基づいて投票を変更できないことです。これはそのようなケースの1つです。
Jason Sebring

1
他の誰かが後のjsPerf(上記で追加したリンク)で証明したように、このアプローチはES6 string.repeatメソッドより約2倍高速です。したがって、多くの文字列パディングを行う場合は、必ずこれを試してください。
Shyam Habarakada 2016年

5
ジェイソンのコメントに戸惑っています。この回答は承認されたものとどう違うのですか?
corwin.amber 2016

1
私はあなたのjsPerfを見ました。これらのテストは、関数と、while()ループを使用するもののためのもので、他の高評価の回答では使用されません。それがより速いという意味かわかりませんか?
HoldOffHunger 2018

48

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;

}

ずっと読みやすくなっています。


1
パッドがスペースの場合に動作していないよう:pad("hello", 20) = "hello "
Cilliéマラン

40

ここに再帰的なアプローチがあります。

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

例...

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

7
整数乗算の再帰的な定義もあります...再帰的には「呪い」があることに注意してください...
フロー

32
イッカクや酔っ払いの男もいますが、どちらも関係ありません。再帰の呪いは、プログラマがいつ適切かわからない場合にのみ適用されます。
hypno7oad 2013

12
「再帰の呪いは、プログラマーがいつ適切かわからない場合にのみ適用されます。単純な文字列パッド関数など。
Danation 2014

これはかなりエレガントで、私のユースケースでは完全に機能しました。テキストを揃えるためにスペースを埋め込む必要がある場合は、最長の文字列の長さを入力してください=)
Damon Aw

12
エレガントですが、関数の反復ごとに新しい文字列も作成します。この関数はO(n)ですが、@ Samuelによる最も一般的なソリューションはO(1)です。どちらもエレガントですが、1つははるかに効率的です。そうは言っても、それはきちんとしたアプローチであり、別の言語ではさらに高速になる可能性があります。
つぶす

40

String.prototype.padStart()そしてString.prototype.padEnd()現在、TC39候補の提案です:参照github.com/tc39/proposal-string-pad-start-endを(2016年4月のように、Firefoxでのみ利用可能; ポリフィルが可能です)。


13
今、すべての(現代)のブラウザでサポートされている:developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
Sphinxxx

怠惰な場合:myString.padStart(padLength [, padString])およびmyString.padEnd(padLength [, padString])
Johan Dettmar

1
最近のすべてのブラウザーでサポートされているので、使用例をいくつか追加してください。これは奨励されるべきです。
フランクリンYu

なんてこった、今日までこれを聞いていないの?? これは受け入れられる答えになるはずです。
electrovir

29

ECMAScript 2017は、padStartメソッドをStringプロトタイプに追加します。このメソッドは、文字列にスペースを指定された長さまで埋め込みます。このメソッドは、スペースの代わりにパディングに使用されるオプションの文字列も受け取ります。

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

同じ方法で機能するpadEndメソッドも追加されました。

ブラウザの互換性(および便利なポリフィル)については、このリンクを参照してください


今日のベストアンサーはこちら!2019!
Peter Krauss、2018

22

ECMAScript 6のメソッドString#repeatを使用すると、パッド関数は次のように簡単です。

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

String#repeat現在、FirefoxとChromeでのみサポートされています。他の実装では、次の単純なポリフィルを検討できます。

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

Node.jsで作業している人のために、String.repeatもサポートされています。
jkt123 2018年

15

ECMAScript 6のメソッドString#repeatおよびArrow functionsを使用すると、パッド関数は次のように簡単です。

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

jsfiddle

編集: コメントからの提案:

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

このように、s.lengthがより大きい場合にエラーをスローしませんn

edit2: コメントからの提案:

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

このようにして、文字列と非文字列の両方に関数を使用できます。


1
これはいいですが、s.lengthそれよりも大きい場合はnスローされます。提案:let leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;
David G

文字列以外では機能しません。のようにleftPad(12, ' ', 5)。私は厳密に言って大丈夫かもしれないと知っていますが、それはおそらく最も一般的な使用例(パディング数)の1つです。多分function leftPad(s, c, n) { s = s.toString(); return s.length > len ? s : c.repeat(n - s.length) + s; }。使用function方法は、leftPadをファイルの下部に置くことができます。そうでなければ、あなたは間違いなく使うべきconstではないvarlet
gman 2017年

@gmanこの提案に感謝しますが、変数は何lenですか?
InsOp 2017年

Doh、するlen必要がありますn
gman

14

これら両方のソリューションの重要なトリックはarray、指定されたサイズ(目的の長さよりも1つ大きいサイズ)のインスタンスを作成し、すぐにjoin()メソッドを呼び出してを作成することstringです。join()この方法は、パディング渡されるstring(おそらくスペース)。のでarray空で、空のセルは、空のようにレンダリングされるstrings接合プロセス中arrayつの結果にstring、およびのみパディングが残ります。それは本当に素晴らしいテクニックです。


10

デフォルト値で埋める

時間の変換/数値のパディングにはほとんどpadLeftが必要であることに気付きました

だから私はこの関数を書きました

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

この単純な関数は、入力として数値または文字列をサポートします

デフォルトのパッドは2文字です

デフォルトの文字は0です

だから私は単に書くことができます

padL(1);
// 01

2番目の引数(パッド幅)を追加した場合

padL(1,3);
// 001

3番目のパラメーター(埋め込み文字)

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

未定義の値または長さが0の文字列を渡した場合、@ BananaAcidを編集して ..soを取得し0undefinedます。

提案通り

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

しかし、これはより短い方法でも実現できます。

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

以下でも動作します:

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

そして、あなたが両方の方法でパディングできるようにしたい場合:

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

スライスを使わずに、より短い方法で書くことができます。

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 
)

*/

ここで、 'averylongword'に2を埋め込もうとした場合、それは私の問題ではありません。


私はあなたにヒントを与えると言った。

ほとんどの場合、パディングすると、同じ値をN回パッドします。

ループ内で任意のタイプの関数を使用すると、ループが遅くなります!!!

したがって、長いリスト内にいくつかの数字を埋め込むだけの場合は、この単純なことを行うために関数を使用しないでください。

このようなものを使用してください:

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

配列内の数値に基づく最大パディングサイズがわからない場合。

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

非常に素晴らしい!ちょうどメモとして同じ結果を思い付きます:これは文字列を指定された最大長に連結し、空の文字列は1文字が短すぎ、未定義のstrは 'undefined' beeingを使用し、スプライスはエラーをスローする可能性があります-組み合わせた。return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2))。そしていつものように、皆さん、理解できないコードをコピーしないでください。
BananaAcid 14

1
(新しいArray(b || 2).join(c || 0)+(a || c || 0))。slice(-b)... shorter
cocco 14


9

ここで、サミュエルの考えを取り上げます。そして、古いSQLスクリプトを思い出してください、私はこれで試しました:

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

それは私が想像できるすべてのケースで機能します:

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

5

新しいJavaScriptバージョンでは、パディング文字列が追加されました。

str.padStart(targetLength [, padString])

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

独自の関数が必要な場合は、この例を確認してください。

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

この回答は他の複数の回答で言及されているため、新しい情報を追加しないのは重複です。回答する前に検索してください。
フランクリンYu

これは完全な署名を持つ最初のものです。そして、それは今日の時点での唯一の答えでなければなりません。
d_f

4

これが私が使用する簡単な関数です。

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

例えば:

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

4

短い方法:

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

例:

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

リターン:「001234」


1
多分String.prototype.padStart()簡単なはずです。
Max Peng

3

es7現時点ではドラフトと提案にすぎませんが、仕様との互換性を追跡したい場合は、パッド関数に次のものが必要です。

  1. 複数文字パッドのサポート。
  2. 入力文字列を切り捨てないでください
  3. パッドのデフォルトはスペース

私のポリフィルライブラリから、プロトタイプ拡張に独自のデューデリジェンスを適用します。

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

基本的に1行のコードで簡単な答えを示します。

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

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

パディングの文字数(ここではゼロ)が、目的の最小長と少なくとも同じであることを確認してください。したがって、実際には、1行に入れると、この場合に「00035」の結果を取得するには、次のようになります。

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

2

配列操作は、単純な文字列連結と比較して本当に遅いです。もちろん、ユースケースのベンチマークです。

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

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

例えば:

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

2

それは2014年です。Javascriptの文字列埋め込み関数をお勧めします。ハ!

ベアボーン:スペース付き右パッド

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

ファンシー:オプション付きパッド

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

使用法(ファンシー):

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

コストがかかるので、再帰を避けた方がいいと思います。

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


1

以下は、カスタムシンブルで指定された数のパディングを追加するJavaScript関数です。この関数は3つのパラメーターを取ります。

    padMe->左側のパッドへの文字列または数値
    パッド->パッドの数
    padSymble->カスタムsymble、デフォルトは「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());
    }
/ *結果は次のとおりです。

> leftPad(1)
「1」
> leftPad(1、4)
「0001」
> leftPad(1、4、 "0")
「0001」
> leftPad(1、4、 "@")
「@@@ 1」

* /

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

そして、あなたは行うことができます:

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

プロトタイプをいじらないでください!
Rihards 2013

1

非常に単純なハッキーワンライナーでパディングしたい場合は、希望する最大パディング長の希望するパディング文字の文字列を作成し、パディングしたい長さにサブストリング化します。

例:文字列ストアにeスペースを埋め込んで、長さを25文字にします。

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

結果: "hello "

入力として数値を使用して同じことを行う場合は、.toString()前にそれを呼び出します。


これは実際には汎用関数としてではなく、きちんと整えられていますが、一部のコンテキストではループを保存するための有効なハックとしてこれを見ることができました。
2014年

面白いアイデア。@ankr汎用関数として使用Array(n).join(c)するには、パディング長とパディング文字を構成可能にするために使用できますArray(26).join(' ')
WynandB 2014

1

いくつかのソリューションの組み合わせでさらに別の

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

友人が、JavaScript関数を使用して左にパディングすることについて質問しました。それは、ゴルフをコード化するためにチャットで私たちの何人かの間の少しの努力に変わりました。これは結果でした:

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

パディングされる値が文字列であることを保証し、それが希望する合計の長さでない場合は、一度パディングしてから再帰します。これは、より論理的な名前と構造で、次のようになります。

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

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

私たちが使用していた例は0、最大長が6 になるように数字が左側に埋め込まれることを確認することでした。次に、例のセットを示します。

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

少し遅れましたが、とにかく共有したいと思いました。Objectにプロトタイプ拡張を追加すると便利です。そうすれば、数字や文字列を左または右に埋め込むことができます。スクリプトに含めた同様のユーティリティを備えたモジュールがあります。

// 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
  1. str = pad + str;データは毎回再割り当てされるため、データをどこかに(特にのように最初に)挿入しないでください。最後に常に追加!
  2. ループ内で文字列をパディングしないでください。そのままにして、パッドストリングを最初に作成します。最後に、メインの文字列と連結します。
  3. 毎回パディング文字列を割り当てないでください(などstr += pad;)。それ自体にパディング文字列を追加して最初のx-charを抽出する方がはるかに高速です(最初のcharから抽出する場合、パーサーはこれを効率的に実行できます)。これは指数関数的な成長です。つまり、一時的にメモリを浪費します(非常に巨大なテキストではこれを行うべきではありません)。

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


0

これが私の見解です

パフォーマンスについてはよくわかりませんが、ここで見た他のオプションよりもはるかに読みやすくなっています...

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);
};
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.