Tengo un archivo que se cargó y que está formateado así

MR 1

MR 2

MR 100

MR 200

Señor 300

ETC.

Lo que tengo que hacer es agregar dos 00 adicionales antes de cualquier cosa antes de MR 10 y agregar un 0 adicional antes de MR10-99

Entonces los archivos están formateados

Señor 001

Señor 010

Señor 076

ETC.

¡Cualquier ayuda sería genial!

Suponiendo que tiene esos valores almacenados en algunas cadenas, intente esto:

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"

Tengo una solución potencial que supongo que es relevante, la publiqué aquí:

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

Básicamente, quieres una longitud mínima de 2 o 3, puedes ajustar cuántos ceros pones en este código.

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

Sabía que siempre obtendría un único entero como mínimo (porque hora 1, hora 2), etc., pero si no puede estar seguro de obtener nada más que una cadena vacía, puede simplemente hacer "000" + d.getHours ( ) para asegurarse de obtener el mínimo.

entonces quieres 3 números? solo use -3 en lugar de -2 en mi código, solo estoy escribiendo esto porque quería construir un reloj de 24 horas de una manera súper fácil.

Nota: consulte la Actualización 2 si está utilizando la última versión de ECMAScript ...

Aquí una solución que me gustó por su simplicidad de una respuesta a una pregunta similar :

var n = 123

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

ACTUALIZAR

Como sugirió @RWC, por supuesto, puede envolver esto muy bien en una función genérica como esta:

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

leftPad(123, 5); // returns 00123

Y para aquellos a los que no les gusta la rebanada:

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

Pero si el rendimiento importa, recomiendo leer la respuesta vinculada antes de elegir una de las soluciones sugeridas.

ACTUALIZACIÓN 2

En ES6, la clase String ahora viene con un padStartmétodo incorporado que agrega caracteres iniciales a una cadena. Consulte MDN aquí para obtener referencias String.prototype.padStart(). Y también hay un padEndmétodo para terminar personajes.

Entonces, con ES6 se volvió tan simple como:

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"

Esta es la función que generalmente uso en mi código para anteponer ceros a un número o cadena.

Las entradas son la cadena o número (str) y la longitud deseada de la salida (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;
}

};

Ejemplos:

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

Si divide en el espacio, puede agregar ceros a la izquierda usando una función simple como:

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

Entonces puede probar la longitud de la cadena y si es menor que 6, divida el espacio, agregue ceros al número y luego vuelva a unirlo.

O como expresión regular:

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

Estoy seguro de que alguien puede hacerlo con un reemplazo, no con dos.

Editar - ejemplos

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

Pondrá uno o dos ceros delante de un número al final de una cadena con un espacio delante. No importa qué parte antes del espacio esté.

Solo para reírse, hágalo de la manera larga y desagradable ....:
(NOTA: ¡No he usado esto, y no recomendaría usar esto!)

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

Yo mismo necesitaba algo como esto el otro día, Pud en lugar de siempre un 0, quería poder decirle lo que quería acolchado en el frente. Esto es lo que se me ocurrió para el código:

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

Donde n es lo que desea rellenar, e es la potencia a la que desea rellenar (número de caracteres que debería tener) y d es con lo que quiere que se rellene. Parece funcionar bien para lo que lo necesitaba, pero fallaría si "d" tuviera más de un carácter en algunos casos.

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

¡Funcionó para mí! Para aumentar los ceros, actualice la variable ' max '

URL de trabajo de Fiddle: ¿ Agregar ceros adicionales delante de un número usando jQuery? :

str podría ser un número o una cadena.

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

Agregue más ceros si necesita dígitos grandes

En términos simples, podemos escribir lo siguiente:

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

// Porque la mayoría de las veces lo necesitamos por cuestiones de día, mes o cantidad.

Sepa que esta es una publicación antigua, pero aquí hay otra forma corta y efectiva:

editar: dur. si num no es una cadena, agregaría:

len -= String(num).length;

si no, está todo bien

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

Agregando 100 al número, luego ejecute una función de subcadena desde el índice 1 hasta la última posición a la derecha.

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

obtendrá este resultado a partir de la fecha de 2020-11-3

11,03

Espero que la respuesta sea de utilidad

Intente seguir, que convertirá los números de uno y dos dígitos en números de 3 dígitos con un prefijo de ceros.

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