Baştaki sıfırlarla bir değeri nasıl doldurabilirim?

JavaScript'te bir değeri sıfırla doldurmanın önerilen yolu nedir? Ben daktilo bir değere sıfır pad için özel bir işlev inşa hayal, ama bunu yapmak için daha doğrudan bir yol olup olmadığını merak ediyorum?

Not: "Sıfır dolgulu" ile kastedilen kelime anlamında (burada 5 rakamının 6 haneli sıfır dolgulu gösterimi "000005" olacaktır).

Okuyucular için not!

Yorum yapanların işaret ettiği gibi, bu çözüm "zekidir" ve zeki çözümler sıklıkla olduğu gibi, bellek yoğun ve nispeten yavaştır. Performans sizin için önemliyse, bu çözümü kullanmayın!

Potansiyel olarak modası geçmiş : ECMAScript 2017,ECMAScript 3.1'den beri String.prototype.padStart ve Number.prototype.toLocaleString var. Misal:

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

... "-0000.10" çıktısını verir.

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

... "-0000.1" çıktısı verir.

Tek ihtiyacınız olan basit bir işlev

function zeroFill( number, width )
{
  width -= number.toString().length;
  if ( width > 0 )
  {
    return new Array( width + (/\./.test( number ) ? 2 : 1) ).join( '0' ) + number;
  }
  return number + ""; // always return a string
}

ad alanını veya herhangi bir şeyi korumak istiyorsanız, bunu bir kitaplığa dönüştürebilirsiniz. JQuery'nin uzantısı gibi .

Basit yol. Ped için dize çarpımı ekleyebilir ve bir işleve dönüştürebilirsiniz.

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

İşlev olarak,

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

Buradaki tüm karmaşık cevaplara inanamıyorum ... Sadece şunu kullanın:

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

Aslında son zamanlarda böyle bir şey bulmak zorundaydım. Döngüler kullanmadan bunu yapmanın bir yolu olması gerektiğini düşündüm.

Ben de bunu buldum.

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

Sonra sadece sıfıra bir sayı sağlayarak kullanın:

> zeroPad(50,4);
"0050"

Sayı dolgudan daha büyükse, sayı dolgudan sonra genişler:

> zeroPad(51234, 3);
"51234"

Ondalık sayılar da iyidir!

> zeroPad(51.1234, 4);
"0051.1234"

Genel ad alanını kirletmekten sakıncası yoksa, doğrudan Sayıya ekleyebilirsiniz:

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

Ve ondalık sayıların dolguda yer kaplamasını tercih ediyorsanız:

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

Şerefe!

XDR , daha iyi performans gösteren bir logaritmik varyasyon ortaya koydu.

UYARI : num sıfıra eşitse bu işlev başarısız olur (örn. 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;
}

Performanstan bahsetmişken, tomsmeding ilk 3 cevabı karşılaştırdı ( 4 log varyasyonu ile ). Tek Bil ki Majorly diğer ikisini geride bırakmıştır? :)

İşte 7 karaktere kadar bir sayıyı doldurmak için kullandım.

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

Bu yaklaşım muhtemelen çoğu insan için yeterli olacaktır.

Düzenleme: Daha genel hale getirmek istiyorsanız, bunu yapabilirsiniz:

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

Edit 2: ES2017'den bu yana şunları kullanabileceğinizi unutmayın String.prototype.padStart:

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

Modern tarayıcılar artık destekliyor padStart, şunları yapabilirsiniz:

string.padStart(maxLength, "0");

Misal:

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

Ne yazık ki, bu sorun için genellikle matematik veya dize manipülasyonu yapmak veya üçüncü taraf bir yardımcı program çağırmak için kendi işlevinizi yazmayı içeren çok fazla gereksiz karmaşık öneri vardır. Ancak, bunu temel JavaScript kitaplığında yalnızca bir satır kodla yapmanın standart bir yolu vardır. Yerel ad veya stil gibi asla değiştirmek istemediğiniz parametreleri belirtmekten kaçınmak için bu kod satırını bir işleve sarmaya değer olabilir.

var amount = 5;

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

Bu metin için "005" değerini üretecektir. Ondalık virgülünün sağ tarafındaki sıfırları doldurmak için Sayı'nın toLocaleString işlevini de kullanabilirsiniz.

var amount = 5;

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

Bu metin için "5.00" değerini üretecektir. Binlerce virgül ayırıcı kullanmak için useGrouping öğesini true olarak değiştirin.

Kullanarak unutmayın toLocaleString()ile localesve optionsargümanlar ECMA-402 ayrı standardize edilmiştir değil ECMAScript'te. Bugün itibariyle, bazı tarayıcılar yalnızca temel desteği uygulamaktadır , yani toLocaleString()herhangi bir argümanı yoksayabilir.

Komple Örnek

Dolgu numarasının önceden belirli bir değeri aşmadığı biliniyorsa, bunu döngüsüz yapmanın başka bir yolu vardır:

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

Test örnekleri burada: http://jsfiddle.net/jfriend00/N87mZ/

Hızlı ve kirli yol:

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

X = 5 ve count = 6 için y = "000005"

İşte işi yapmak için bulduğum hızlı bir işlev. Herkes daha basit bir yaklaşıma sahipse, paylaşmaktan çekinmeyin!

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

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

    return result;
}

Buradaki partiye geç, ama genellikle bu yapıyı n, pozitif, ondalık olduğu bilinen bazı değerlerin geçici olarak doldurulması için kullanıyorum:

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

offset10 ^ ^ basamak nerede .

5 basamaklı dolgu, burada n = 123:

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

Bunun onaltılık versiyonu biraz daha ayrıntılıdır:

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

Not 1: Dilim () 'in şık negatif dizin özelliğini kullanarak, bunun dize sürümü olan @ profitehlolz çözümünü de seviyorum.

Nedenini gerçekten bilmiyorum, ama kimse bunu en açık şekilde yapmadı. İşte benim uygulamam.

İşlev:

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

Prototip:

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

Çok basit, bunun nasıl daha basit olabileceğini hiçbir şekilde göremiyorum. Bir sebepten ötürü burada SO'da birçok kez göründüm, insanlar sadece 'için' ve 'iken' döngülerden kaçınmaya çalışıyorlar. Normal ifade kullanmak, bu kadar önemsiz bir 8 basamaklı dolgu için muhtemelen daha fazla döngüye mal olacaktır.

Bu parçacığı 5 basamaklı gösterim almak için kullanıyorum

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

ECMAScript 2017: padStart kullanın veya padEnd

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

Daha fazla bilgi:

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

Matematiğin gücü!

x = ped için tam sayı
y = ped için sıfır sayısı

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

Ben kimse String.prototype.substr () kullandığınızı işaret görmedim negatif bir sayı ile .

OP sorusuna bir numaralı çözüm, 5 sayısının 6 haneli sıfır doldurulmuş bir temsili:

console.log(("00000000" + 5).substr(-6));

Genel olarak elde edeceğiz:

function pad(num, len) { return ("00000000" + num).substr(-len) };

console.log(pad(5, 6));
console.log(pad(45, 6));
console.log(pad(345, 6));
console.log(pad(2345, 6));
console.log(pad(12345, 6));

Bu soruların cevaplarında bulunan 15 farklı fonksiyon / yöntemi test eden bir, uzun, uzun bir süre sonra, hangisinin en iyi olduğunu (en çok yönlü ve en hızlı) biliyorum.

Bu sorunun cevabından 15 fonksiyon / yöntem aldım ve 100 ped yürütmek için harcanan zamanı ölçmek için bir senaryo hazırladım. Ped numarası Her ped olur 9ile 2000sıfır. Bu aşırı görünebilir ve öyledir, ancak işlevlerin ölçeklendirilmesi hakkında size iyi bir fikir verir.

Kullandığım kodu burada bulabilirsiniz: https://gist.github.com/NextToNothing/6325915

Kodu kendiniz değiştirip test etmekten çekinmeyin.

En çok yönlü yöntemi elde etmek için bir döngü kullanmanız gerekir. Bunun nedeni, çok büyük sayılarda başkalarının başarısız olma olasılığıdır, oysa bu başarılı olacaktır.

Hangi döngü kullanılacak? Bu bir whiledöngü olurdu . Bir fordöngü hala hızlıdır, ancakwhile döngü biraz daha hızlı (birkaç ms) ve daha temiz.

Tarafından olduğu gibi Cevapları Wilco, Aleksandar ToplekyaVitim.us mükemmel iş yapacak.

Şahsen farklı bir yaklaşım denedim. Dize / sayı pad için özyinelemeli bir işlev kullanmaya çalıştım. Bir diziye katılma yöntemlerinden daha iyi sonuç verdi, ancak yine de for döngüsü kadar hızlı çalışmadı.

Benim fonksiyonum:

function pad(str, max, padder) {
  padder = typeof padder === "undefined" ? "0" : padder;
  return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}

İşlevimi dolgu değişkenini ayarlayarak veya bu ayar olmadan kullanabilirsiniz. Şöyle böyle:

pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'

Şahsen, testlerimden sonra, bir while döngüsüne sahip bir yöntem kullanacağım, Aleksandar Toplekya da Vitim.us. Ancak, dolgu dizesini ayarlayabilmeniz için biraz değiştiririm.

Yani, bu kodu kullanırdım:

function padLeft(str, len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    str = str + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
padLeft(1, 3); // Returns '001'
// - Or -
padLeft(1, 3, "x"); // Returns 'xx1'

Bu kodu kullanarak bir prototip işlevi olarak da kullanabilirsiniz:

Number.prototype.padLeft = function(len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    var str = this + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
var num = 1;

num.padLeft(3); // Returns '001'
// - Or -
num.padLeft(3, "x"); // Returns 'xx1'

Birinci parametre herhangi bir gerçek sayıdır, ikinci parametre ondalık noktasının solundaki minimum basamak sayısını belirten pozitif bir tamsayıdır ve üçüncü parametre ondalık noktasının sağındaki basamaklarsa sayıyı belirten isteğe bağlı bir pozitif tamsayıdır.

function zPad(n, l, r){
    return(a=String(n).match(/(^-?)(\d*)\.?(\d*)/))?a[1]+(Array(l).join(0)+a[2]).slice(-Math.max(l,a[2].length))+('undefined'!==typeof r?(0<r?'.':'')+(a[3]+Array(r+1).join(0)).slice(0,r):a[3]?'.'+a[3]:''):0
}

yani

           zPad(6, 2) === '06'
          zPad(-6, 2) === '-06'
       zPad(600.2, 2) === '600.2'
        zPad(-600, 2) === '-600'
         zPad(6.2, 3) === '006.2'
        zPad(-6.2, 3) === '-006.2'
      zPad(6.2, 3, 0) === '006'
        zPad(6, 2, 3) === '06.000'
    zPad(600.2, 2, 3) === '600.200'
zPad(-600.1499, 2, 3) === '-600.149'

Tekerleği yeniden icat etmeyin, alt çizgi dizesini kullanın :

jsFiddle

var numToPad = '5';

alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'

Bu ES6 çözümüdür.

function pad(num, len) {
  return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));

Tüm modern tarayıcılarda kullanabilirsiniz

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

İşte MDN referansı https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Bu sorunun daha fazla cevaba ihtiyacı değil, ama bunun basit lodash versiyonunu ekleyeceğimi düşündüm.

_.padLeft(number, 6, '0')

Bunu yapmanın en son yolu çok daha basit:

var number = 2
number.toLocaleString(undefined, {minimumIntegerDigits:2})

output: "02"

Sadece başka bir çözüm, ama bence daha okunaklı.

function zeroFill(text, size)
{
  while (text.length < size){
  	text = "0" + text;
  }
  
  return text;
}

Bu daha az yerli, ama en hızlı olabilir ...

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};

Çözümüm

Number.prototype.PadLeft = function (length, digit) {
    var str = '' + this;
    while (str.length < length) {
        str = (digit || '0') + str;
    }
    return str;
};

kullanım

var a = 567.25;
a.PadLeft(10); // 0000567.25

var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25

Neden özyineleme kullanmıyorsunuz?

function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}

Bazı maymun sıçraması da işe yarıyor

String.prototype.padLeft = function (n, c) {
  if (isNaN(n))
    return null;
  c = c || "0";
  return (new Array(n).join(c).substring(0, this.length-n)) + this; 
};
var paddedValue = "123".padLeft(6); // returns "000123"
var otherPadded = "TEXT".padLeft(8, " "); // returns "    TEXT"

function pad(toPad, padChar, length){
    return (String(toPad).length < length)
        ? new Array(length - String(toPad).length + 1).join(padChar) + String(toPad)
        : toPad;
}

pad(5, 0, 6) = 000005

pad('10', 0, 2) = 10 // don't pad if not necessary

pad('S', 'O', 2) = SO

...vb.

Şerefe

En basit bulacaksınız, en düz İleri çözüm.

function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}