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

Was ist die empfohlene Methode, um einen Wert in JavaScript auf Null zu setzen? Ich stelle mir vor, ich könnte eine benutzerdefinierte Funktion erstellen, um Nullen auf einen typisierten Wert aufzufüllen, aber ich frage mich, ob es einen direkteren Weg gibt, dies zu tun?

Hinweis: Mit "nullgefüllt" meine ich es im Datenbank-Sinne des Wortes (wobei eine 6-stellige nullgefüllte Darstellung der Zahl 5 "000005" wäre).

Hinweis für die Leser!

Wie Kommentatoren hervorgehoben haben, ist diese Lösung "clever", und wie clevere Lösungen oft sind, ist sie speicherintensiv und relativ langsam. Wenn Ihnen die Leistung ein Anliegen ist, verwenden Sie diese Lösung nicht!

Möglicherweise veraltet : ECMAScript 2017 enthält String.prototype.padStart und Number.prototype.toLocaleString ist seit ECMAScript 3.1 vorhanden. Beispiel:

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

... gibt "-0000.10" aus.

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

... gibt "-0000.1" aus.

Eine einfache Funktion ist alles was Sie brauchen

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
}

Sie können dies in eine Bibliothek backen, wenn Sie den Namespace oder was auch immer beibehalten möchten. Wie bei jQuery's Extend .

Einfacher Weg. Sie können eine Zeichenfolgenmultiplikation für das Pad hinzufügen und es in eine Funktion umwandeln.

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

Als eine Funktion,

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

Ich kann all die komplexen Antworten hier nicht glauben ... Verwenden Sie einfach Folgendes:

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

Ich musste mir in letzter Zeit tatsächlich so etwas einfallen lassen. Ich dachte, es müsste einen Weg geben, dies ohne Schleifen zu tun.

Das habe ich mir ausgedacht.

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

Verwenden Sie es dann einfach und geben Sie eine Zahl für das Nullfeld an:

> zeroPad(50,4);
"0050"

Wenn die Zahl größer als die Auffüllung ist, wird die Zahl über die Auffüllung hinaus erweitert:

> zeroPad(51234, 3);
"51234"

Dezimalstellen sind auch in Ordnung!

> zeroPad(51.1234, 4);
"0051.1234"

Wenn es Ihnen nichts ausmacht, den globalen Namespace zu verschmutzen, können Sie ihn direkt zu Number hinzufügen:

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

Und wenn Sie lieber Dezimalstellen haben möchten, nehmen Sie Platz in der Polsterung ein:

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

Prost!

XDR hat eine logarithmische Variation entwickelt , die anscheinend eine bessere Leistung erbringt.

WARNUNG : Diese Funktion schlägt fehl, wenn num gleich Null ist (z. B. 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;
}

Apropos Leistung: Tomsmeding verglich die drei besten Antworten ( 4 mit der logarithmischen Variation ). Ratet mal, welches die beiden anderen deutlich übertroffen hat? :) :)

Hier ist, was ich verwendet habe, um eine Zahl mit bis zu 7 Zeichen aufzufüllen.

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

Dieser Ansatz wird wahrscheinlich für die meisten Menschen ausreichen.

Bearbeiten: Wenn Sie es allgemeiner machen möchten, können Sie dies tun:

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

Bearbeiten 2: Beachten Sie, dass Sie seit ES2017 Folgendes verwenden können String.prototype.padStart:

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

Moderne Browser unterstützen jetzt padStart, Sie können jetzt einfach tun:

string.padStart(maxLength, "0");

Beispiel:

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

Leider gibt es viele unnötig komplizierte Vorschläge für dieses Problem, die normalerweise das Schreiben einer eigenen Funktion zur Durchführung von Mathematik- oder Zeichenfolgenmanipulationen oder das Aufrufen eines Dienstprogramms eines Drittanbieters umfassen. Es gibt jedoch eine Standardmethode in der Basis-JavaScript-Bibliothek mit nur einer Codezeile. Es kann sinnvoll sein, diese eine Codezeile in eine Funktion einzubinden, um zu vermeiden, dass Sie Parameter angeben müssen, die Sie niemals ändern möchten, wie z. B. den lokalen Namen oder Stil.

var amount = 5;

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

Dies erzeugt den Wert "005" für Text. Sie können auch die toLocaleString-Funktion von Number verwenden, um Nullen auf der rechten Seite des Dezimalpunkts aufzufüllen.

var amount = 5;

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

Dies ergibt den Wert "5.00" für Text. Ändern Sie useGrouping in true, um Komma-Trennzeichen für Tausende zu verwenden.

Beachten Sie, dass die Verwendung toLocaleString()mit localesund optionsArgumenten in ECMA-402 separat standardisiert ist , nicht in ECMAScript. Ab heute implementieren einige Browser nur die grundlegende Unterstützung , dh toLocaleString()sie ignorieren möglicherweise alle Argumente.

Vollständiges Beispiel

Wenn im Voraus bekannt ist, dass die Füllnummer einen bestimmten Wert nicht überschreitet, gibt es eine andere Möglichkeit, dies ohne Schleifen zu tun:

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

Testfälle hier: http://jsfiddle.net/jfriend00/N87mZ/

Der schnelle und schmutzige Weg:

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

Für x = 5 und count = 6 haben Sie y = "000005"

Hier ist eine kurze Funktion, die ich mir ausgedacht habe, um die Arbeit zu erledigen. Wenn jemand einen einfacheren Ansatz hat, können Sie ihn gerne teilen!

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

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

    return result;
}

Spät zur Party hier, aber ich benutze dieses Konstrukt oft, um Ad-hoc-Auffüllungen mit einem Wert ndurchzuführen, der als positive Dezimalzahl bekannt ist:

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

Wo offsetist 10 ^^ Ziffern.

ZB Auffüllen auf 5 Stellen, wobei n = 123:

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

Die hexadezimale Version davon ist etwas ausführlicher:

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

Anmerkung 1: Ich mag auch die Lösung von @ profitehlolz, bei der es sich um die String-Version handelt, bei der die raffinierte Negativindex-Funktion von Slice () verwendet wird.

Ich weiß wirklich nicht warum, aber niemand hat es auf die offensichtlichste Weise getan. Hier ist meine Implementierung.

Funktion:

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

Prototyp:

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

Sehr einfach, ich kann nicht sehen, wie dies einfacher sein kann. Aus irgendeinem Grund habe ich hier auf SO oft den Eindruck, dass die Leute nur versuchen, "for" - und "while" -Schleifen um jeden Preis zu vermeiden. Die Verwendung von Regex kostet wahrscheinlich viel mehr Zyklen für eine so triviale 8-stellige Auffüllung.

Ich benutze dieses Snipet, um eine 5-stellige Darstellung zu erhalten

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

ECMAScript 2017: Verwenden Sie padStart oder padEnd

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

Mehr Info:

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

Die Kraft der Mathematik!

x = Ganzzahl zum Auffüllen
y = Anzahl der Nullen zum Auffüllen

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

Ich habe niemanden darauf hinweisen sehen, dass wenn Sie String.prototype.substr () mit einer negativen Zahl verwenden, dies von rechts zählt.

Eine einzeilige Lösung für die Frage des OP, eine 6-stellige nullgefüllte Darstellung der Zahl 5, lautet:

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

Verallgemeinernd werden wir bekommen:

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

Nach einer langen, langen Zeit des Testens von 15 verschiedenen Funktionen / Methoden, die in diesen Fragen gefunden wurden, weiß ich jetzt, welche die besten (die vielseitigsten und schnellsten) sind.

Ich habe 15 Funktionen / Methoden aus den Antworten auf diese Frage genommen und ein Skript erstellt, um die Zeit zu messen, die für die Ausführung von 100 Pads benötigt wird. Jedes Pad würde die Zahl 9mit 2000Nullen auffüllen. Dies mag übertrieben erscheinen, ist es aber, aber es gibt Ihnen eine gute Vorstellung von der Skalierung der Funktionen.

Den von mir verwendeten Code finden Sie hier: https://gist.github.com/NextToNothing/6325915

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

Um die vielseitigste Methode zu erhalten, müssen Sie eine Schleife verwenden. Dies liegt daran, dass bei sehr großen Zahlen andere wahrscheinlich scheitern, während dies erfolgreich sein wird.

Also, welche Schleife soll verwendet werden? Nun, das wäre eine whileSchleife. Eine forSchleife ist immer noch schnell, aber eine whileSchleife ist nur etwas schneller (ein paar ms) - und sauberer.

Antworten wie die von Wilco, Aleksandar Toplekoder Vitim.usden Job perfekt machen.

Persönlich habe ich einen anderen Ansatz versucht. Ich habe versucht, eine rekursive Funktion zu verwenden, um die Zeichenfolge / Nummer aufzufüllen. Es funktionierte besser als Methoden, die einem Array beitreten, funktionierte 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 Füllvariablen verwenden. Also so:

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

Persönlich würde ich nach meinen Tests eine Methode mit einer while-Schleife verwenden, wie Aleksandar Toplekoder Vitim.us. Ich würde es jedoch leicht ändern, damit Sie die Füllzeichenfolge festlegen können.

Also würde ich 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 es auch als Prototypfunktion 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'

Der erste Parameter ist eine beliebige reelle Zahl, der zweite Parameter ist eine positive Ganzzahl, die die minimale Anzahl von Stellen links vom Dezimalpunkt angibt, und der dritte Parameter ist eine optionale positive Ganzzahl, die die Zahl angibt, wenn die Ziffern rechts vom Dezimalpunkt stehen.

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
}

damit

           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'

Das Rad nicht neu erfinden, Unterstrich verwenden :

jsFiddle

var numToPad = '5';

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

Dies ist die ES6-Lösung.

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

In allen modernen Browsern können Sie verwenden

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

Hier ist die MDN-Referenz https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Nicht, dass diese Frage mehr Antworten benötigt, aber ich dachte, ich würde die einfache lodash-Version hinzufügen.

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

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

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

output: "02"

Nur eine andere Lösung, aber ich denke, es ist besser lesbar.

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

Dieser ist weniger einheimisch, kann aber der schnellste sein ...

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

Meine Lösung

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

Verwendungszweck

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

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

Warum nicht Rekursion verwenden?

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

Einige Monkeypatching funktioniert auch

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

...usw.

Prost

Die einfachste und einfachste Lösung, die Sie finden werden.

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