JavaScriptで値をゼロフィルするための推奨される方法は何ですか? 型キャストされた値にゼロを埋め込むカスタム関数を作成できると思いますが、これを行うより直接的な方法があるかどうか疑問に思っていますか?
注:「ゼロフィル」とは、データベースの意味での意味です(数字5の6桁のゼロフィル表現は「000005」になります)。
JavaScriptで値をゼロフィルするための推奨される方法は何ですか? 型キャストされた値にゼロを埋め込むカスタム関数を作成できると思いますが、これを行うより直接的な方法があるかどうか疑問に思っていますか?
注:「ゼロフィル」とは、データベースの意味での意味です(数字5の6桁のゼロフィル表現は「000005」になります)。
簡単な方法。パッドに文字列の乗算を追加して、それを関数に変えることができます。
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
読者への注意!
コメンテーターが指摘しているように、このソリューションは「巧妙」であり、巧妙なソリューションがよくあるように、メモリを集中的に使用し、比較的低速です。パフォーマンスが気になる場合は、このソリューションを使用しないでください。
時代遅れの可能性: 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と同様です。
これは、最大7文字の数字を埋め込むために使用したものです。
("0000000" + number).slice(-7)
このアプローチは、おそらくほとんどの人にとって十分です。
編集:より一般的にしたい場合は、これを行うことができます:
("0".repeat(padding) + number).slice(-padding)
編集2:ES2017以降、次を使用できることに注意してくださいString.prototype.padStart
:
number.toString().padStart(padding, "0")
残念ながら、この問題に対しては、多くの不必要で複雑な提案があり、通常は独自の関数を作成して数学や文字列操作を行うか、サードパーティ ユーティリティを呼び出す必要があります。ただし、ベース 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()
withlocales
と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;
}
ECMAScript 2017: padStartまたはpadEndを使用
'abc'.padStart(10); // " abc"
'abc'.padStart(10, "foo"); // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
より詳しい情報:
理由はわかりませんが、最も明白な方法でそれを行った人はいません。これが私の実装です。
関数:
/** 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 桁のパディングに対して、より多くのサイクルが必要になります。
n
ここでパーティーに遅れましたが、正の小数であることが知られている value のアドホックなパディングを行うために、この構造をよく使用します。
(offset + n + '').substr(1);
offset
10^^桁はどこですか?
たとえば、n = 123 の場合、5 桁にパディングします。
(1e5 + 123 + '').substr(1); // => 00123
これの 16 進数バージョンはもう少し冗長です。
(0x100000 + 0x123).toString(16).substr(1); // => 00123
注 1: @profitehlolz のソリューションも気に入っています。これは、slice() の気の利いた負のインデックス機能を使用した、これの文字列バージョンです。
このスニペットを使用して、5 桁の表現を取得します
(value+100000).toString().slice(-5) // "00123" with value=123
これが ES6 ソリューションです。
function pad(num, len) {
return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));
この質問にさらに回答が必要というわけではありませんが、これの単純な lodash バージョンを追加すると思いました。
_.padLeft(number, 6, '0')
この質問の回答にある 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
orのような 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'
別の解決策ですが、より読みやすいと思います。
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
...等。
乾杯
パフォーマンスが非常に重要な場合 (何百万ものレコードをループする場合)、パディング文字列の配列を事前に生成して、呼び出しごとに行うのを避けることができます。
時間計算量: 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)
}
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;
}
このトピックに関する私の小さな貢献 ( 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"
私は知っています、それはかなり汚い関数ですが、高速で負の数でも機能します;)
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 が返されます。ここでの変更はそれを修正するはずです。
私はこの単純なアプローチを使用しています
var input = 1000; //input any number
var len = input.toString().length;
for (i = 1; i < input; i++) {
console.log("MyNumber_" + ('000000000000000' + i).slice(-len));
}
さらに別のバージョン:
function zPad(s,n){
return (new Array(n+1).join('0')+s).substr(-Math.max(n,s.toString().length));
}
function zFill(n,l){
return
(l > n.toString().length) ?
( (Array(l).join('0') + n).slice(-l) ) : n;
}
コメントをしたかっただけです(しかし、私は十分なポイントを持っていません)、最も投票数の多い回答は負の数と小数で失敗するということです
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"
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ゼロ先行」参照になるようです。
たぶん私は素朴ですが、これは単純で効率的な1行のコードで機能すると思います(正の数の場合):
padded = (value+Math.pow(10,total_length)+"").slice(1)
値のセットに従って長さをOKに保つ限り(ゼロパディングのように)、これは機能するはずです。
手順は次のとおりです。
自然なリスト(ファイル、ディレクトリ...)の場合、非常に便利です。
私のユースケースの単純なもの(ミリ秒を埋めるために> 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);
}
可変長パディング関数
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);
}
}
exports.pad = (num, length) => "0".repeat(length - num.toString().length) + num;
これは私が書いた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);
};
}]);
参考までに、より明確で読みやすい構文 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,'#' ) しない。これは、すべての数値について同じようです。
function uint_zerofill(num, width) {
var pad = ''; num += '';
for (var i = num.length; i < width; i++)
pad += '0';
return pad + num;
}
ロダッシュを使用する場合。
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>
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'
ネイティブ ソリューションを探しているときに、この投稿に出くわしました。組み込みのソリューションがないため、これに対する私の見解は次のとおりです。
function zerofill(number, width) {
var num = '';
while (width-- > 0) {
num += '0';
}
return num.slice(0, - (number + '').length) + number + '';
}
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";
私の貢献:
文字列の合計の長さに「ドット」を含めることを想定しています。そうでない場合でも、数値が浮動小数点数の場合、余分なゼロを追加するように書き直すのは簡単です。
padZeros = function (num, zeros) {
return (((num < 0) ? "-" : "") + Array(++zeros - String(Math.abs(num)).length).join("0") + Math.abs(num));
}
ばかげた再帰的な方法は次のとおりです。
function paddingZeros(text, limit) {
if (text.length < limit) {
return paddingZeros("0" + text, limit);
} else {
return text;
}
}
limit は文字列のサイズです。
元:appendZeros("7829", 20) // 00000000000000007829
さらに後でパーティーに。
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)
}
これは、数値がフィールド幅よりも長いネガや状況を処理します。そして浮動小数点。
お使いの環境で利用可能な場合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
私は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;
}());
私のテストはタイプミスがあったので偽物でした。
zeroPad = function (num, count) {
return ((num / Math.pow(10, count)) + '').substr(2);
};
Paul'sが最速ですが、.substrは.sliceよりも1文字多い場合でも高速だと思います;)
数値の末尾にパディングするには、num.toFixed を使用します。
例えば:
document.getElementById('el').value = amt.toFixed(2);
これは私が見つけた最も簡単な解決策であり、機能します。
ここで標準を探していました。ポールとジョナサンと同じ考えを持っていた...彼らはとてもかわいいです.これは恐ろしくかわいいバージョンです:
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'
うーん...私はこの問題に対する「究極の」答えを見たことがありません。同じ課題に直面している場合は、残念ながら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')+'.');
function zeroPad(num,digits){ return ((num/Math.pow(10,digits))+'').slice(2) }