Wie kann ich einen Wert mit führenden Nullen auffüllen?

Question

Was ist der empfohlene Weg, um einen Wert in JavaScript mit Nullen zu füllen? Ich kann mir vorstellen, dass ich eine benutzerdefinierte Funktion zum Auffüllen von Nullen auf einen eingegebenen Wert bauen könnte, aber ich frage mich, ob es einen direkteren Weg gibt, dies zu tun?

Anmerkung: Mit "zerofilled" meine ich es im Sinne des Wortes in der Datenbank (wo eine 6-stellige zerofilled Darstellung der Zahl 5 "000005" wäre).

Answer 1

Nach langem, langem Testen von 15 verschiedenen Funktionen/Methoden, die in den Antworten auf diese Fragen zu finden sind, weiß ich jetzt, welche die beste ist (die vielseitigste und schnellste).

Ich habe 15 Funktionen/Methoden aus den Antworten auf diese Frage genommen und ein Skript erstellt, um die Zeit für die Ausführung von 100 Auffüllungen zu messen. Jeder Pad würde die Zahl 9 con 2000 Nullen. Das mag übertrieben erscheinen, und das ist es auch, aber es gibt Ihnen eine gute Vorstellung von der Skalierung der Funktionen.

Der von mir verwendete Code ist hier zu finden: https://gist.github.com/NextToNothing/6325915

Sie können den Code gerne selbst ändern und testen.

Um die vielseitigste Methode zu erhalten, müssen Sie eine Schleife verwenden. Der Grund dafür ist, dass bei sehr großen Zahlen andere Methoden wahrscheinlich scheitern, während diese Methode erfolgreich sein wird.

Welche Schleife soll ich also verwenden? Nun, das wäre eine while Schleife. A for Schleife ist immer noch schnell, aber eine while Schleife ist nur geringfügig schneller (ein paar ms) - und sauberer.

Antworten wie die von Wilco , Aleksandar Toplek o Vitim.us wird die Aufgabe perfekt erfüllen.

Ich persönlich habe einen anderen Ansatz gewählt. Ich habe versucht, eine rekursive Funktion zum Auffüllen der Zeichenfolge/Zahl zu verwenden. Es funktionierte besser als Methoden, die ein Array verbinden, aber immer noch nicht so schnell wie eine for-Schleife.

Meine Funktion ist:

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

Sie können meine Funktion mit oder ohne Einstellung der Padding-Variable verwenden. Also etwa so:

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

Ich persönlich würde nach meinen Tests eine Methode mit einer while-Schleife verwenden, etwa Aleksandar Toplek o Vitim.us . Ich würde es jedoch leicht abändern, so dass Sie die Auffüllzeichenfolge festlegen können.

Ich würde also diesen Code verwenden:

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'

Sie können sie auch als Prototyp-Funktion verwenden, indem Sie diesen Code verwenden:

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'

Answer 2

Der erste Parameter ist eine beliebige reelle Zahl, der zweite Parameter ist eine positive ganze Zahl, die die Mindestanzahl der Stellen links vom Dezimalpunkt angibt, und der dritte Parameter ist eine optionale positive ganze Zahl, die die Anzahl der Stellen rechts vom Dezimalpunkt angibt.

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
}

also

           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'

Answer 3

Der neueste Weg, dies zu tun, ist viel einfacher:

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

output: "02"

Answer 4

Das ist nur eine andere Lösung, aber ich denke, sie ist besser lesbar.

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

  return text;
}

Answer 5

Diese ist weniger nativ, aber vielleicht die schnellste...

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