Jak sformatować liczby, dodając 0 do liczb jednocyfrowych?

Chcę sformatować liczbę tak, aby zawierała dwie cyfry. Problem powstaje, gdy 0- 9zostanie przekazany, więc muszę go sformatować do 00- 09.

Czy w JavaScript jest formatyzator liczb?

Najlepsza metoda, jaką znalazłem, jest następująca:

_{(Uwaga: ta prosta wersja działa tylko dla dodatnich liczb całkowitych)}

var myNumber = 7;
var formattedNumber = ("0" + myNumber).slice(-2);
console.log(formattedNumber);

W przypadku miejsc po przecinku możesz użyć tego kodu (choć jest nieco niechlujny).

var myNumber = 7.5;
var dec = myNumber - Math.floor(myNumber);
myNumber = myNumber - dec;
var formattedNumber = ("0" + myNumber).slice(-2) + dec.toString().substr(1);
console.log(formattedNumber);

Wreszcie, jeśli masz do czynienia z możliwością występowania liczb ujemnych, najlepiej przechowywać znak, zastosować formatowanie do wartości bezwzględnej liczby i ponownie zastosować znak po fakcie. Zauważ, że ta metoda nie ogranicza liczby do 2 cyfr całkowitych. Zamiast tego ogranicza tylko liczbę na lewo od miejsca po przecinku (część całkowita). (Ta linia, która określa znak został znaleziony tutaj ).

var myNumber = -7.2345;
var sign = myNumber?myNumber<0?-1:1:0;
myNumber = myNumber * sign + ''; // poor man's absolute value
var dec = myNumber.match(/\.\d+$/);
var int = myNumber.match(/^[^\.]+/);

var formattedNumber = (sign < 0 ? '-' : '') + ("0" + int).slice(-2) + (dec !== null ? dec : '');
console.log(formattedNumber);

Jeśli liczba jest większa niż 9, przekonwertuj liczbę na ciąg znaków (spójność). W przeciwnym razie dodaj zero.

function n(n){
    return n > 9 ? "" + n: "0" + n;
}

n( 9); //Returns "09"
n(10); //Returns "10"
n(999);//Returns "999"

Użyj metody toLocaleString () w dowolnej liczbie. Tak więc dla liczby 6, jak pokazano poniżej, można uzyskać pożądane wyniki.

(6).toLocaleString('en-US', {minimumIntegerDigits: 2, useGrouping:false})

Wygeneruje ciąg „06”.

Oto prosta funkcja uzupełniania liczb, której zwykle używam. Pozwala na dowolną ilość wyściółki.

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

Przykłady:

leftPad(1, 2) // 01
leftPad(10, 2) // 10
leftPad(100, 2) // 100
leftPad(1, 3) // 001
leftPad(1, 8) // 00000001

We wszystkich nowoczesnych przeglądarkach możesz używać

numberStr.padStart(2, "0");

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

function zeroPad(numberStr) {
  return numberStr.padStart(2, "0");
}

var numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

numbers.forEach(
  function(num) {
    var numString = num.toString();
    
    var paddedNum = zeroPad(numString);

    console.log(paddedNum);
  }
);

@ Odpowiedź Lifehacka była dla mnie bardzo przydatna; gdzie myślę, że możemy to zrobić w jednym wierszu dla liczb dodatnich

 String(input).padStart(2, '0');

("0" + (date.getMonth() +　1)).slice(-2);
("0" + (date.getDay())).slice(-2);

Możesz to zrobić:

function pad2(number) {
   return (number < 10 ? '0' : '') + number
}

Przykład:

document.write(pad2(0) + '<br />');
document.write(pad2(1) + '<br />');
document.write(pad2(2) + '<br />');
document.write(pad2(10) + '<br />');
document.write(pad2(15) + '<br />');

Wynik:

00
01
02
10
15

Wygląda na to, że możesz mieć ciąg zamiast liczby. Użyj tego:

var num = document.getElementById('input').value,
    replacement = num.replace(/^(\d)$/, '0$1');
document.getElementById('input').value = replacement;

Oto przykład: http://jsfiddle.net/xtgFp/

Szybka i brudna jedna wkładka ....

function zpad(n, len) {
  return 0..toFixed(len).slice(2,-n.toString().length)+n.toString();
}

Jest to proste i działa całkiem dobrze:

function twoDigit(number) {
  var twodigit = number >= 10 ? number : "0"+number.toString();
  return twodigit;
}

Oto bardzo proste rozwiązanie, które działało dla mnie dobrze.

Najpierw zadeklaruj zmienną, która będzie zawierać Twój numer.

var number;

Teraz przekonwertuj liczbę na ciąg i trzymaj ją w innej zmiennej;

var numberStr = number.toString();

Teraz możesz przetestować długość tego ciągu, jeśli jest mniej niż pożądany, możesz na początku dodać „zero”.

if(numberStr.length < 2){
      number = '0' + number;
}

Teraz użyj numeru zgodnie z życzeniem

console.log(number);

Oto najprostsze rozwiązanie, jakie znalazłem: -

let num = 9; // any number between 0 & 99
let result = ( '0' + num ).substr( -2 );

Ulepszona wersja poprzedniej odpowiedzi

function atLeast2Digit(n){
    n = parseInt(n); //ex. if already passed '05' it will be converted to number 5
    var ret = n > 9 ? "" + n: "0" + n;
    return ret;
}

alert(atLeast2Digit(5));

Wiem, że to starożytny post, ale chciałem zaoferować bardziej elastyczną opcję OO.

Trochę ekstrapolowałem zaakceptowaną odpowiedź i rozszerzyłem obiekt javascript, Numberaby umożliwić regulację dopełniania zer:

Number.prototype.zeroPad = function(digits) {
  var loop = digits;
  var zeros = "";
  while (loop) {
    zeros += "0";
    loop--;
  }
  return (this.toString().length > digits) ?
    this.toString() : (zeros + this).slice(-digits);
}
var v = 5;
console.log(v.zeroPad(2)); // returns "05"
console.log(v.zeroPad(4)); // returns "0005"

Edycja: dodaj kod, aby zapobiec odcinaniu liczb dłuższych niż żądane cyfry.

UWAGA: Jest to przestarzałe we wszystkich oprócz IE. Użyj padStart()zamiast tego.

Nie ma wbudowanego formatyzatora liczb dla JavaScript, ale istnieją biblioteki, które to osiągają:

1. underscore.string zapewnia funkcję sprintf (wraz z wieloma innymi przydatnymi formatami)
2. javascript-sprintf , który podkreśla .string zapożycza z.

lub

function zpad(n,l){
   return rep(l-n.toString().length, '0') + n.toString();
}

z

function rep(len, chr) { 
   return new Array(len+1).join(chr);
}

Jeśli chcesz jednocześnie ograniczyć liczbę cyfr:

function pad2(number) {
  number = (number < 10 ? '0' : '') + number;
  number = number.substring(0,2);
  return number;
}

Spowodowałoby to również posiekanie dowolnej wartości przekraczającej dwie cyfry. Rozszerzyłem to na rozwiązanie Fanaura.

<html>
    <head>
        <script src="http://code.jquery.com/jquery-1.11.0.min.js"></script>
        <script type="text/javascript">
            $(document).ready(function(){
                $('#test').keypress(allowOnlyTwoPositiveDigts);
            });

            function allowOnlyTwoPositiveDigts(e){

                var test = /^[\-]?[0-9]{1,2}?$/
                return test.test(this.value+String.fromCharCode(e.which))
            }

        </script>
    </head>
    <body>
        <input id="test" type="text" />
    </body>
</html>

Oto proste rekurencyjne rozwiązanie, które działa dla dowolnej liczby cyfr.

function numToNDigitStr(num, n)
{
    if(num >=  Math.pow(10, n - 1)) { return num; }
    return "0" + numToNDigitStr(num, n-1);
}

Jeśli nie masz lodash w swoim projekcie, dodawanie całej biblioteki w celu korzystania z jednej funkcji będzie przesadą. To najbardziej wyrafinowane rozwiązanie twojego problemu, jakie kiedykolwiek widziałem.

_.padStart(num, 2, '0')

Oto moja wersja. Można go łatwo dostosować do innych scenariuszy.

function setNumericFormat(value) {
    var length = value.toString().length;
    if (length < 4) {
        var prefix = "";
        for (var i = 1; i <= 4 - length; i++) {
            prefix += "0";
        }
        return prefix + value.toString();
    }
    return  value.toString();
}

    function colorOf(r,g,b){
  var f = function (x) {
    return (x<16 ? '0' : '') + x.toString(16) 
  };

  return "#" +  f(r) + f(g) + f(b);
}

Dla każdego, kto chce mieć różnice czasowe i wyniki, które mogą przyjmować liczby ujemne, jest to dobre. pad (3) = „03”, pad (-2) = „-02”, pad (-234) = „-234”

pad = function(n){
  if(n >= 0){
    return n > 9 ? "" + n : "0" + n;
  }else{
    return n < -9 ? "" + n : "-0" + Math.abs(n);
  }
}

za pomocą tej funkcji możesz drukować z dowolną liczbą n cyfr

function frmtDigit(num, n) {
    isMinus = num < 0;
    if (isMinus)
        num *= -1;
    digit = '';
    if (typeof n == 'undefined')
        n = 2;//two digits
    for (i = 1; i < n; i++) {
        if (num < (1 + Array(i + 1).join("0")))
            digit += '0';
    }
    digit = (isMinus ? '-' : '') + digit + num;
    return digit;
};

mój przykład to :

<div id="showTime"></div>

    function x() {
    var showTime = document.getElementById("showTime");
    var myTime = new Date();
    var hour = myTime.getHours();
    var minu = myTime.getMinutes();
    var secs = myTime.getSeconds();
    if (hour < 10) {
        hour = "0" + hour
    };
    if (minu < 10) {
        minu = "0" + minu
    };
    if (secs < 10) {
        secs = "0" + secs
    };

    showTime.innerHTML = hour + ":" + minu + ":" + secs;
}

setInterval("x()", 1000)

`${number}`.replace(/^(\d)$/, '0$1');

Regex jest najlepszy.

Typ danych AS w JavaScript jest określany dynamicznie, traktuje 04 jako 4 Użyj instrukcji warunkowej, jeśli wartość jest mniejsza niż 10, a następnie dodaj 0 przed nią, ustawiając ciąg E.g,

var x=4;
  x = x<10?"0"+x:x
 console.log(x); // 04

Zbudowałem dość prostą funkcję formatu, którą wywołuję, gdy potrzebuję prostej daty sformatowanej. Zajmuje się formatowaniem pojedynczych cyfr na dwucyfrowe, gdy są mniejsze niż 10. Wyodrębnia datę sformatowaną jakoSat Sep 29 2018 - 00:05:44

Ta funkcja jest używana jako część zmiennej utils, dlatego jest nazywana:

let timestamp = utils._dateFormatter('your date string');

var utils = {
  _dateFormatter: function(dateString) {
    let d = new Date(dateString);
    let hours = d.getHours();
    let minutes = d.getMinutes();
    let seconds = d.getSeconds();
    d = d.toDateString();
    if (hours < 10) {
      hours = '0' + hours;
    }
    if (minutes < 10) {
      minutes = '0' + minutes;
    }
    if (seconds < 10) {
      seconds = '0' + seconds;
    }
    let formattedDate = d + ' - ' + hours + ':' + minutes + ':' + seconds;
    return formattedDate;
  }
}

Zaktualizowano dla funkcji strzałek ES6 (obsługiwane w prawie wszystkich nowoczesnych przeglądarkach, patrz CanIUse )

const formatNumber = n => ("0" + n).slice(-2);