Pad-un număr cu zero în JavaScript

Nu este o mulțime de "scris", merge atât de departe:

function pad(n, width, z) {
  z = z || '0';
  n = n + '';
  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
}

Când inițializați o matrice cu un număr, se creează o matrice cu "lungime" setat la valoarea respectivă, astfel încât matrice pare să conțină că mulți "nedefinit" elemente. Deși unele Matrice exemplu metode de a sări peste elementele de matrice fără valori, .join() nu't, sau cel puțin nu complet; tratează-le ca și în cazul lor valoarea este un șir gol. Astfel vei obtine o copie de caracter zero (sau orice altceva "z" e) între fiecare dintre elementele de matrice; ca's de ce nu's un + 1 acolo.

Exemplu de utilizare:

pad(10, 4);      // 0010
pad(9, 4);       // 0009
pad(123, 4);     // 0123

pad(10, 4, '-'); // --10

Încercați:

String.prototype.lpad = function(padString, length) {
    var str = this;
    while (str.length < length)
        str = padString + str;
    return str;
}

Acum testul:

var str = "5";
alert(str.lpad("0", 4)); //result "0005"
var str = "10"; // note this is string type
alert(str.lpad("0", 4)); //result "0010"

[DEMO][1]

În ECMAScript 8 , avem nouă metodă padStart și padEnd, care are sintaxa de mai jos.

'string'.padStart(targetLength [,padString]):

Deci, acum putem folosi

const str = "5";
str.padStart(4, '0'); // '0005'

Ciudat, am avut recent pentru a face acest lucru.

function padDigits(number, digits) {
    return Array(Math.max(digits - String(number).length + 1, 0)).join(0) + number;
}

Utilizați, cum ar fi:

padDigits(9, 4);  // "0009"
padDigits(10, 4); // "0010"
padDigits(15000, 4); // "15000"

Nu frumos, dar eficient.

Ai spus că a avut un număr-

String.prototype.padZero= function(len, c){
    var s= '', c= c || '0', len= (len || 2)-this.length;
    while(s.length

Ai putea face ceva de genul asta:

function pad ( num, size ) {
  return ( Math.pow( 10, size ) + ~~num ).toString().substring( 1 );
}

Edit: Asta a fost doar o idee de bază pentru o funcție, dar pentru a adăuga suport pentru un număr mai mare (la fel de bine ca invalid input), probabil ar fi mai bine:

function pad ( num, size ) {
  if (num.toString().length >= size) return num;
  return ( Math.pow( 10, size ) + Math.floor(num) ).toString().substring( 1 );
}

Asta inseamna 2 lucruri:

1. Dacă numărul este mai mare decât dimensiunea specificată, se va întoarce pur și simplu numărul.
2. Folosind Matematica.podea(num) "în loc de" ~~num` va sprijini un număr mai mare.

Pentru distracție, în loc de a folosi o buclă pentru a crea zerouri suplimentare:

function zeroPad(n,length){
  var s=n+"",needed=length-s.length;
  if (needed>0) s=(Math.pow(10,needed)+"").slice(1)+s;
  return s;
}

Când ai menționat-o's întotdeauna va avea o lungime de 4, n-o't face orice eroare de verificare pentru a face acest slick. ;)

function pad(input) {
    var BASE = "0000";
    return input ? BASE.substr(0, 4 - Math.ceil(input / 10)) + input : BASE;
}

Idee: pur și Simplu înlocuiți '0000' cu numărul furnizat... Problema cu asta e că, dacă "intrare" este 0, am nevoie la greu-cod pentru a reveni '0000'. LOL.

Acest lucru ar trebui să fie destul de slick.

JSFiddler: http://jsfiddle.net/Up5Cr/

Acest lucru nu este chiar 'scris', dar's mai rapid pentru a face întreg operațiuni decât să faci șir înlănțuirilor pentru fiecare padding 0.

function ZeroPadNumber ( nValue )
{
    if ( nValue < 10 )
    {
        return ( '000' + nValue.toString () );
    }
    else if ( nValue < 100 )
    {
        return ( '00' + nValue.toString () );
    }
    else if ( nValue < 1000 )
    {
        return ( '0' + nValue.toString () );
    }
    else
    {
        return ( nValue );
    }
}

Această funcție este, de asemenea, hardcoded la nevoie special (4 cifre padding), deci's nu generic.