Ich habe hochgeladene Dateien, die so formatiert sind

MR 1

MR 2

MR 100

MR 200

MR 300

ETC.

Was ich tun muss, ist zwei zusätzliche 00s vor irgendetwas vor MR 10 und eine zusätzliche 0 vor MR10-99 hinzuzufügen

Dateien werden also formatiert

MR 001

MR 010

MR 076

ETC.

Jede Hilfe wäre toll!

Angenommen, Sie haben diese Werte in einigen Zeichenfolgen gespeichert, versuchen Sie Folgendes:

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

pad("3", 3);    // => "003"
pad("123", 3);  // => "123"
pad("1234", 3); // => "1234"

var test = "MR 2";
var parts = test.split(" ");
parts[1] = pad(parts[1], 3);
parts.join(" "); // => "MR 002"

Ich habe eine mögliche Lösung, die meiner Meinung nach relevant ist. Ich habe hier darüber geschrieben:

https://www.facebook.com/antimatterstudios/posts/10150752380719364

Wenn Sie eine Mindestlänge von 2 oder 3 möchten, können Sie anpassen, wie viele Nullen Sie in diesen Code einfügen

var d = new Date();
var h = ("0"+d.getHours()).slice(-2);
var m = ("0"+d.getMinutes()).slice(-2);
var s = ("0"+d.getSeconds()).slice(-2);

Ich wusste, dass ich immer mindestens eine einzelne Ganzzahl erhalten würde (Ursache Stunde 1, Stunde 2) usw., aber wenn Sie nicht sicher sind, ob Sie etwas anderes als eine leere Zeichenfolge erhalten, können Sie einfach "000" + d.getHours ( ) um sicherzustellen, dass Sie das Minimum erhalten.

dann willst du 3 nummern? Verwenden Sie einfach -3 anstelle von -2 in meinem Code. Ich schreibe dies nur, weil ich auf super einfache Weise eine 24-Stunden-Uhr erstellen wollte.

Hinweis: Siehe Update 2, wenn Sie das neueste ECMAScript verwenden ...

Hier eine Lösung, die mir wegen ihrer Einfachheit von einer Antwort auf eine ähnliche Frage gefallen hat :

var n = 123

String('00000' + n).slice(-5); // returns 00123
('00000' + n).slice(-5);       // returns 00123

AKTUALISIEREN

Wie @RWC vorgeschlagen hat, können Sie dies natürlich gut in eine generische Funktion wie diese einbinden:

function leftPad(value, length) { 
    return ('0'.repeat(length) + value).slice(-length); 
}

leftPad(123, 5); // returns 00123

Und für diejenigen, die das Stück nicht mögen:

function leftPad(value, length) {
    value = String(value);
    length = length - value.length;
    return ('0'.repeat(length) + value)
}

Wenn es jedoch auf die Leistung ankommt, empfehle ich, die verknüpfte Antwort durchzulesen, bevor Sie eine der vorgeschlagenen Lösungen auswählen.

UPDATE 2

In ES6 enthält die String-Klasse jetzt eine integrierte padStartMethode, mit der einem String führende Zeichen hinzugefügt werden. Überprüfen Sie MDN hier als Referenz auf String.prototype.padStart(). Und es gibt auch eine padEndMethode zum Beenden von Zeichen.

Mit ES6 wurde es so einfach wie:

var n = 123;
n.padStart(5, '0'); // returns 00123

function addLeadingZeros (n, length)
{
    var str = (n > 0 ? n : -n) + "";
    var zeros = "";
    for (var i = length - str.length; i > 0; i--)
        zeros += "0";
    zeros += str;
    return n >= 0 ? zeros : "-" + zeros;
}

//addLeadingZeros (1, 3) =   "001"
//addLeadingZeros (12, 3) =  "012"
//addLeadingZeros (123, 3) = "123"

Dies ist die Funktion, die ich normalerweise in meinem Code verwende, um einer Zahl oder Zeichenfolge Nullen voranzustellen.

Die Eingaben sind die Zeichenfolge oder Zahl (str) und die gewünschte Länge der Ausgabe (len).

var PrependZeros = function (str, len) {
    if(typeof str === 'number' || Number(str)){
    str = str.toString();
    return (len - str.length > 0) ? new Array(len + 1 - str.length).join('0') + str: str;
}
else{
    for(var i = 0,spl = str.split(' '); i < spl.length; spl[i] = (Number(spl[i])&& spl[i].length < len)?PrependZeros(spl[i],len):spl[i],str = (i == spl.length -1)?spl.join(' '):str,i++);
    return str;
}

};

Beispiele:

PrependZeros('MR 3',3);    // MR 003
PrependZeros('MR 23',3);   // MR 023
PrependZeros('MR 123',3);  // MR 123
PrependZeros('foo bar 23',3);  // foo bar 023

Wenn Sie das Leerzeichen teilen, können Sie führende Nullen mit einer einfachen Funktion wie der folgenden hinzufügen:

function addZeros(n) {
  return (n < 10)? '00' + n : (n < 100)? '0' + n : '' + n;
}

Sie können also die Länge der Zeichenfolge testen. Wenn sie kleiner als 6 ist, teilen Sie das Leerzeichen auf, fügen Sie der Zahl Nullen hinzu und fügen Sie sie dann wieder zusammen.

Oder als regulärer Ausdruck:

function addZeros(s) {
  return s.replace(/ (\d$)/,' 00$1').replace(/ (\d\d)$/,' 0$1');
}

Ich bin sicher, jemand kann es mit einem Ersatz tun, nicht mit zwei.

Bearbeiten - Beispiele

alert(addZeros('MR 3'));    // MR 003
alert(addZeros('MR 23'));   // MR 023
alert(addZeros('MR 123'));  // MR 123
alert(addZeros('foo bar 23'));  // foo bar 023

Es werden ein oder zwei Nullen vor eine Zahl am Ende einer Zeichenfolge mit einem Leerzeichen davor gesetzt. Es ist egal, was vor dem Raum ist.

Nur zum Lachen, mach es auf die lange, böse Art ....:
(HINWEIS: Ich habe das nicht benutzt, und ich würde nicht raten, es zu benutzen.!)

function pad(str, new_length) {
    ('00000000000000000000000000000000000000000000000000' + str).
    substr((50 + str.toString().length) - new_length, new_length)
}

Ich brauchte neulich selbst so etwas, Pud statt immer eine 0, ich wollte sagen können, was ich vorne gepolstert haben wollte. Folgendes habe ich mir für Code ausgedacht:

function lpad(n, e, d) {
  var o = ''; if(typeof(d) === 'undefined'){ d='0'; } if(typeof(e) === 'undefined'){ e=2; }
  if(n.length < e){ for(var r=0; r < e - n.length; r++){ o += d; } o += n; } else { o=n; }
  return o; }

Wobei n das ist, was Sie auffüllen möchten, e die Leistung, auf die es aufgefüllt werden soll (Anzahl der Zeichen, die es sein soll), und d ist das, mit dem es aufgefüllt werden soll. Scheint gut zu funktionieren für das, wofür ich es brauchte, aber es würde fehlschlagen, wenn "d" in einigen Fällen mehr als ein Zeichen lang wäre.

var str = "43215"; 
console.log("Before : \n string :"+str+"\n Length :"+str.length);
var max = 9;
while(str.length < max ){
                                str = "0" + str;

                        }
console.log("After : \n string :"+str+"\n Length :"+str.length);

Es hat bei mir funktioniert! Aktualisieren Sie die Variable ' max ', um die Nullen zu erhöhen

Working Fiddle URL: Hinzufügen zusätzlicher Nullen vor einer Zahl mit jQuery? ::

str kann eine Zahl oder eine Zeichenfolge sein.

formatting("hi",3);
function formatting(str,len)
{
   return ("000000"+str).slice(-len);
}

Fügen Sie weitere Nullen hinzu, wenn Sie große Ziffern benötigen

In einfachen Worten können wir wie folgt schreiben:

for(var i=1;i<=31;i++)
    i=(i<10) ? '0'+i : i;

// Weil wir dies meistens für Tag, Monat oder Menge benötigen.

Wisse, dass dies ein alter Beitrag ist, aber hier ist ein weiterer kurzer, effektiver Weg:

bearbeiten: dur. Wenn num kein String ist, würden Sie hinzufügen:

len -= String(num).length;

sonst ist alles gut

function addLeadingZeros(sNum, len) {
    len -= sNum.length;
    while (len--) sNum = '0' + sNum;
    return sNum;
}

Führen Sie durch Hinzufügen von 100 zur Zahl eine Teilzeichenfolgenfunktion von Index 1 bis zur letzten Position rechts aus.

var dt = new Date();
var month = (100 + dt.getMonth()+1).toString().substr(1, 2);
var day = (100 + dt.getDate()).toString().substr(1, 2);

console.log(month,day);

Sie erhalten dieses Ergebnis ab dem Datum 2020-11-3

11,03

Ich hoffe die Antwort ist nützlich

Versuchen Sie Folgendes: Konvertieren Sie ein- und zweistellige Zahlen in dreistellige Zahlen, indem Sie Nullen voranstellen.

var base_number = 2;
var zero_prefixed_string = ("000" + base_number).slice(-3);