値に先行ゼロを埋め込むにはどうすればよいですか？

JavaScriptで値をゼロフィルするための推奨される方法は何ですか？型キャストされた値にゼロを埋め込むカスタム関数を構築できると思いますが、これを行う直接的な方法があるかどうか疑問に思いますか？

注：「ゼロフィル」とは、データベースの意味での意味です（5の6桁のゼロフィル表現は「000005」になります）。

読者への注意！

コメンターが指摘したように、このソリューションは「賢い」ものであり、賢いソリューションはしばしばそうであるように、メモリを集中的に使用し、比較的低速です。パフォーマンスが気になる場合は、このソリューションを使用しないでください。

潜在的に古い：ECMAScriptの2017は、 String.prototype.padStartと Number.prototype.toLocaleStringは ECMAScriptの3.1以降があります。例：

var n=-0.1;
n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false})

...「-0000.10」を出力します。

// or 
const padded = (.1+"").padStart(6,"0");
`-${padded}`

...「-0000.1」を出力します。

シンプルな機能で十分

function zeroFill( number, width )
{
  width -= number.toString().length;
  if ( width > 0 )
  {
    return new Array( width + (/\./.test( number ) ? 2 : 1) ).join( '0' ) + number;
  }
  return number + ""; // always return a string
}

名前空間などを節約したい場合は、これをライブラリに焼き込むことができます。jQueryのextendと同様です。

簡単な方法。パッドに文字列乗算を追加して、関数に変換できます。

var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);

関数として、

function paddy(num, padlen, padchar) {
    var pad_char = typeof padchar !== 'undefined' ? padchar : '0';
    var pad = new Array(1 + padlen).join(pad_char);
    return (pad + num).slice(-pad.length);
}
var fu = paddy(14, 5); // 00014
var bar = paddy(2, 4, '#'); // ###2

ここにあるすべての複雑な答えは信じられません...これを使用してください：

var zerofilled = ('0000'+n).slice(-4);

私は実際に最近このようなものを考え出さなければなりませんでした。ループを使用せずにそれを行う方法が必要だと考えました。

これが私が思いついたものです。

function zeroPad(num, numZeros) {
    var n = Math.abs(num);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( num < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

次に、ゼロパッドに数値を指定して使用します。

> zeroPad(50,4);
"0050"

数値がパディングよりも大きい場合、数値はパディングを超えて拡張されます。

> zeroPad(51234, 3);
"51234"

小数も結構です！

> zeroPad(51.1234, 4);
"0051.1234"

グローバル名前空間を汚染することを気にしない場合は、それを直接Numberに追加できます。

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

また、小数を使用したい場合は、パディングでスペースを使用します。

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - n.toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

乾杯！

XDRは、パフォーマンスが向上しているように見える対数変動を考え出しました。

警告：numがゼロの場合、この関数は失敗します（例：zeropad（0、2））

function zeroPad (num, numZeros) {
    var an = Math.abs (num);
    var digitCount = 1 + Math.floor (Math.log (an) / Math.LN10);
    if (digitCount >= numZeros) {
        return num;
    }
    var zeroString = Math.pow (10, numZeros - digitCount).toString ().substr (1);
    return num < 0 ? '-' + zeroString + an : zeroString + an;
}

パフォーマンスといえば、tomsmeding は上位3つの回答を比較しました（4は対数変動と比較）。どちらが他の2 つを大幅に上回ったと思いますか？:)

これが、7文字までの数字を埋めるために使用したものです。

("0000000" + number).slice(-7)

ほとんどの場合、このアプローチでおそらく十分です。

編集：それをより一般的にしたい場合は、これを行うことができます：

("0".repeat(padding) + number).slice(-padding)

編集2：ES2017以降は以下を使用できることに注意してくださいString.prototype.padStart：

number.toString().padStart(padding, "0")

最新のブラウザでがサポートされるようpadStartになりました。次の操作を実行できます。

string.padStart(maxLength, "0");

例：

string = "14";
maxLength = 5; // maxLength is the max string length, not max # of fills
res = string.padStart(maxLength, "0");
console.log(res); // prints "00014"

残念ながら、この問題には不必要で複雑な提案がたくさんあります。通常、数学や文字列の操作を行う独自の関数を記述したり、サードパーティのユーティリティを呼び出したりします。ただし、これを行う基本的なJavaScriptライブラリの標準的な方法は、1行のコードだけです。ローカル名やスタイルなど、変更したくないパラメーターを指定する必要がないように、この1行のコードを関数にラップすることをお勧めします。

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumIntegerDigits: 3,
    useGrouping: false
});

これにより、テキストの値は「005」になります。NumberのtoLocaleString関数を使用して、小数点の右側にゼロを埋め込むこともできます。

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumFractionDigits: 2,
    useGrouping: false
});

これにより、テキストの値は「5.00」になります。何千ものカンマ区切りを使用するには、useGroupingをtrueに変更します。

toLocaleString()with localesとoptions引数の使用は、ECMAScriptではなくECMA-402で個別に標準化されていることに注意してください。現在のところ、一部のブラウザは基本的なサポートのみを実装していtoLocaleString()ます。つまり、引数を無視する場合があります。

完全な例

フィル数が特定の値を超えないことが事前にわかっている場合、ループなしでこれを行う別の方法があります。

var fillZeroes = "00000000000000000000";  // max number of zero fill ever asked for in global

function zeroFill(number, width) {
    // make sure it's a string
    var input = number + "";  
    var prefix = "";
    if (input.charAt(0) === '-') {
        prefix = "-";
        input = input.slice(1);
        --width;
    }
    var fillAmt = Math.max(width - input.length, 0);
    return prefix + fillZeroes.slice(0, fillAmt) + input;
}

テストケースはこちら：http : //jsfiddle.net/jfriend00/N87mZ/

迅速かつ汚い方法：

y = (new Array(count + 1 - x.toString().length)).join('0') + x;

x = 5およびcount = 6の場合、y = "000005"になります。

これは私が仕事をするために思いついた簡単な機能です。誰かがより簡単なアプローチを持っている場合は、自由に共有してください！

function zerofill(number, length) {
    // Setup
    var result = number.toString();
    var pad = length - result.length;

    while(pad > 0) {
        result = '0' + result;
        pad--;
    }

    return result;
}

ここではパーティーに遅れますが、私はしばしばこの構成を使用してn、正の10進数であることがわかっている、ある値のアドホックパディングを実行します。

(offset + n + '').substr(1);

offset10 ^^桁はどこですか。

たとえば、n = 123である5桁のパディング：

(1e5 + 123 + '').substr(1); // => 00123

これの16進数バージョンは少し冗長です。

(0x100000 + 0x123).toString(16).substr(1); // => 00123

注1：@profitehlolzのソリューションも気に入っています。これは、slice（）の気の利いた負のインデックス機能を使用した、これの文字列バージョンです。

理由は本当にわかりませんが、最も明白な方法でそれを行った人はいません。これが私の実装です。

関数：

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

プロトタイプ：

Number.prototype.zeroPad=function(digits){
    var num=this+"";
    while(num.length < digits){
        num='0'+num;
    }
    return(num);
};

非常に簡単ですが、これがどのように単純になるかはわかりません。どういうわけか私はここSOで何度も見たことがありますが、人々は「for」ループと「while」ループを絶対に避けようとします。正規表現を使用すると、このようなささいな8桁のパディングでおそらくより多くのサイクルが必要になります。

このスニペットを使用して5桁の表現を取得します

(value+100000).toString().slice(-5) // "00123" with value=123

ECMAScript 2017：padStartまたはpadEndを使用

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

より詳しい情報：

• https://github.com/tc39/proposal-string-pad-start-end
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

数学の力！

x =パディングする整数
y =パディングするゼロの数

function zeroPad(x, y)
{
   y = Math.max(y-1,0);
   var n = (x / Math.pow(10,y)).toFixed(y);
   return n.replace('.','');  
}

String.prototype.substr（）を負の数で使用すると、右から数えるという事実を誰も指摘しなかった。

OPの質問に対する1つのライナーの解決策、数値5の6桁のゼロで埋められた表現は次のとおりです。

console.log(("00000000" + 5).substr(-6));

一般化すると次のようになります。

function pad(num, len) { return ("00000000" + num).substr(-len) };

console.log(pad(5, 6));
console.log(pad(45, 6));
console.log(pad(345, 6));
console.log(pad(2345, 6));
console.log(pad(12345, 6));

この質問で見つかった15の異なる関数/メソッドのテストの長い、長い時間の後に、私はどちらが最高（最も用途が広く、最も速い）であるかを知っています。

この質問への回答から15の関数/メソッドを取り、100パッドを実行するのにかかる時間を測定するスクリプトを作成しました。各パッドは、数値9を2000ゼロで埋めます。これは過度に見えるかもしれませんが、実際はそうですが、関数のスケーリングについての良い考えを与えてくれます。

私が使用したコードはここにあります：https : //gist.github.com/NextToNothing/6325915

自由にコードを変更してテストしてください。

最も用途の広いメソッドを取得するには、ループを使用する必要があります。これは、非常に多数の場合、他のユーザーは失敗する可能性が高いためですが、これは成功します。

では、どのループを使用するのでしょうか。まあ、それはwhileループになります。forループが速く、まだですが、whileループはわずかに速く（ミリ秒のカップル）である-とクリーナー。

のような回答Wilco、Aleksandar ToplekまたはVitim.us完全に仕事をします。

個人的に、私は別のアプローチを試みました。文字列/数値を埋めるために再帰関数を使用しようとしました。配列を結合するメソッドよりもうまくいきましたが、それでもforループほど速く機能しませんでした。

私の機能は：

function pad(str, max, padder) {
  padder = typeof padder === "undefined" ? "0" : padder;
  return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}

パディング変数を設定してもしなくても、my関数を使用できます。このように：

pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'

個人的には、テスト後、Aleksandar Toplekまたはのような、whileループを持つメソッドを使用しますVitim.us。ただし、パディング文字列を設定できるように少し変更します。

だから、私はこのコードを使用します：

function padLeft(str, len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    str = str + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
padLeft(1, 3); // Returns '001'
// - Or -
padLeft(1, 3, "x"); // Returns 'xx1'

次のコードを使用して、プロトタイプ関数として使用することもできます。

Number.prototype.padLeft = function(len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    var str = this + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
var num = 1;

num.padLeft(3); // Returns '001'
// - Or -
num.padLeft(3, "x"); // Returns 'xx1'

最初のパラメーターは任意の実数、2番目のパラメーターは小数点の左側の最小桁数を指定する正の整数、3番目のパラメーターは小数点の右側の桁数を指定するオプションの正の整数です。

function zPad(n, l, r){
    return(a=String(n).match(/(^-?)(\d*)\.?(\d*)/))?a[1]+(Array(l).join(0)+a[2]).slice(-Math.max(l,a[2].length))+('undefined'!==typeof r?(0<r?'.':'')+(a[3]+Array(r+1).join(0)).slice(0,r):a[3]?'.'+a[3]:''):0
}

そう

           zPad(6, 2) === '06'
          zPad(-6, 2) === '-06'
       zPad(600.2, 2) === '600.2'
        zPad(-600, 2) === '-600'
         zPad(6.2, 3) === '006.2'
        zPad(-6.2, 3) === '-006.2'
      zPad(6.2, 3, 0) === '006'
        zPad(6, 2, 3) === '06.000'
    zPad(600.2, 2, 3) === '600.200'
zPad(-600.1499, 2, 3) === '-600.149'

ホイールを作り直すのではなく、アンダースコア文字列を使用してください：

jsFiddle

var numToPad = '5';

alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'

これはES6ソリューションです。

function pad(num, len) {
  return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));

使用できるすべての最新ブラウザー

numberStr.padStart(numberLength, "0");

function zeroFill(num, numLength) {
  var numberStr = num.toString();

  return numberStr.padStart(numLength, "0");
}

var numbers = [0, 1, 12, 123, 1234, 12345];

numbers.forEach(
  function(num) {
    var numString = num.toString();
    
    var paddedNum = zeroFill(numString, 5);

    console.log(paddedNum);
  }
);

MDNリファレンスhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

この質問にはもっと回答が必要なわけではありませんが、私はこれの単純なロダッシュバージョンを追加すると思いました。

_.padLeft(number, 6, '0')

これを行う最新の方法は、はるかに簡単です。

var number = 2
number.toLocaleString(undefined, {minimumIntegerDigits:2})

output: "02"

別の解決策ですが、もっと読みやすいと思います。

function zeroFill(text, size)
{
  while (text.length < size){
  	text = "0" + text;
  }
  
  return text;
}

これはネイティブではありませんが、最速かもしれません...

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};

私の解決策

Number.prototype.PadLeft = function (length, digit) {
    var str = '' + this;
    while (str.length < length) {
        str = (digit || '0') + str;
    }
    return str;
};

使用法

var a = 567.25;
a.PadLeft(10); // 0000567.25

var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25

再帰を使用しないのはなぜですか？

function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}

一部のモンキーパッチも機能します

String.prototype.padLeft = function (n, c) {
  if (isNaN(n))
    return null;
  c = c || "0";
  return (new Array(n).join(c).substring(0, this.length-n)) + this; 
};
var paddedValue = "123".padLeft(6); // returns "000123"
var otherPadded = "TEXT".padLeft(8, " "); // returns "    TEXT"

function pad(toPad, padChar, length){
    return (String(toPad).length < length)
        ? new Array(length - String(toPad).length + 1).join(padChar) + String(toPad)
        : toPad;
}

pad(5, 0, 6) = 000005

pad('10', 0, 2) = 10 // don't pad if not necessary

pad('S', 'O', 2) = SO

...等。

乾杯

最も簡単なあなたは見つけるでしょう、最もストレートフォワードソリューション。

function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}