500

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

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

4

76 に答える 76

337

簡単な方法。パッドに文字列の乗算を追加して、それを関数に変えることができます。

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
于 2012-03-16T21:11:05.760 に答える
280

読者への注意!

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

時代遅れの可能性: 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と同様です。

于 2009-08-12T16:42:49.123 に答える
84

これは、最大7文字の数字を埋め込むために使用したものです。

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

このアプローチは、おそらくほとんどの人にとって十分です。

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

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

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

number.toString().padStart(padding, "0")
于 2013-01-14T19:04:05.250 に答える
33

残念ながら、この問題に対しては、多くの不必要で複雑な提案があり、通常は独自の関数を作成して数学や文字列操作を行うか、サードパーティ ユーティリティを呼び出す必要があります。ただし、ベース 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」が生成されます。3 桁ごとにコンマ区切りを使用するには、useGrouping を true に変更します。

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

完全な例

于 2014-11-05T22:34:37.703 に答える
21

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

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/

于 2011-08-08T15:37:21.860 に答える
19

手っ取り早い方法:

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

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

于 2010-11-23T17:12:56.597 に答える
17

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

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

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

    return result;
}
于 2009-08-12T16:54:00.863 に答える
16

ECMAScript 2017: padStartまたはpadEndを使用

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

より詳しい情報:

于 2016-11-28T08:49:01.513 に答える
13

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

関数:

/** 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 桁のパディングに対して、より多くのサイクルが必要になります。

于 2013-02-05T14:45:16.327 に答える
13

nここでパーティーに遅れましたが、正の小数であることが知られている value のアドホックなパディングを行うために、この構造をよく使用します。

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

offset10^^桁はどこですか?

たとえば、n = 123 の場合、5 桁にパディングします。

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

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

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

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

于 2012-09-24T12:25:58.767 に答える
12

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

(value+100000).toString().slice(-5) // "00123" with value=123
于 2013-09-03T11:08:13.873 に答える
9

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

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

于 2015-05-22T03:38:19.203 に答える
8

この質問にさらに回答が必要というわけではありませんが、これの単純な lodash バージョンを追加すると思いました。

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

于 2015-07-13T15:21:46.500 に答える
8

この質問の回答にある 15 の異なる関数/メソッドを長い間テストした後、どれが最適か (最も用途が広く、最も高速) がわかりました。

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

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

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

最も用途の広い方法を得るには、ループを使用する必要があります。これは、非常に多くの場合、他の人が失敗する可能性が高いのに対し、これは成功するためです.

では、どのループを使用するのでしょうか? まあ、それはwhileループでしょう。forループは依然として高速ですが、ループwhileはわずかに高速 (数ミリ秒) であり、クリーンです。

WilcoAleksandar 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 Toplekorのような 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'
于 2013-08-24T04:12:48.953 に答える
8

最初のパラメータは任意の実数、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'
于 2014-02-04T00:59:55.190 に答える
5

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

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

于 2016-07-22T13:55:11.270 に答える
4

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

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};
于 2009-09-06T23:05:23.860 に答える
4

私の解決策

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
于 2012-12-27T17:15:32.283 に答える
3

なぜ再帰を使わないのですか?

function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}
于 2016-05-12T15:59:15.597 に答える
2

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

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"
于 2009-09-07T00:07:52.700 に答える
2
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

...等。

乾杯

于 2012-05-01T23:00:38.063 に答える
2

パフォーマンスが非常に重要な場合 (何百万ものレコードをループする場合)、パディング文字列の配列を事前に生成して、呼び出しごとに行うのを避けることができます。

時間計算量: O(1) .
スペースの複雑さ: O(1)

const zeroPads = Array.from({ length: 10 }, (_, v) => '0'.repeat(v))

function zeroPad(num, len) {
  const numStr = String(num)
  return (zeroPads[len - numStr.length] + numStr)
}

于 2016-09-26T22:20:47.523 に答える
1
function numberPadding(n, p) {
  n = n.toString();
  var len = p - n.length;
  if (len > 0) {
    for (var i=0; i < len; i++) {
      n = '0' + n;
    }
  }
  return n;
}
于 2012-11-14T16:29:56.843 に答える
1

このトピックに関する私の小さな貢献 ( https://gist.github.com/lucasferreira/a881606894dde5568029 ):

/* Autor: Lucas Ferreira - http://blog.lucasferreira.com | Usage: fz(9) or fz(100, 7) */
function fz(o, s) {
    for(var s=Math.max((+s||2),(n=""+Math.abs(o)).length); n.length<s; (n="0"+n));
    return (+o < 0 ? "-" : "") + n;
};

使用法:

fz(9) & fz(9, 2) == "09"
fz(-3, 2) == "-03"
fz(101, 7) == "0000101"

私は知っています、それはかなり汚い関数ですが、高速で負の数でも機能します;)

于 2014-09-13T19:09:24.417 に答える
1
function zeroFill(number, width) {
    width -= (number.toString().length - /\./.test(number));
    if (width > 0) {
        return new Array(width + 1).join('0') + number;
    }
    return number + ""; // always return a string
}

Peter のコードに若干の変更を加えました。彼のコードでは、入力が (1.2, 3) の場合、返される値は 01.2 になるはずですが、1.2 が返されます。ここでの変更はそれを修正するはずです。

于 2012-08-22T16:51:40.020 に答える
1

私はこの単純なアプローチを使用しています

var input = 1000; //input any number
var len = input.toString().length;
for (i = 1; i < input; i++) {
  console.log("MyNumber_" + ('000000000000000' + i).slice(-len));
}
于 2016-07-19T09:29:15.243 に答える
1

さらに別のバージョン:

function zPad(s,n){
    return (new Array(n+1).join('0')+s).substr(-Math.max(n,s.toString().length));
}
于 2012-02-21T19:46:58.637 に答える
1
function zFill(n,l){
    return 
      (l > n.toString().length) ? 
        ( (Array(l).join('0') + n).slice(-l) ) : n;
}
于 2014-09-17T11:52:56.383 に答える
1

コメントをしたかっただけです(しかし、私は十分なポイントを持っていません)、最も投票数の多い回答は負の数と小数で失敗するということです

function padNumber(n,pad) {
    p = Math.pow(10,pad);
    a = Math.abs(n);
    g = (n<0);
    return (a < p) ?  ((g ? '-' : '') + (p+a).toString().substring(1)) : n;
}

padNumber( -31.235, 5);

"-00031.235"
于 2010-05-08T10:03:01.217 に答える
1

sprintf.jsは、ブラウザーおよび node.js 用の完全なオープン ソース JavaScript sprintf 実装です。

そのプロトタイプは単純です:

string sprintf(string format , [mixed arg1 [, mixed arg2 [ ,...]]])

ソリューション全体でAlexandru Mărășteanuのsprintfモジュールをお勧めします。次のようになります。

var sprintf = require('sprintf');
var zeroFilled = sprintf('%06d', 5);

console.log(zeroFilled); // 000005

注:私は6年後にこの質問に答えていますが、この質問は、ビューと回答の数が多いことを考えると、「 javascriptゼロ先行」参照になるようです。

于 2015-09-03T04:15:01.530 に答える
1

たぶん私は素朴ですが、これは単純で効率的な1行のコードで機能すると思います(正の数の場合):

padded = (value+Math.pow(10,total_length)+"").slice(1)

値のセットに従って長さをOKに保つ限り(ゼロパディングのように)、これは機能するはずです。

手順は次のとおりです。

  1. 正しい数の 0 で 10 の累乗を足します [69+1000 = 1069]
  2. +"" で文字列に変換 [1069 => "1069"]
  3. 最初の乗算の結果である最初の 1 をスライスします ["1069" => "069"]

自然なリスト(ファイル、ディレクトリ...)の場合、非常に便利です。

于 2012-12-05T18:24:18.447 に答える
1

私のユースケースの単純なもの(ミリ秒を埋めるために> 999を超えることはありません)必要に応じて、ゼロの数を調整するか、より一般的な方法を使用できます。

/**
 * @val integer
 * @zeros padding
 */
function zeroFill(val, zeros)
{
    var str = val.toString();
    if (str.length >= zeros)
        return str;
    str = "000" + str;
    return str.substring(str.length - zeros);
}
于 2013-08-15T09:22:06.503 に答える
0

可変長パディング関数

function addPaddingZeroes(value, nLength)
{
    var sValue = value + ''; //converts to string

    if(sValue.length>=nLength)
        return sValue;
    else
    {
        for(var nZero = 0; nZero < nLength; nZero++)
            sValue = "0" + sValue;
        return (sValue).substring(nLength - sValue.length, nLength);    
    }
}
于 2013-02-26T17:24:08.833 に答える
0
exports.pad = (num, length) => "0".repeat(length - num.toString().length) + num;
于 2016-03-14T05:05:07.840 に答える
0

これは私が書いたAngularプロバイダーで、@profitehlolzの答えを利用していますが、メモ化を採用しているため、一般的に使用されるパッド長とパッド文字の組み合わせが配列ビルド結合を不必要に呼び出さないようにしています:

angular.module('stringUtilities', [])
    .service('stringFunctions', [function() {
        this.padMemo={ };
        this.padLeft=function(inputString,padSize,padCharacter) {

            var memoKey=padSize+""+padCharacter;

            if(!this.padMemo[memoKey]) {

                this.padMemo[memoKey]= new Array(1 + padSize).join(padCharacter);
            }

           var pad=this.padMemo[memoKey];
           return (pad + inputString).slice(-pad.length);
       };
}]);
于 2016-01-07T12:32:48.810 に答える
0

参考までに、より明確で読みやすい構文 IMHO

"use strict";
String.prototype.pad = function( len, c, left ) {
    var s = '',
        c = ( c || ' ' ),
        len = Math.max( len, 0 ) - this.length,
        left = ( left || false );
    while( s.length < len ) { s += c };
    return ( left ? ( s + this ) : ( this + s ) );
}
Number.prototype.pad = function( len, c, left ) {
    return String( this ).pad( len, c, left );
}
Number.prototype.lZpad = function( len ) {
    return this.pad( len, '0', true );
}

これにより、文字として「0」を強制する他のソリューションよりも、結果の視覚的および読みやすさの不具合が少なくなります。入力しやすく読みやすいままで、他の文字をパディングしたい場合、または他の方向 (右パディング) にパディングしたい場合はどうすればよいかという質問に答えます。これは最もDRYな例でもあり、実際の先行ゼロパディング関数本体のコードが最も少ないことは確かです(他の依存関数は質問とはほとんど関係がないため)。

コードは、この github ユーザー (コードの元のソース) https://gist.github.com/Lewiscowles1986/86ed44f428a376eaa67fからの要点を介してコメントできます。

コンソールとスクリプトのテストに関する注意、数値リテラルにはメソッドを呼び出すために括弧または変数が必要なようです。そのため、2.pad(...) はエラーを引き起こしますが、(2).pad(0,'#' ) しない。これは、すべての数値について同じようです。

于 2015-11-07T11:44:08.030 に答える
0
function uint_zerofill(num, width) {
    var pad = ''; num += '';
    for (var i = num.length; i < width; i++)
        pad += '0';
    return pad + num;
}
于 2014-01-12T14:39:46.790 に答える
0

ロダッシュを使用する場合。

var n = 1;

alert( _.padLeft(n, 2, 0) ); // 01

n = 10;

alert( _.padLeft(n, 2, 0) ); // 10
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.0/lodash.min.js"></script>

于 2015-07-09T16:22:04.847 に答える
0

ES6 では、これはかなり簡単になります。

function pad (num, length, countSign = true) {
  num = num.toString()
  let negative = num.startsWith('-')
  let numLength = negative && !countSign ? num.length - 1 : num.length
  if (numLength >= length) {
    return num
  } else if (negative) {
    return '-' + '0'.repeat(length - numLength) + num.substr(1)
  } else {
    return '0'.repeat(length - numLength) + num
  }
}

pad(42, 4)          === '0042'
pad(12345, 4)       === '12345'
pad(-123, 4)        === '-100'
pad(-123, 4, false) === '-0100'
于 2015-10-10T00:52:15.377 に答える
0

ネイティブ ソリューションを探しているときに、この投稿に出くわしました。組み込みのソリューションがないため、これに対する私の見解は次のとおりです。

function zerofill(number, width) {
    var num = '';
    while (width-- > 0) {
        num += '0';
    }

    return num.slice(0, - (number + '').length) + number + '';
}
于 2015-03-04T23:53:01.397 に答える
0
function numPadding (padding,i) {
    return padding.substr(0, padding.length - (Math.floor(i).toString().length)) + Math.floor(i );
}

numPadding("000000000",234); -> "000000234"

また

function numPadding (number, paddingChar,i) {
    var padding = new Array(number + 1).join(paddingChar);
    return padding.substr(0, padding.length - (Math.floor(i).toString().length)) + Math.floor(i );
}

numPadding(8 ,"0", 234); -> "00000234";
于 2013-02-10T23:02:40.120 に答える
0

私の貢献:

文字列の合計の長さに「ドット」を含めることを想定しています。そうでない場合でも、数値が浮動小数点数の場合、余分なゼロを追加するように書き直すのは簡単です。

padZeros = function (num, zeros) {
        return (((num < 0) ? "-" : "") + Array(++zeros - String(Math.abs(num)).length).join("0") + Math.abs(num));
    }
于 2014-08-27T15:04:31.443 に答える
0

ばかげた再帰的な方法は次のとおりです。

function paddingZeros(text, limit) {
  if (text.length < limit) {
    return paddingZeros("0" + text, limit);
  } else {
    return text;
  }
}

limit は文字列のサイズです。

元:appendZeros("7829", 20) // 00000000000000007829

于 2021-12-27T19:00:13.113 に答える
0

さらに後でパーティーに。

function zfill(num, len) {
  return(0 > num ? "-" : "") + (Math.pow(10, len) <= Math.abs(num) ? "0" + Math.abs(num) : Math.pow(10, len) + Math.abs(num)).toString().substr(1)
}

これは、数値がフィールド幅よりも長いネガや状況を処理します。そして浮動小数点。

于 2012-10-16T15:25:33.493 に答える
0

お使いの環境で利用可能な場合npm、いくつかの既製のパッケージを使用できます: www.npmjs.com/browse/keyword/zeropad

私はゼロフィルが好きです。

インストール

$ npm install zero-fill

使用法

var zeroFill = require('zero-fill')

zeroFill(4, 1)      // '0001' 
zeroFill(4, 1, '#') // '###1' custom padding
zeroFill(4)(1)      // '0001' partials
于 2016-05-08T01:02:10.920 に答える
0

私はecmaScript6(TypeScript)で何かを書きましたが、おそらく誰かがそれを使用できます:

class Helper {
    /**
     * adds leading 0 and returns string if value is not minSize long, 
     * else returns value as string
     *
     * @param {string|number} value
     * @param {number} minSize
     * @returns {string}
     */
    public static leadingNullString(value: string|number, minSize: number): string {
        if (typeof value == "number") {
            value = "" + value;
        }
        let outString: string = '';
        let counter: number = minSize - value.length;
        if (counter > 0) {
            for (let i = 0; i < counter; i++) {
                outString += '0';
            }
        }
        return (outString + value);
    }
}

Helper.leadingNullString(123, 2);「123」を返す

Helper.leadingNullString(5, 2);「05」を返す

Helper.leadingNullString(40,2);「40」を返します

ecmaScript4 (JavaScript) トランスパイルは次のようになります。

var Helper = (function () {
    function Helper() {
    }
    Helper.leadingNullString = function (value, minSize) {
        if (typeof value == "number") {
            value = "" + value;
        }
        var outString = '';
        var counter = minSize - value.length;
        if (counter > 0) {
            for (var i = 0; i < counter; i++) {
                outString += '0';
            }
        }
        return (outString + value);
    };
    return Helper;
}());
于 2017-01-19T09:58:47.450 に答える
-1

私のテストはタイプミスがあったので偽物でした。

zeroPad = function (num, count) {
    return ((num / Math.pow(10, count)) + '').substr(2);
};

Paul'sが最速ですが、.substrは.sliceよりも1文字多い場合でも高速だと思います;)

于 2009-09-06T23:27:55.700 に答える
-1

数値の末尾にパディングするには、num.toFixed を使用します。

例えば:

  document.getElementById('el').value = amt.toFixed(2);

これは私が見つけた最も簡単な解決策であり、機能します。

于 2012-01-25T17:48:09.383 に答える
-1

ここで標準を探していました。ポールとジョナサンと同じ考えを持っていた...彼らはとてもかわいいです.これは恐ろしくかわいいバージョンです:

function zeroPad(n,l,i){
    return (i=n/Math.pow(10,l))*i>1?''+n:i.toFixed(l).replace('0.','');
}

も機能します(整数を想定していますか?)...

> zeroPad(Math.pow(2, 53), 20);
'00009007199254740992'
> zeroPad(-Math.pow(2, 53), 20);
'-00009007199254740992'
> zeroPad(Math.pow(2, 53), 10);
'9007199254740992'
> zeroPad(-Math.pow(2, 53), 10);
'-9007199254740992'
于 2013-09-19T08:35:56.733 に答える
-2

うーん...私はこの問題に対する「究極の」答えを見たことがありません。同じ課題に直面している場合は、残念ながらJavaScriptにそのための組み込み関数がないことを言って時間を節約する必要があります。しかし、PHPにはこの素晴らしい機能があり、文字列のパディングだけでなく、単一の文字または任意の文字列の数値を処理するので、JSで適切なツールがないために頭を悩ませた後、[主にゼロフィルインの数値、通常は固定長に合うように文字列をトリミングする]と過度のコーディング作業私は、夢のPHP関数と同じ[「ほぼ同じ」、詳細を読む]、快適なクライアント側JavaScriptで実行する独自の関数を作成することにしました。

function str_pad(input,pad_length,pad_string,pad_type){
    var input=input.toString();
    var output="";
    if((input.length>pad_length)&&(pad_type=='STR_PAD_RIGHT')){var output=input.slice(0,pad_length);}
    else if((input.length>pad_length)&&(pad_type=='STR_PAD_LEFT')){var output=input.slice(input.length-pad_length,input.length);}
    else if((input.length<pad_length)&&(pad_type=='STR_PAD_RIGHT')){
        var caracteresNecesarios=pad_length-input.length;
        var rellenoEnteros=Math.floor(caracteresNecesarios/pad_string.length);
        var rellenoParte=caracteresNecesarios%pad_string.length;
        var output=input;
        for(var i=0;i<rellenoEnteros;i++){var output=output+pad_string;};
        var output=output+pad_string.slice(0,rellenoParte);
    }
    else if((input.length<pad_length)&&(pad_type=='STR_PAD_LEFT')){
        var caracteresNecesarios=pad_length-input.length;
        var rellenoEnteros=Math.floor(caracteresNecesarios/pad_string.length);
        var rellenoParte=caracteresNecesarios%pad_string.length;
        var output="";
        for(var i=0;i<rellenoEnteros;i++){var output=output+pad_string;};
        var output=output+pad_string.slice(0,rellenoParte);
        var output=output+input;
    }
    else if(input.length==pad_length){var output=input;};
    return output;
};

私の関数が実行しない唯一のことは、STR_PAD_BOTHしばらくして追加できる動作と、より快適なキーボードです。関数を呼び出してテストすることができます。内部コードがスペイン語で1つまたは2つの単語を使用していることを気にしないのであれば、きっと気に入るはずです...大したことではないと思います。コーディングを「透かし」するためのコメントを追加しなかったので、作業でシームレスに使用できます。また、読みやすさを向上させるためにコードを圧縮しました。それを使用して、このようにテストし、コードを広めます

alert("str_pad('murcielago',20,'123','STR_PAD_RIGHT')="+str_pad('murcielago',20,'123','STR_PAD_RIGHT')+'.');
于 2012-10-25T07:07:50.557 に答える
-3
function zeroPad(num,digits){ return ((num/Math.pow(10,digits))+'').slice(2) } 
于 2009-09-06T22:47:34.297 に答える