padleft - padstart javascript

Javascript que agrega ceros al principio de una cadena(longitud máxima 4 caracteres)

Question

var number = 1310;

debe quedar solo.

var number = 120;

debe cambiarse a "0120";

var number = 10;

debe cambiarse a "0010";

var number = 7;

debe cambiarse a "0007";

Answer 1

Aquí hay otra manera. Proviene de algo que hice que debe hacerse miles de veces en una carga de página. Es bastante eficiente para la CPU codificar una cadena de ceros una vez, y cortar tantas veces como sea necesario para el pad tantas veces como sea necesario. Realmente me gusta el poder del método de 10, eso es bastante flexible.

De todos modos, esto es tan eficiente como podría llegar a:

Para la pregunta original, ELIGE UNO de los casos ...

var number = 1310;
var number = 120;
var number = 10;
var number = 7;

entonces

// only needs to happen once 
var zeroString = "00000";

// one assignment gets the padded number
var paddedNum = zeroString.substring((number + "").length, 4) + bareNum;

//output
alert("The padded number string is: " + paddedNum);

Por supuesto, todavía necesita validar la entrada. Porque esto SOLO funciona de manera confiable bajo las siguientes condiciones:

• El número de ceros en la cadena de ceros es deseados_longitud + 1
• El número de dígitos en su número inicial es menor o igual a su longitud deseada

Backstory:

Tengo un caso que necesita una longitud fija (14 dígitos) con número rellenado con cero. Quería ver qué tan básico podía hacer esto. Se ejecuta decenas de miles de veces en una carga de página, por lo que la eficiencia importa. No es tan reutilizable como es, y es poco elegante. Excepto que es muy muy simple.

Para los n dígitos de la cadena rellenada, este método requiere una cadena de (al menos) n + 1 ceros. El índice 0 es el primer carácter de la cadena, que nunca se utilizará, por lo que realmente podría ser cualquier cosa.

Tenga en cuenta también que string.substring () es diferente de string.substr () !

var bareNum = 42 + '''';  
var zeroString = "000000000000000";
var paddedNum = zeroString.substring(bareNumber.length, 14) + bareNum

Esto extrae los ceros de zeroString comenzando en la posición que coincide con la longitud de la cadena, y continúa obteniendo los ceros a la longitud necesaria de 14. Siempre que "14" en la tercera línea sea un número entero menor que el número de caracteres en zeroString , funcionará.

Answer 2

En todos los navegadores modernos puedes usar

numberStr.padStart(4, "0");

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

function zeroPad(num) {
  return num.toString().padStart(4, "0");
}

var numbers = [1310, 120, 10, 7];

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

    console.log(paddedNum);
  }
);

Answer 3

Nate, como es la mejor manera que he encontrado, es demasiado largo para leer. Por eso te proporciono 3 soluciones simples.

1. Así que aquí está mi simplificación de la respuesta de Nate.

//number = 42
"0000".substring(number.toString().length, 4) + number;

2. Aquí hay una solución que lo hace más reutilizable mediante el uso de una función que toma el número y la longitud deseada en los parámetros.

function pad_with_zeroes(number, len) {
  var zeroes = "0".repeat(len);
  return zeroes.substring(number.toString().length, len) + number;
}

// Usage: pad_with_zeroes(42,4);
// Returns "0042"

3. Aquí hay una tercera solución, extendiendo el prototipo Número.

Number.prototype.toStringMinLen = function(len) {
  var zeroes = "0".repeat(len);
  return zeroes.substring(self.toString().length, len) + self;
}

//Usage: tmp=42; tmp.toStringMinLen(4)

Answer 4

Sin bucle, sin funciones.

let n = "" + 100;
let x = ("0000000000" + n).substring(n.length);//add your amount of zeros
alert(x + "-" + x.length);

Answer 5

Un enfoque que me gusta es agregar 10 ^ N al número, donde N es el número de ceros que desea. Trate el número resultante como una cadena y corte el dígito cero. Por supuesto, querrás tener cuidado si tu número de entrada puede ser mayor que la longitud de tu pad, pero aún así es mucho más rápido que el método de bucle:

// You want to pad four places:
>>> var N = Math.pow(10, 4)
>>> var number = 1310
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"1310"
>>> var number = 120
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"0120"
>>> var number = 10
>>> number < N ? ("" + (N + number)).slice(1) : "" + number
"0010"
…

Puede convertir esto en una función con bastante facilidad:

/**
 * Pad a number with leading zeros to "pad" places:
 *
 * @param number: The number to pad
 * @param pad: The maximum number of leading zeros
 */
function padNumber(number, pad) {
    var N = Math.pow(10, pad);
    return number < N ? ("" + (N + number)).slice(1) : "" + number
}

Answer 6

Utilice la función librairy String.JS padLeft:

S(''123'').padLeft(5, ''0'').s   --> 00123

Answer 7

prueba estos

(''0000'' + number).slice(-4);

o

(number+'''').padStart(4,''0'');

Answer 8

//to: 0 - to left, 1 - to right
String.prototype.pad = function(_char, len, to) {
    if (!this || !_char || this.length >= len) {
        return this;
    }
    to = to || 0;

    var ret = this;

    var max = (len - this.length)/_char.length + 1;
    while (--max) {
        ret = (to) ? ret + _char : _char + ret;
    }

    return ret;
};

Uso:

someString.pad(neededChars, neededLength)

Ejemplo:

''332''.pad(''0'', 6); //''000332''
''332''.pad(''0'', 6, 1); //''332000''

Answer 9

function pad(n, len) {
  return (new Array(len + 1).join(''0'') + n).slice(-len);
}

podría no funcionar en versiones antiguas de IE.

Answer 10

function pad_with_zeroes(number, length) {

    var my_string = '''' + number;
    while (my_string.length < length) {
        my_string = ''0'' + my_string;
    }

    return my_string;

}