javascript - Ako môžem doplniť hodnotu predponou núl?

Ako môžem v JavaScripte doplniť hodnotu na začiatku nulami? Predstavujem si, že by som mohol vytvoriť vlastnú funkciu na doplnenie núl k pretypovanej hodnote, ale zaujíma ma, či existuje priamejší spôsob, ako to urobiť?

Poznámka: Pod pojmom doplnenie hodnoty myslím doplnenie v zmysle databáz (kde 6-miestna doplnená reprezentácia čísla 5 by bola "000005").

Odpoveď č. 1

Nemôžem uveriť všetkým tým zložitým odpovediam tu... Stačí použiť toto:

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


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

Odpoveď č. 2

Od ECMAScript 2017 máme padStart:

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

Pred ECMAScript 2017

S toLocaleString:

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

Odpoveď č. 3

Jednoduchý spôsob. Môžete pridať násobenie reťazca pre výplň a premeniť to na funkciu.

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

Ako funkcia,

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

Odpoveď č. 4

Vlastne som nedávno musel prísť s niečím takýmto. Myslel som si, že musí existovať spôsob, ako to urobiť bez použitia slučiek.

To je to, na čo som prišiel.

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

Potom to jednoducho použite a zadajte číslo na doplnenie nulami:

> zeroPad(50,4);
"0050"

Ak je číslo väčšie ako odsadenie, číslo sa rozbalí za odsadenie:

> zeroPad(51234, 3);
"51234"

Desatinné čísla sú tiež v poriadku!

> zeroPad(51.1234, 4);
"0051.1234"

Ak vám nevadí znečistiť globálny priestor mien, môžete ho pridať priamo do 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 ak by ste radšej, aby desatinné miesta zaberali miesto v odsadení:

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 zdravie!

XDR prišiel s logaritmickou variáciou, ktorá sa zdá byť efektívnejšia.

UPOZORNENIE: Táto funkcia zlyhá, ak je num rovné nule (napr. 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;
}

Keď už hovoríme o výkone, tomsmeding porovnal top 3 odpovede (4 s variáciou logu). Uhádni, ktorá výrazne prekonala tie ostatné dve? :)

Odpoveď č. 5

Moderné prehliadače teraz podporujú padStart, teraz môžete jednoducho urobiť:

string.padStart(maxLength, "0");

Prí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"

Odpoveď č. 6

Tu je to, čo som použil na doplnenie čísla až na 7 znakov.

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

Tento prístup pravdepodobne postačí väčšine ľudí.

Upraviť: Ak to chcete spraviť všeobecnejším, môžete urobiť toto:

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

Upraviť 2: Upozorňujeme, že od ES2017 môžete použiť String.prototype.padStart:

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

Odpoveď č. 7

Bohužiaľ, existuje veľa zbytočne komplikovaných návrhov na riešenie tohto problému, zvyčajne zahŕňajúcich písanie vlastnej funkcie na matematiku alebo manipuláciu s reťazcami, alebo volanie nástroja tretej strany. Existuje však štandardný spôsob, ako to urobiť v základnej knižnici JavaScriptu len jedným riadkom kódu. Mohlo by stáť za to zabaliť tento jeden riadok kódu do funkcie, aby ste nemuseli zadávať parametre, ktoré nikdy nechcete meniť, ako napríklad lokálny názov alebo štýl.

var amount = 5;

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

Toto vygeneruje hodnotu „005“ pre text. Môžete tiež použiť funkciu toLocaleString objektu Number na doplnenie núl na pravú stranu desatinnej čiarky.

var amount = 5;

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

Toto vygeneruje hodnotu „5,00“ pre text. Zmeňte useGrouping na true, aby sa použili čiarky ako oddeľovače tisícok.

Všimnite si, že používanie toLocaleString() s argumentmi locales a options je štandardizované samostatne v ECMA-402, nie v ECMAScripte. Ku dnešnému dňu niektoré prehliadače implementujú iba základnú podporu, t.j. toLocaleString() môže ignorovať akékoľvek argumenty.

Kompletný príklad

Odpoveď č. 8

Ak je vopred známe, že číslo výplne neprekročí určitú hodnotu, existuje iný spôsob, ako to urobiť bez slučiek:

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

Testovacie prípady tu: http://jsfiddle.net/jfriend00/N87mZ/

Odpoveď č. 9

Rýchly a špinavý spôsob:

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

Pre x=5 a count=6 budete mať y="000005"

Odpoveď č. 10

ECMAScript 2017: použite padStart alebo padEnd

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

Viac informácií:

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

Odpoveď č. 11

Tu je rýchla funkcia, ktorú som vymyslel na vykonanie práce. Ak má niekto jednoduchší prístup, pokojne sa podeľte!

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

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

    return result;
}

Odpoveď č. 12

Naozaj neviem prečo, ale nikto to nespravil tým najzrejmejším spôsobom. Tu je moje riešenie.

Funkcia:

/** 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);
};

Veľmi jednoduché, nevidím žiadny spôsob, ako by to mohlo byť ešte jednoduchšie. Z nejakého dôvodu som tu na SO už veľakrát videl, že ľudia sa snažia za každú cenu vyhnúť slučkám 'for' a 'while'. Použitie regexu pravdepodobne bude stáť oveľa viac cyklov pre takéto triviálne doplnenie na 8 číslic.

Odpoveď č. 13

Tento konštrukt často používam na ad-hoc dopĺňanie nejakej hodnoty n, o ktorej je známe, že je kladná desatinná hodnota:

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

Kde offset je 10^^cifier.

Napríklad, doplnenie na 5 číslic, kde n=123:

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

Hexadecimálna verzia tohto je o niečo rozvláčnejšia:

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

Poznámka 1: Páči sa mi aj riešenie @profitehlolz, ktoré je stringovou verziou tohto, využívajúce šikovnú funkciu slice() s negatívnym indexom.

Odpoveď č. 14

Vo všetkých moderných prehliadačoch môžete použiť

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

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

Odpoveď č. 15

Používam tento úryvok na získanie päťmístnej reprezentácie:

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

Odpoveď č. 16

Sila matematiky!

x=celé číslo na doplnenie
y=počet núl na doplnenie

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

Súvisiace články