javascript - मैं अग्रणी शून्य के साथ मूल्य कैसे पैड कर सकता हूं?




zerofill (20)

जावास्क्रिप्ट में एक मूल्य zerofill करने के लिए अनुशंसित तरीका क्या है? मुझे कल्पना है कि मैं पैड ज़ीरो को एक टाइपकास्ट मान पर एक कस्टम फ़ंक्शन बना सकता हूं, लेकिन मुझे आश्चर्य है कि ऐसा करने का कोई और सीधा तरीका है या नहीं?

नोट: "ज़ीरोफिल्ल्ड" से मेरा मतलब यह है कि यह शब्द की डेटाबेस भावना में है (जहां संख्या 5 का 6-अंकों का ज़ीरोफिल प्रतिनिधित्व "000005" होगा)।


पाठकों को ध्यान दें!

जैसा कि टिप्पणीकारों ने इंगित किया है, यह समाधान "चालाक" है, और चूंकि चतुर समाधान अक्सर होते हैं, यह स्मृति गहन और अपेक्षाकृत धीमी है। यदि प्रदर्शन आपके लिए चिंता का विषय है, तो इस समाधान का उपयोग न करें!

संभावित रूप से पुराना : String.prototype.padStart 2017 में String.prototype.padStart और Number.prototype.toLocaleString है ECMAScript 3.1 के बाद से है। उदाहरण:

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

... आउटपुट "-0000.10" होगा।

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

... आउटपुट "-0000.1" होगा।

एक साधारण कार्य आपको चाहिए

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
}

यदि आप नेमस्पेस या जो कुछ भी संरक्षित करना चाहते हैं तो आप इसे लाइब्रेरी में सेंक सकते हैं। JQuery के विस्तार के साथ की तरह।


इस प्रश्न के उत्तरों में मिले 15 अलग-अलग कार्यों / विधियों का परीक्षण करने के लंबे, लंबे, लंबे समय के बाद, अब मुझे पता है कि सबसे अच्छा (सबसे बहुमुखी और तेज़) कौन सा है।

मैंने इस प्रश्न के उत्तर से 15 कार्य / विधियां लीं और 100 पैड निष्पादित करने के लिए किए गए समय को मापने के लिए एक स्क्रिप्ट बनाई। प्रत्येक पैड 2000 शून्य के साथ नंबर 9 पैड करेगा। यह अत्यधिक प्रतीत हो सकता है, और यह है, लेकिन यह आपको कार्यों के स्केलिंग के बारे में एक अच्छा विचार देता है।

मेरे द्वारा उपयोग किया जाने वाला कोड यहां पाया जा सकता है: https://gist.github.com/NextToNothing/6325915

कोड को संशोधित करने और परीक्षण करने के लिए स्वतंत्र महसूस करें।

सबसे बहुमुखी विधि प्राप्त करने के लिए, आपको एक लूप का उपयोग करना होगा। ऐसा इसलिए है क्योंकि बहुत बड़ी संख्या में अन्य विफल होने की संभावना है, जबकि, यह सफल होगा।

तो, किस लूप का उपयोग करने के लिए? खैर, यह while लूप होगा। लूप के लिए अभी भी तेज है, लेकिन while लूप थोड़ा तेज है (कुछ एमएस) - और क्लीनर।

Wilco , Aleksandar Toplek या Vitim.us द्वारा जवाब जैसे ही काम पूरी तरह से करेंगे।

व्यक्तिगत रूप से, मैंने एक अलग दृष्टिकोण की कोशिश की। मैंने स्ट्रिंग / संख्या पैड करने के लिए एक रिकर्सिव फ़ंक्शन का उपयोग करने का प्रयास किया। यह एक सरणी में शामिल विधियों से बेहतर काम करता है लेकिन, अभी भी, लूप के रूप में जल्दी से काम नहीं करता है।

मेरा कार्य है:

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

आप पैडिंग चर सेट करने के साथ, या बिना मेरे फ़ंक्शन का उपयोग कर सकते हैं। तो इस तरह:

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

निजी तौर पर, मेरे परीक्षणों के बाद, मैं थोड़ी देर के साथ एक विधि का उपयोग करता हूं, जैसे कि Aleksandar Toplek या Vitim.us । हालांकि, मैं इसे थोड़ा संशोधित कर दूंगा ताकि आप पैडिंग स्ट्रिंग सेट कर सकें।

तो, मैं इस कोड का उपयोग करूंगा:

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'

आप इस कोड का उपयोग करके प्रोटोटाइप फ़ंक्शन के रूप में भी इसका उपयोग कर सकते हैं:

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'

ऐसा करने का नवीनतम तरीका बहुत आसान है:

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

output: "02"


कुछ बंदरगाह भी काम करता है

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"

त्वरित और गंदे तरीके:

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

X = 5 और count = 6 के लिए आपके पास y = "000005" होगा


दुर्भाग्यवश, इस समस्या के लिए बहुत सारे जटिल जटिल सुझाव हैं, आम तौर पर गणित या स्ट्रिंग मैनिपुलेशन करने या तीसरे पक्ष की उपयोगिता को कॉल करने के लिए अपना स्वयं का फ़ंक्शन लिखना शामिल है। हालांकि, बेस जावास्क्रिप्ट लाइब्रेरी में कोड की केवल एक पंक्ति के साथ ऐसा करने का एक मानक तरीका है। ऐसे पैरामीटर निर्दिष्ट करने से बचने के लिए फ़ंक्शन में कोड की एक पंक्ति को लपेटने के लायक हो सकते हैं जिन्हें आप कभी भी स्थानीय नाम या शैली की तरह बदलना नहीं चाहते हैं।

var amount = 5;

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

यह पाठ के लिए "005" के मूल्य का उत्पादन करेगा। आप दशमलव बिंदु के दाईं ओर पैड शून्य तक संख्या के toLocaleString फ़ंक्शन का भी उपयोग कर सकते हैं।

var amount = 5;

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

यह पाठ के लिए "5.00" के मान का उत्पादन करेगा। हजारों के लिए अल्पविराम विभाजक का उपयोग करने के लिए उपयोग को सही में बदलें।

ध्यान दें कि locales और options तर्कों के साथ toLocaleString() का उपयोग ईसीएमए -402 में अलग-अलग मानकीकृत किया जाता है, toLocaleString() में नहीं। आज तक, कुछ ब्राउज़र केवल बुनियादी समर्थन को लागू करते हैं , यानी toLocaleString() किसी भी तर्क को अनदेखा कर सकता है।

पूरा उदाहरण



बस एक और समाधान, लेकिन मुझे लगता है कि यह अधिक सुगम है।

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


मुझे वास्तव में इस तरह कुछ इस तरह के साथ आना पड़ा था। मैंने सोचा कि लूप का उपयोग किये बिना इसे करने का कोई तरीका होना चाहिए।

मैंने ये ढूंढ निकाला।

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

फिर बस इसे शून्य संख्या पैड प्रदान करने का उपयोग करें:

> zeroPad(50,4);
"0050"

यदि संख्या पैडिंग से बड़ी है, तो संख्या पैडिंग से आगे बढ़ेगी:

> zeroPad(51234, 3);
"51234"

दशमलव भी ठीक है!

> zeroPad(51.1234, 4);
"0051.1234"

यदि आप वैश्विक नामस्थान को प्रदूषित करने पर ध्यान नहीं देते हैं तो आप इसे सीधे संख्या में जोड़ सकते हैं:

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

और यदि आप पैडिंग में जगह ले लेते हैं तो निर्णय लेते हैं:

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

चीयर्स!

XDR एक लॉगरिदमिक भिन्नता के साथ आया जो बेहतर प्रदर्शन करता प्रतीत होता है।

चेतावनी : यह फ़ंक्शन विफल रहता है यदि संख्या शून्य के बराबर होती है (जैसे ज़ीरोपैड (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;
}

प्रदर्शन की बात करते हुए, jsperf.com/left-zero-pad ( लॉग विविधता के साथ 4 ) jsperf.com/left-zero-pad tomsmeding । मान लीजिए कि किसने दूसरे को दोबारा बेहतर प्रदर्शन किया? :)


मेरा समाधान

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

प्रयोग

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

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

मैं यहां पर सभी जटिल उत्तरों पर विश्वास नहीं कर सकता ... बस इसका उपयोग करें:


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


मैं वास्तव में नहीं जानता क्यों, लेकिन किसी ने इसे सबसे स्पष्ट तरीके से नहीं किया। यहां यह मेरा कार्यान्वयन है।

समारोह:

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

प्रोटोटाइप:

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

बहुत सरल, मैं किसी भी तरह से नहीं देख सकता कि यह कैसे आसान हो सकता है। किसी कारण से मैं SO पर कई बार ऐसा प्रतीत होता हूं, लोग किसी भी कीमत पर 'के लिए' और 'जबकि' लूप से बचने की कोशिश करते हैं। रेगेक्स का उपयोग करने से शायद इस तरह के एक छोटे से 8 अंकों के पैडिंग के लिए अधिक चक्र होंगे।


यदि भरने की संख्या अग्रिम में किसी निश्चित मूल्य से अधिक नहीं है, तो कोई लूप के साथ ऐसा करने का दूसरा तरीका है:

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

टेस्ट केस यहां: http://jsfiddle.net/jfriend00/N87mZ/


यह ES6 समाधान है।

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


यह नहीं कि इस प्रश्न को और अधिक जवाब चाहिए, लेकिन मैंने सोचा कि मैं इसका सरल लॉनाश संस्करण जोड़ूंगा।

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


यहां एक त्वरित कार्य है जो मैं नौकरी करने के लिए आया था। अगर किसी के पास एक आसान दृष्टिकोण है, तो साझा करने के लिए स्वतंत्र महसूस करें!

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

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

    return result;
}

यहां मैं 7 अक्षरों तक की संख्या को पैड करने के लिए उपयोग करता हूं।

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

यह दृष्टिकोण शायद ज्यादातर लोगों के लिए पर्याप्त होगा।

संपादित करें: यदि आप इसे अधिक सामान्य बनाना चाहते हैं तो आप यह कर सकते हैं:

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

रिकर्सन का उपयोग क्यों नहीं करें?

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

सरल तरीका। आप पैड के लिए स्ट्रिंग गुणा जोड़ सकते हैं और इसे एक फ़ंक्शन में बदल सकते हैं।

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

एक समारोह के रूप में,

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






zerofill