[英]How can I pad a value with leading zeros?
在 JavaScript 中零填充值的推薦方法是什么？ 我想我可以構建一個自定義 function 來將零填充到類型轉換的值上，但我想知道是否有更直接的方法可以做到這一點？
注意： “填零”是指數據庫意義上的單詞（其中數字 5 的 6 位填零表示為“000005”）。
我無法相信這里所有復雜的答案......只需使用這個：
var zerofilled = ('0000'+n).slice(-4);
let n = 1 var zerofilled = ('0000'+n).slice(-4); console.log(zerofilled)
簡單的方法。 您可以為 pad 添加字符串乘法並將其轉換為函數。
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 開始，我們有了padStart ：
const padded = (.1 + "").padStart(6, "0"); console.log(`-${padded}`);
使用toLocaleString ：
var n=-0.1; var res = n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false}); console.log(res);
實際上，我最近不得不想出類似的東西。 我認為必須有一種方法可以在不使用循環的情況下做到這一點。
這就是我想出的。
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 等於 0，此函數將失敗（例如 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 個與對數變化）。 猜猜哪一個大大優於其他兩個？ :)
這是我用來填充最多 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" number = 14; maxLength = 5; // maxLength is the max string length, not max # of fills res = number.toString().padStart(maxLength, "0"); console.log(res); // prints "00014"
不幸的是，對於這個問題有很多不必要的復雜建議，通常涉及編寫自己的函數來進行數學或字符串操作或調用第三方實用程序。 但是，在基礎 JavaScript 庫中有一種標准方法，只需一行代碼即可。 可能值得將這一行代碼包裝在一個函數中，以避免必須指定您永遠不想更改的參數，例如本地名稱或樣式。
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 以使用千位逗號分隔符。
請注意，使用帶有locales和options參數的toLocaleString()在 ECMA-402 中是單獨標准化的，而不是在 ECMAScript 中。 截至今天，一些瀏覽器只實現基本支持，即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"
更多信息：
在這里聚會遲到了，但我經常使用這個結構來做一些值n的臨時填充，已知是一個正的小數：
(offset + n + '').substr(1);
其中offset為 10^^ 位。
例如填充到 5 位，其中 n = 123：
(1e5 + 123 + '').substr(1); // => 00123
這個的十六進制版本稍微冗長一些：
(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
在所有現代瀏覽器中，您都可以使用
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
數學的力量！
x = 要填充的整數
y = 要填充的零數
function zeroPad(x, y)
{
y = Math.max(y-1,0);
var n = (x / Math.pow(10,y)).toFixed(y);
return n.replace('.','');
}
這就是 ES6 解決方案。
function pad(num, len) { return '0'.repeat(len - num.toString().length) + num; } alert(pad(1234,6));
並不是說這個問題需要更多答案，但我想我會添加這個簡單的 lodash 版本。
_.padLeft(number, 6, '0')
我沒有看到有人指出這樣一個事實，即當您使用帶負數的String.prototype.substr()時，它從右側開始計數。
OP 問題的一個線性解決方案，即數字 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 個焊盤所需的時間。 每個墊將用2000個零填充數字9 。 這可能看起來有些過分，確實如此，但它讓您對函數的縮放有一個很好的了解。
我使用的代碼可以在這里找到： 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;
}
您可以使用我的函數來設置或不設置填充變量。 所以像這樣：
pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'
就個人而言，在我的測試之后，我會使用帶有 while 循環的方法，比如Aleksandar Toplek或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'
第一個參數是任何實數，第二個參數是一個正整數，指定小數點左邊的最小位數，第三個參數是一個可選的正整數，指定小數點右邊的位數。
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'
執行此操作的最新方法要簡單得多：
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
您可以使用以下函數“填零一個數字”：
/**
* @param number The number
* @param minLength Minimal length for your string with leading zeroes
* @return Your formatted string
*/
function zerofill(nb, minLength) {
// Convert your number to string.
let nb2Str = nb.toString()
// Guess the number of zeroes you will have to write.
let nbZeroes = Math.max(0, minLength - nb2Str.length)
// Compute your result.
return `${ '0'.repeat(nbZeroes) }${ nb2Str }`
}
console.log(zerofill(5, 6)) // Displays "000005"
/**
* @param number The number
* @param minLength Minimal length for your string with leading zeroes
* @return Your formatted string
*/
const zerofill = (nb, minLength) => nb.toString().padStart(minLength, '0')
console.log(zerofill(5, 6)) // Displays "000005"
為什么不使用遞歸？
function padZero(s, n) {
s = s.toString(); // in case someone passes a number
return s.length >= n ? s : padZero('0' + s, n);
}
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
...ETC。
干杯
一些猴子補丁也有效
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 zerofill(number,length) {
var output = number.toString();
while(output.length < length) {
output = '0' + output;
}
return output;
}
只是為了好玩，這是我的 pad 函數版本：
function pad(num, len) {
return Array(len + 1 - num.toString().length).join('0') + num;
}
它也不會截斷長於填充長度的數字
如果性能真的很關鍵（循環數百萬條記錄），可以預先生成一個填充字符串數組，避免每次調用都這樣做。
時間復雜度： 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 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。 此處的更改應該可以糾正這一點。
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;
}
也許我太天真了，但我認為這可以在一個簡單而有效的代碼行中工作（對於正數）：
padded = (value+Math.pow(10,total_length)+"").slice(1)
只要您根據您的一組值（如任何零填充）保持您的長度正常，這應該可以工作。
步驟是：
對於自然列表（文件、目錄...）非常有用。
這種方法不是更快，但它是相當原生的。
zeroPad = function (num, count) {
return [Math.pow(10, count - num.toString().length), num].join('').substr(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);
}
我對這個主題的一點貢獻（ 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 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 零領先”參考。
我正在使用這種簡單的方法
var input = 1000; //input any number
var len = input.toString().length;
for (i = 1; i < input; i++) {
console.log("MyNumber_" + ('000000000000000' + i).slice(-len));
}
好的，好的，我不敢相信我會費心為這個問題提交另一個答案，但我認為我的方法有點不同。 我需要填充數字的原因是將其顯示在<pre>元素（屏幕日志的一部分）中，因此無論如何它最終都會是一個字符串。 我沒有做任何數學運算，而是編寫了一個簡單的函數來將字符串值覆蓋在掩碼字符串上：
function overlayr(m, s) {
return m.length > s.length ? m.substr(0, m.length - s.length) + s : s;
}
這樣做的好處是我可以將它用於各種字符串對齊任務。 要調用它，只需將掩碼和數字作為字符串傳入：
> overlayr('00000', (5).toString())
< "00005"
作為額外的獎勵，它可以正確處理溢出：
> overlayr('00000', (555555).toString())
< "555555"
當然，它不限於 0 填充：
> overlayr('*****', (55).toString())
< "***55"
我沒有以這種形式看到任何答案，所以在這里我使用正則表達式和字符串操作進行拍攝
（也適用於負數和十進制數）
代碼：
function fillZeroes(n = 0, m = 1) {
const p = Math.max(1, m);
return String(n).replace(/\d+/, x => '0'.repeat(Math.max(p - x.length, 0)) + x);
}
一些輸出：
console.log(fillZeroes(6, 2)) // >> '06'
console.log(fillZeroes(1.35, 2)) // >> '01.35'
console.log(fillZeroes(-16, 3)) // >> '-016'
console.log(fillZeroes(-1.456, 3)) // >> '-001.456'
console.log(fillZeroes(-456.53453, 6)) // >> '-000456.53453'
console.log(fillZeroes('Agent 7', 3)) // >> 'Agent 007'
一個愚蠢的遞歸方式是：
function paddingZeros(text, limit) {
if (text.length < limit) {
return paddingZeros("0" + text, limit);
} else {
return text;
}
}
其中限制是您希望字符串的大小。
例如： appendZeros("7829", 20) // 00000000000000007829
另一個版本：
function zPad(s,n){
return (new Array(n+1).join('0')+s).substr(-Math.max(n,s.toString().length));
}
甚至后來參加聚會。
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)
}
這可以處理負數和數字長於字段寬度的情況。 和浮點數。
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";
可變長度填充函數
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);
}
}
一個簡單的短遞歸函數來實現您的建議：
function padleft (YourNumber, OutputLength){
if (YourNumber.length >= OutputLength) {
return YourNumber;
} else {
return padleft("0" +YourNumber, OutputLength);
}
}
如果您的輸入數字長度短於所需的輸出數字長度，此函數將在左側添加 0。
function uint_zerofill(num, width) {
var pad = ''; num += '';
for (var i = num.length; i < width; i++)
pad += '0';
return pad + num;
}
一點數學可以給你一個單行函數：
function zeroFill( number, width ) {
return Array(width - parseInt(Math.log(number)/Math.LN10) ).join('0') + number;
}
這是假設number是一個不比width的整數。 如果調用例程不能保證，該函數將需要進行一些檢查：
function zeroFill( number, width ) {
var n = width - parseInt(Math.log(number)/Math.LN10);
return (n < 0) ? '' + number : Array(n).join('0') + number;
}
我的貢獻：
我假設您希望總字符串長度包括“點”。 如果不是，如果數字是浮點數，重寫添加一個額外的零仍然很簡單。
padZeros = function (num, zeros) {
return (((num < 0) ? "-" : "") + Array(++zeros - String(Math.abs(num)).length).join("0") + Math.abs(num));
}
這是兩行函數中的一個小數組解決方案。 它還檢查前導零是否小於數字字符串的長度。
function pad(num, z) {
if (z < (num = num + '').length) return num;
return Array(++z - num.length).join('0') + num;
}
我只是偶然發現這篇文章正在尋找本機解決方案。 由於沒有內置的解決方案，這是我的看法：
function zerofill(number, width) {
var num = '';
while (width-- > 0) {
num += '0';
}
return num.slice(0, - (number + '').length) + number + '';
}
如果你使用 Lodash。
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'
僅供參考，更清晰，更易讀的語法恕我直言
"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'est 示例，實際前導零填充函數體的代碼最少（因為其他依賴函數在很大程度上與問題無關）。
該代碼可通過此 github 用戶的 gist 進行評論（代碼的原始來源） https://gist.github.com/Lewiscowles1986/86ed44f428a376eaa67f
關於控制台和腳本測試的說明，數字文字似乎需要括號或變量才能調用方法，因此 2.pad(...) 會導致錯誤，而 (2).pad(0,'#' ） 將不會。 這似乎對所有數字都是一樣的
這是我編寫的一個角度提供程序，它利用了@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);
};
}]);
exports.pad = (num, length) => "0".repeat(length - num.toString().length) + num;
如果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
一個簡單的功能：
function padStr(number, numDigits){
return
(number < 0 ? '-':'')
+ ((new Array(numDigits + 1).join("0"))
+ Math.abs(number)).slice(-numDigits);
}
我在 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;
}());
我有 2 個解決方案。 如果您知道這就是您想要快速完成的所有操作，那么第一個是真正的基本操作，即用零來壞一個數字。
第二個也將填充負數 - 與似乎具有最佳答案分數的“聰明”解決方案相同。
開始：
// One liner simple mode! // (always ensure the number is 6 digits long knowing its never negative) var mynum = 12; var mynum2 = "0".repeat((n=6-mynum.toString().length)>0?n:0)+mynum; alert("One liner to pad number to be 6 digits long = Was "+mynum+" Now "+mynum2); // As a function which will also pad negative numbers // Yes, i could do a check to only take "-" into account // if it was passed in as an integer and not a string but // for this, i haven't. // // @s The string or integer to pad // @l The minumum length of @s // @c The character to pad with // @return updated string function padme(s,l,c){ s = s.toString(); c = c.toString(); m = s.substr(0,1)=="-"; return (m?"-":"")+c.repeat((n=l-(s.length-(m?1:0)))>0?n:0)+s.substr((m?1:0)); } alert("pad -12 to ensure it is 8 digits long = "+padme(-12,8,0)); alert("pad 'hello' with 'x' to ensure it is 12 digits long = "+padme('hello',12,'x'));
一個簡單優雅的解決方案，其中 n 是數字，l 是長度。
function nFill (n, l) {return (l>n.toString().length)?((Array(l).join('0')+n).slice(-l)):n;}
如果超出預期，這會保留長度，以免更改數字。
n = 500; console.log(nFill(n, 5)); console.log(nFill(n, 2)); function nFill (n, l) {return (l>n.toString().length)?((Array(l).join('0')+n).slice(-l)):n;}
以下提供了一個快速快速的解決方案：
function numberPadLeft(num , max, padder = "0"){ return "" == (num += "") ? "" : ( dif = max - num.length, dif > 0 ? padder.repeat(dif < 0 ? 0 : dif) + num : num ) }
在編寫數字基轉換器時，我想出了一個荒謬的單行代碼。 在其他答案中沒有看到任何類似的東西，所以這里是：
// This is cursed function p(i,w,z){z=z||0;w=w||8;i+='';var o=i.length%w;return o?[...Array(wo).fill(z),...i].join(''):i;} console.log(p(8675309)); // Default: pad w/ 0 to 8 digits console.log(p(525600, 10)); // Pad to 10 digits console.log(p(69420, 10, 'X')); // Pad w/ X to 10 digits console.log(p(8675309, 4)); // Pad to next 4 digits console.log(p(12345678)); // Don't pad if you ain't gotta pad
或者，以一種不太容易背叛我已將我的靈魂賣給 Black Perl 的形式：
function pad(input, width, zero) {
zero = zero || 0; width = width || 8; // Defaults
input += ''; // Convert input to string first
var overflow = input.length % width // Do we overflow?
if (overflow) { // Yep! Let's pad it...
var needed = width - overflow; // ...to the next boundary...
var zeroes = Array(needed); // ...with an array...
zeroes = zeroes.fill(zero); // ...full of our zero character...
var output = [...zeroes,...input]; // ...and concat those zeroes to input...
output = output.join(''); // ...and finally stringify.
} else {
var output = input; // We don't overflow; no action needed :)
}
return output; // Done!
}
將其與其他答案區分開來的一件事是，它將數字長度與目標寬度取模，而不是簡單的大於檢查。 如果您想確保結果長度是目標寬度的某個倍數（例如，您需要輸出長度為 5 或 10 個字符），這很方便。
不知道它的性能如何，但是嘿，至少它已經縮小了！
這是我認為很酷的一個小技巧：
(2/10000).toString().split(".")[1]
"0002"
(52/10000).toString().split(".")[1]
"0052"
發布以防這是您要查找的內容，將以毫秒為單位的剩余時間轉換為字符串，例如 00:04:21
function showTimeRemaining(remain){
minute = 60 * 1000;
hour = 60 * minute;
//
hrs = Math.floor(remain / hour);
remain -= hrs * hour;
mins = Math.floor(remain / minute);
remain -= mins * minute;
secs = Math.floor(remain / 1000);
timeRemaining = hrs.toString().padStart(2, '0') + ":" + mins.toString().padStart(2, '0') + ":" + secs.toString().padStart(2, '0');
return timeRemaining;
}
我發現這個問題很有趣，我把我的小貢獻
function zeroLeftComplete(value, totalCharters = 3) { const valueString = value.toString() || '0' const zeroLength = valueString.length - totalCharters if (Math.sign(parseInt(zeroLength)) === -1) { const zeroMissing = Array.from({ length: Math.abs(zeroLength) }, () => '0').join('') return `${zeroMissing}${valueString}` } else return valueString }; console.log(zeroLeftComplete(0)); console.log(zeroLeftComplete(1)); console.log(zeroLeftComplete(50)); console.log(zeroLeftComplete(50561,3));
我們的測試是虛假的，因為我的測試有誤。
zeroPad = function (num, count) {
return ((num / Math.pow(10, count)) + '').substr(2);
};
Paul 是最快的，但我認為 .substr 比 .slice 快，即使它多一個字符；）
在這里尋找一個標准。 和保羅和喬納森有同樣的想法......他們的想法超級可愛，這是一個可怕的可愛版本：
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'
我用了
Utilities.formatString("%04d", iThe_TWO_to_FOUR_DIGIT)
最多有 4 個前導 0
注意：這需要 Google 的應用程序腳本實用程序：
https://developers.google.com/apps-script/reference/utilities/utilities#formatstringtemplate-args
要在數字末尾填充，請使用 num.toFixed
例如：
document.getElementById('el').value = amt.toFixed(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行為，我可以用一些時間和更舒適的鍵盤添加它。 您可以調用該函數並對其進行測試； 如果您不介意內部代碼在西班牙語中使用一兩個詞，那么您會喜歡它……我認為這沒什么大不了的。 我沒有為我的編碼添加“水印”注釋，因此您可以在工作中無縫使用它，我也沒有壓縮代碼以增強可讀性。 使用它並像這樣測試它並傳播代碼：
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) }
當值等於一位數字時，如何用前導零填充值？
[英]How can I pad a value with leading zeros when value equals to one digit number?
如何計算 javascript 中帶前導零的數字的位數？
[英]How can I count the number of digits of a number with leading zeros in javascript?
如何使用AngularJS過濾器格式化數字以具有前導零？
[英]How can I use an AngularJS filter to format a number to have leading zeros?
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.