Vyhledávání na webu

javascript - Jak mohu vyplnit hodnotu nulami na začátku?

Jak mohu doplnit hodnotu na začátku nulami v JavaScriptu? Představuji si, že bych mohl vytvořit vlastní funkci pro doplnění nul na typově převedenou hodnotu, ale zajímá mě, zda existuje přímější způsob, jak to udělat?

Poznámka: Když mluvím o doplňování hodnoty, myslím tím po databázové stránce (kde 6-místná doplněná reprezentace čísla 5 by byla „000005“).

Odpověď č. 1

Nemůžu uvěřit všem těm složitým odpovědím tady... Stačí použít toto:

var zerofilled = ('0000'+n).slice(-4);


let n = 1
var zerofilled = ('0000'+n).slice(-4);
console.log(zerofilled)

Odpověď č. 2

Od ECMAScript 2017 máme padStart:

const padded = (.1 + "").padStart(6, "0");
console.log(`-${padded}`);

Před ECMAScript 2017

S toLocaleString:

var n=-0.1;
var res = n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false});
console.log(res);

Odpověď č. 3

Jednoduchý způsob. Mohl byste přidat násobení řetězce pro výplň a proměnit to ve funkci.

var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);

Jako funkce,

function paddy(num, padlen, padchar) {
    var pad_char = typeof padchar !== 'undefined' ? padchar : '0';
    var pad = new Array(1 + padlen).join(pad_char);
    return (pad + num).slice(-pad.length);
}
var fu = paddy(14, 5); // 00014
var bar = paddy(2, 4, '#'); // ###2

Odpověď č. 4

Vlastně jsem si nedávno musel něco takového vymyslet. Přišel jsem na to, že musí existovat způsob, jak to udělat bez použití smyček.

Tohle je to, co jsem vymyslel.

function zeroPad(num, numZeros) {
    var n = Math.abs(num);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( num < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

Pak to prostě použijte a zadejte číslo pro doplnění nulami:

> zeroPad(50,4);
"0050"

Pokud je číslo větší než vycpávka, číslo se rozšíří za vycpávku:

> zeroPad(51234, 3);
"51234"

Desetinná čísla jsou také v pořádku!

> zeroPad(51.1234, 4);
"0051.1234"

Pokud vám nevadí znečišťovat globální jmenný prostor, můžete ji přidat přímo k Number:

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

A pokud byste raději, aby desetinná místa zabírala místo v odsazení:

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - n.toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

Na zdraví!

XDR přišel s logaritmickou variantou, která se zdá být výkonnější.

VAROVÁNÍ: Tato funkce selže, pokud se num rovná nule (např. zeropad(0, 2))

function zeroPad (num, numZeros) {
    var an = Math.abs (num);
    var digitCount = 1 + Math.floor (Math.log (an) / Math.LN10);
    if (digitCount >= numZeros) {
        return num;
    }
    var zeroString = Math.pow (10, numZeros - digitCount).toString ().substr (1);
    return num < 0 ? '-' + zeroString + an : zeroString + an;
}

Když už mluvíme o výkonu, tomsmeding porovnal nejlepší 3 odpovědi (4 s logaritmickou variantou). Hádej, která z nich výrazně předčila ty dvě ostatní? :)

Odpověď č. 5

Moderní prohlížeče nyní podporují padStart, nyní můžete jednoduše udělat:

string.padStart(maxLength, "0");

Příklad :

string = "14";
maxLength = 5; // maxLength is the max string length, not max # of fills
res = string.padStart(maxLength, "0");
console.log(res); // prints "00014"

number = 14;
maxLength = 5; // maxLength is the max string length, not max # of fills
res = number.toString().padStart(maxLength, "0");
console.log(res); // prints "00014"

Odpověď č. 6

Tady je to, co jsem použil k doplnění čísla až na 7 znaků.

("0000000" + number).slice(-7)

Tento přístup pravděpodobně postačí většině lidí.

Upravit: Pokud to chcete udělat obecnější, můžete to udělat takto:

("0".repeat(padding) + number).slice(-padding)

Úprava 2: Všimněte si, že od ES2017 můžete použít String.prototype.padStart:

number.toString().padStart(padding, "0")

Odpověď č. 7

Bohužel existuje spousta zbytečně složitých návrhů pro tento problém, obvykle zahrnujících psaní vlastní funkce pro matematiku nebo manipulaci s řetězci, nebo volání utilit třetích stran. Existuje však standardní způsob, jak toho dosáhnout v základní knihovně JavaScriptu jen jedním řádkem kódu. Může stát za to zabalit tento jeden řádek kódu do funkce, aby nebylo nutné zadávat parametry, které nikdy nechcete měnit, jako je lokální název nebo styl.

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumIntegerDigits: 3,
    useGrouping: false
});

To bude produkovat hodnotu „005“ pro text. Také můžete použít funkci toLocaleString objektu Number k doplnění nul na pravou stranu desetinné tečky.

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumFractionDigits: 2,
    useGrouping: false
});

To vytvoří hodnotu „5,00“ pro text. Změňte useGrouping na true, aby se pro tisíce používaly čárkové oddělovače.

Všimněte si, že použití toLocaleString() s argumenty locales a options je standardizováno samostatně v ECMA-402, nikoli v ECMAScriptu. K dnešnímu dni některé prohlížeče implementují pouze základní podporu, tj. toLocaleString() může ignorovat jakékoliv argumenty.

Kompletní příklad

Odpověď č. 8

Pokud je předem známo, že číslo výplně nepřekročí určitou hodnotu, existuje jiný způsob, jak toho dosáhnout bez smyček:

var fillZeroes = "00000000000000000000";  // max number of zero fill ever asked for in global

function zeroFill(number, width) {
    // make sure it's a string
    var input = number + "";  
    var prefix = "";
    if (input.charAt(0) === '-') {
        prefix = "-";
        input = input.slice(1);
        --width;
    }
    var fillAmt = Math.max(width - input.length, 0);
    return prefix + fillZeroes.slice(0, fillAmt) + input;
}

Testovací případy zde: http://jsfiddle.net/jfriend00/N87mZ/

Odpověď č. 9

Rychlý a špinavý způsob:

y = (new Array(count + 1 - x.toString().length)).join('0') + x;

Pro x=5 a count=6 budete mít y="000005"

Odpověď č. 10

ECMAScript 2017: použijte padStart nebo padEnd

'abc'.padStart(10);         // "       abc"
'abc'.padStart(10, "foo");  // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"

Více informací:

  • https://github.com/tc39/proposal-string-pad-start-end
  • https://developer.mozilla.org/cs/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Odpověď č. 11

Tady je rychlá funkce, kterou jsem vymyslel, aby práci udělala. Pokud někdo má jednodušší způsob, klidně se o něj podělte!

function zerofill(number, length) {
    // Setup
    var result = number.toString();
    var pad = length - result.length;

    while(pad > 0) {
        result = '0' + result;
        pad--;
    }

    return result;
}

Odpověď č. 12

Opravdu nevím proč, ale nikdo to neudělal tím nejzjevnějším způsobem. Tady je moje implementace.

Funkce:

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

Prototyp:

Number.prototype.zeroPad=function(digits){
    var num=this+"";
    while(num.length < digits){
        num='0'+num;
    }
    return(num);
};

Velmi přímočaré, nevidím žádný způsob, jak by to mohlo být jednodušší. Z nějakého důvodu jsem zde na SO mnohokrát viděl, že lidé se snaží za každou cenu vyhnout smyčkám 'for' a 'while'. Použití regulárních výrazů pravděpodobně spotřebuje mnohem více cyklů pro takto triviální doplnění na 8 číslic.

Odpověď č. 13

Tuto konstrukci často používám pro ad-hoc doplňování nějaké hodnoty n, u které je známo, že je kladná, desítková:

(offset + n + '').substr(1);

Kde offset je 10^^cifer.

Např. vycpání na 5 číslic, kde n=123:

(1e5 + 123 + '').substr(1); // => 00123

Hexadecimální verze tohoto je o něco podrobnější:

(0x100000 + 0x123).toString(16).substr(1); // => 00123

Poznámka 1: Líbí se mi také řešení @profitehlolz, což je stringová verze tohohle, používající užitečnou vlastnost slice() s negativním indexem.

Odpověď č. 14

Ve všech moderních prohlížečích můžete použít

numberStr.padStart(numberLength, "0");


function zeroFill(num, numLength) {
  var numberStr = num.toString();

  return numberStr.padStart(numLength, "0");
}

var numbers = [0, 1, 12, 123, 1234, 12345];

numbers.forEach(
  function(num) {
    var numString = num.toString();
    
    var paddedNum = zeroFill(numString, 5);

    console.log(paddedNum);
  }
);

Zde je odkaz na MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Odpověď č. 15

Používám tento úryvek k získání pěticiferného zobrazení:

(value+100000).toString().slice(-5) // "00123" with value=123

Odpověď č. 16

Síla matematiky!

x=celé číslo k doplnění
y=počet nul k doplnění

function zeroPad(x, y)
{
   y = Math.max(y-1,0);
   var n = (x / Math.pow(10,y)).toFixed(y);
   return n.replace('.','');  
}

Související články