Làm thế nào tôi có thể đệm một giá trị với số không hàng đầu?

Cách được đề xuất để ghi lại giá trị trong JavaScript là gì? Tôi tưởng tượng rằng tôi có thể xây dựng một chức năng tùy chỉnh để chuyển các số không thành một giá trị được đánh máy, nhưng tôi tự hỏi liệu có cách nào trực tiếp hơn để làm điều này không?

Lưu ý: Theo "zerofiled", ý tôi là nó theo nghĩa cơ sở dữ liệu của từ này (trong đó biểu diễn zerofills 6 chữ số của số 5 sẽ là "000005").

Lưu ý cho độc giả!

Như các nhà bình luận đã chỉ ra, giải pháp này là "thông minh", và như các giải pháp thông minh thường có, đó là bộ nhớ chuyên sâu và tương đối chậm. Nếu hiệu suất là mối quan tâm của bạn, đừng sử dụng giải pháp này!

Có khả năng lỗi thời : ECMAScript 2017 bao gồm String.prototype.padStart và Number.prototype.toLocaleString có ở đó kể từ ECMAScript 3.1. Thí dụ:

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

... sẽ xuất ra "-0000.10".

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

... sẽ xuất ra "-0000.1".

Một chức năng đơn giản là tất cả những gì bạn cần

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
}

bạn có thể nướng cái này vào thư viện nếu bạn muốn bảo tồn không gian tên hoặc bất cứ thứ gì. Giống như với phần mở rộng của jQuery .

Cách đơn giản. Bạn có thể thêm phép nhân chuỗi cho pad và biến nó thành một hàm.

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

Là một chức năng,

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

Tôi không thể tin tất cả các câu trả lời phức tạp ở đây ... Chỉ cần sử dụng điều này:

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

Tôi thực sự đã phải đưa ra một cái gì đó như thế này gần đây. Tôi nghĩ rằng phải có một cách để làm điều đó mà không cần sử dụng các vòng lặp.

Đây là những gì tôi đã đưa ra.

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

Sau đó, chỉ cần sử dụng nó cung cấp một số đến không pad:

> zeroPad(50,4);
"0050"

Nếu số lớn hơn phần đệm, số sẽ mở rộng ra ngoài phần đệm:

> zeroPad(51234, 3);
"51234"

Số thập phân cũng tốt!

> zeroPad(51.1234, 4);
"0051.1234"

Nếu bạn không ngại làm ô nhiễm không gian tên toàn cầu, bạn có thể thêm trực tiếp vào Số:

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

Và nếu bạn muốn có số thập phân chiếm không gian trong phần đệm:

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

Chúc mừng!

XDR đã đưa ra một biến thể logarit dường như hoạt động tốt hơn.

CẢNH BÁO : Hàm này không thành công nếu num bằng 0 (ví dụ: 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;
}

Nói về hiệu suất, tomsmeding so sánh 3 câu trả lời hàng đầu ( 4 với biến thể nhật ký ). Đoán cái nào majorly vượt trội so với hai người kia? :)

Đây là những gì tôi đã sử dụng để đệm một số tối đa 7 ký tự.

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

Cách tiếp cận này có thể sẽ đủ cho hầu hết mọi người.

Chỉnh sửa: Nếu bạn muốn làm cho nó chung chung hơn, bạn có thể làm điều này:

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

Chỉnh sửa 2: Lưu ý rằng kể từ ES2017, bạn có thể sử dụng String.prototype.padStart:

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

Các trình duyệt hiện đại hiện hỗ trợ padStart, giờ bạn có thể làm:

string.padStart(maxLength, "0");

Thí dụ:

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

Thật không may, có rất nhiều đề xuất phức tạp không cần thiết cho vấn đề này, thường liên quan đến việc viết hàm riêng của bạn để thực hiện thao tác toán học hoặc chuỗi hoặc gọi một tiện ích của bên thứ ba. Tuy nhiên, có một cách tiêu chuẩn để thực hiện việc này trong thư viện JavaScript cơ bản chỉ với một dòng mã. Có thể đáng để bọc một dòng mã này trong một hàm để tránh phải chỉ định các tham số mà bạn không bao giờ muốn thay đổi như tên hoặc kiểu cục bộ.

var amount = 5;

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

Điều này sẽ tạo ra giá trị "005" cho văn bản. Bạn cũng có thể sử dụng hàm toLocaleString của Number để đệm các số không ở bên phải dấu thập phân.

var amount = 5;

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

Điều này sẽ tạo ra giá trị "5,00" cho văn bản. Thay đổi useGrouping thành true để sử dụng dấu phẩy cho hàng nghìn.

Lưu ý rằng việc sử dụng toLocaleString()với localesvà optionsđối số được tiêu chuẩn hóa riêng biệt trong ECMA-402 , không phải trong ECMAScript. Cho đến hôm nay, một số trình duyệt chỉ thực hiện hỗ trợ cơ bản , tức là toLocaleString()có thể bỏ qua mọi đối số.

Ví dụ hoàn chỉnh

Nếu số điền được biết trước không vượt quá một giá trị nhất định, có một cách khác để làm điều này mà không có vòng lặp:

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

Các trường hợp thử nghiệm tại đây: http://jsfiddle.net/jfriend00/N87mZ/

Cách nhanh chóng và bẩn thỉu:

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

Với x = 5 và tính = 6 bạn sẽ có y = "000005"

Đây là một chức năng nhanh chóng tôi đã đưa ra để thực hiện công việc. Nếu bất cứ ai có một cách tiếp cận đơn giản hơn, hãy chia sẻ!

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

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

    return result;
}

Đến bữa tiệc muộn ở đây, nhưng tôi thường sử dụng cấu trúc này để thực hiện phần đệm đặc biệt của một số giá trị n, được gọi là số thập phân dương:

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

Trong trường hợp offsetlà 10 ^^ chữ số.

Ví dụ: Đệm đến 5 chữ số, trong đó n = 123:

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

Phiên bản thập lục phân của điều này dài hơn một chút:

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

Lưu ý 1: Tôi cũng thích giải pháp của @ profitehlolz, đây là phiên bản chuỗi của điều này, sử dụng tính năng chỉ mục phủ định tiện lợi của lát ().

Tôi thực sự không biết tại sao, nhưng không ai làm điều đó theo cách rõ ràng nhất. Đây là cách thực hiện của tôi.

Chức năng:

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

Nguyên mẫu:

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

Rất đơn giản, tôi không thể thấy bất kỳ cách nào có thể đơn giản hơn. Vì một số lý do tôi dường như nhiều lần ở đây trên SO, mọi người chỉ cố gắng tránh các vòng lặp 'cho' và 'trong khi' bằng bất cứ giá nào. Sử dụng regex có thể sẽ tốn nhiều chu kỳ hơn cho phần đệm 8 chữ số tầm thường như vậy.

Tôi sử dụng snipet này để có được một đại diện gồm 5 chữ số

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

ECMAScript 2017: sử dụng padStart hoặc padEnd

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

Thêm thông tin:

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

Sức mạnh của Toán học!

x = số nguyên cho pad
y = số lượng số 0 đến pad

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

Tôi không thấy ai chỉ ra thực tế rằng khi bạn sử dụng String.prototype.substr () với số âm, nó sẽ được tính từ bên phải.

Một giải pháp lót cho câu hỏi của OP, đại diện số 6 chữ số của số 5, là:

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

Tổng quát hóa chúng tôi sẽ nhận được:

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

Sau một thời gian dài, rất lâu để thử nghiệm 15 chức năng / phương pháp khác nhau được tìm thấy trong câu hỏi này, giờ đây tôi biết cái nào là tốt nhất (linh hoạt nhất và nhanh nhất).

Tôi đã lấy 15 hàm / phương thức từ các câu trả lời cho câu hỏi này và tạo một kịch bản để đo thời gian thực hiện 100 miếng đệm. Mỗi pad sẽ đệm số 9với2000 số không. Điều này có vẻ quá mức, và nó là, nhưng nó cung cấp cho bạn một ý tưởng tốt về quy mô của các chức năng.

Mã tôi đã sử dụng có thể được tìm thấy ở đây: https://gist.github.com/NextToNoth/6325915

Hãy tự sửa đổi và kiểm tra mã.

Để có được phương pháp linh hoạt nhất, bạn phải sử dụng một vòng lặp. Điều này là do với số lượng rất lớn những người khác có khả năng thất bại, trong khi đó, điều này sẽ thành công.

Vậy, sử dụng vòng lặp nào? Vâng, đó sẽ là một whilevòng lặp. Một forvòng lặp vẫn nhanh, nhưng một whilevòng lặp chỉ nhanh hơn một chút (vài ms) - và sạch hơn.

Câu trả lời như những người bằng Wilco, Aleksandar Toplekhoặc Vitim.ussẽ làm công việc hoàn hảo.

Cá nhân, tôi đã thử một cách tiếp cận khác. Tôi đã cố gắng sử dụng một hàm đệ quy để đệm chuỗi / số. Nó hoạt động tốt hơn các phương thức tham gia vào một mảng nhưng, vẫn không hoạt động nhanh như vòng lặp for.

Chức năng của tôi là:

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

Bạn có thể sử dụng chức năng của tôi có hoặc không có cài đặt biến đệm. Vì vậy, như thế này:

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

Cá nhân, sau khi thử nghiệm, tôi sẽ sử dụng một phương thức với vòng lặp while, như Aleksandar ToplekhoặcVitim.us . Tuy nhiên, tôi sẽ sửa đổi nó một chút để bạn có thể đặt chuỗi đệm.

Vì vậy, tôi sẽ sử dụng mã này:

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'

Bạn cũng có thể sử dụng nó như một chức năng nguyên mẫu, bằng cách sử dụng mã này:

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'

Tham số thứ nhất là bất kỳ số thực nào, tham số thứ hai là số nguyên dương chỉ định số chữ số tối thiểu ở bên trái dấu thập phân và tham số thứ ba là số nguyên dương tùy chọn chỉ định số nếu chữ số ở bên phải dấu thập phân.

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
}

vì thế

           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'

Đừng phát minh lại bánh xe, sử dụng chuỗi gạch dưới :

jsFiddle

var numToPad = '5';

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

Đây là giải pháp ES6.

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

Trong tất cả các trình duyệt hiện đại, bạn có thể sử dụng

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

Dưới đây là tài liệu tham khảo MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Không phải là câu hỏi này cần nhiều câu trả lời hơn, nhưng tôi nghĩ rằng tôi sẽ thêm phiên bản lodash đơn giản này.

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

Cách mới nhất để làm điều này đơn giản hơn nhiều:

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

output: "02"

Chỉ là một giải pháp khác, nhưng tôi nghĩ nó dễ đọc hơn.

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

Cái này ít bản địa hơn, nhưng có thể là nhanh nhất ...

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

Giải pháp của tôi

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

Sử dụng

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

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

Tại sao không sử dụng đệ quy?

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

Một số khỉ cũng hoạt động

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

...Vân vân.

Chúc mừng

Giải pháp đơn giản nhất , đơn giản nhất mà bạn sẽ tìm thấy.

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