formatering - Fyll ett nummer med ledande nollor i JavaScript

I JavaScript behöver jag ha utfyllnad.

Till exempel, om jag har siffran 9, kommer det att vara "0009". Om jag har flera, säg 10, kommer det att vara "0010". Lägg märke till hur det alltid kommer att innehålla fyra siffror.

Ett sätt att göra detta skulle vara att subtrahera numret minus 4 för att få antalet nollor jag behöver lägga till.

Finns det ett smidigare sätt att göra detta?

Svar #1

ES2017 Uppdatering

Du kan använda den inbyggda String.prototype.padStart()

n = 9;
String(n).padStart(4, '0'); // '0009'

n = 10;
String(n).padStart(4, '0'); // '0010'

Inte mycket 'slick' som händer hittills:

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

När du initialiserar en array med ett nummer skapas en array med length satt till det värdet så att arrayen verkar innehålla så många undefined-element. Även om vissa metoder för Array-instans hoppar över array-element utan värden, gör .join() inte det, åtminstone inte helt; den behandlar dem som om deras värde är den tomma strängen. Därför får du en kopia av nolltecknet (eller vad "z" än är) mellan varje array-element; det är därför det finns ett + 1 där.

Exempel på användning:

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

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

Svar #2

function padToFour(number) {
  if (number<=9999) { number = ("000"+number).slice(-4); }
  return number;
}

Något sådant?

Bonus obegriplig-men-snyggare enradig ES6-version:

let padToFour = number => number <= 9999 ? `000${number}`.slice(-4) : number;

ES6-ismer:

  • let är en block-scopead variabel (i motsats till var’s funktionella scope)
  • => är en pilfunktion som, bland annat, ersätter function och föregås av sina parametrar
  • Om en pilfunktion tar ett enda parameter kan du utelämna parenteserna (därav number =>)
  • Om en arrow-funktions kropp har en enda rad som börjar med return, kan du utelämna klamrarna och return-nyckelordet och helt enkelt använda uttrycket
  • För att få funktionskroppen till en enda rad, fuskte jag och använde ett ternärt uttryck

Svar #3

Försök :

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

Testa nu:

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

I ECMAScript 2017 har vi nya metoder padStart och padEnd som har följande syntax.

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

Så nu kan vi använda

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

Svar #4

Roligt, jag var tvungen att göra det här nyligen.

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

Använd som:

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

Inte vacker, men effektiv.

Svar #5

Du sa att du hade ett nummer-

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

Svar #6

Du skulle kunna göra något liknande detta:

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

Redigera: Detta var bara en grundläggande idé för en funktion, men för att lägga till stöd för större siffror (såväl som ogiltig inmatning), skulle detta förmodligen vara bättre:

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

Detta gör två saker:

  1. Om numret är större än den angivna storleken kommer det helt enkelt att returnera numret.
  2. Att använda Math.floor(num) istället för ~~num kommer att stödja större tal.

Relaterade artiklar