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

394

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

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

javascript zerofill

— विल्को
स्रोत

यह वास्तव में जवाब देने के लिए पर्याप्त जानकारी नहीं है। "जीरो पैडिंग" का सबसे आम उदाहरण संभवतः तारीखों पर शून्य का प्रीपेडिंग है: 5/1/2008> 05/01/2008। क्या यही मतलब है तुम्हारा?

— त्रिकोणीय

6

नोड ऐप्स के लिए, इसका उपयोग करें npm install sprintf-js, और आपको जो फ़ाइल चाहिए, sprintf('%0d6', 5);

— उसमें इसकी

function padWithZeroes(n, width) { while(n.length<width) n = '0' + n; return n;} ... nनकारात्मक नहीं मानते

— पाओलो

@Paolo कि फ़ंक्शन काम नहीं करता है यदि n संख्यात्मक है। आप n से पहले एक स्ट्रिंग में बदलने की आवश्यकता होगी whileका उपयोग करने के क्रम मेंn.length

— निक एफ

1

मठ के बिना एक लाइनर या जबकि छोरों या पुस्तकालयों? mynum = "0".repeat((n=6-mynum.toString().length)>0?n:0)+mynum;

— एडम

224

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

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

संभावित रूप से पुराना : ECMAScript 2017 में String.prototyp.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 के विस्तार के साथ ।

— पीटर बेली
स्रोत

1

अब आपको बस 50.1234 जैसे नंबरों का ध्यान रखना है और आपको नीचे दिए गए मेरे समाधान का एक पठनीय संस्करण मिल गया है! हालाँकि, मैंने मान लिया था कि हम सिर्फ पैडिंग थे, ओवरऑल पैडिंग नहीं।

— कोडरजॉ

7

हर बार जब आप एक मूल्य पैड करना चाहते हैं, तो एक नई सरणी बनाने का प्रशंसक नहीं। पाठकों को संभावित मेमोरी और GC प्रभाव के बारे में पता होना चाहिए, यदि वे इनमें से बड़े # कर रहे हैं (उदाहरण के लिए एक नोड.जेएस सर्वर जो इन ऑपरेशनों को प्रति सेकंड 1000 कर रहा है। @ profitehlolz का उत्तर बेहतर समाधान प्रतीत होगा। ।)

— ब्रूफ़

6

यह नकारात्मक मानों के लिए काम नहीं करता है: शून्यफिल (-10, 7) -> "0000-10"

— digitalbath

2

तीन शीर्ष जवाबों के बीच प्रदर्शन माप यहां: jsperf.com/left-zero-pad

— tomsmeding

12

ECMAScript 2017 के अनुसार, बिल्ड-इन फ़ंक्शन पैडस्टार्ट है ।

— टॉमस निकोडियम

321

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

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

— प्रोफाइटोल्ज़
स्रोत

95

यह एक बहुत अच्छा समाधान है, सबसे अच्छा मैंने देखा है। स्पष्टता के लिए, यहाँ एक सरल संस्करण है जिसका उपयोग मैं समय प्रारूपण में मिनटों को पैड करने के लिए कर रहा हूँ: ('0' + मिनट) .llice (-2)

— ल्यूक

17

यह थोड़ी देर के लूप के साथ कार्यान्वयन की तुलना में 5 गुना धीमा है: gist.github.com/4382935

— andrewrk

42

इसमें अपेक्षित संख्याओं से बड़ा एक FATAL FLAW है - जो एक अत्यंत सामान्य घटना है। उदाहरण के लिए, paddy (888, 2)पैदावार 88और 888आवश्यकतानुसार नहीं । यह उत्तर भी नकारात्मक संख्या को नहीं संभालता है।

— ब्रॉक एडम्स

8

@BrockAdams, zerofill आमतौर पर निश्चित चौड़ाई संख्या / स्वरूपण मामलों के लिए उपयोग किया जाता है - इसलिए मुझे लगता है कि यह वास्तव में कम संभावना (या यहां तक कि एक गैर-मुद्दा) होगा यदि 2 अंकों के ज़ीरोफ़िल करने की कोशिश करते समय 3 अंकों की संख्या दी जाती है।

— Seaux

1

("000000" + somenum) .substr (-6,6) जहां शून्य की संख्या और -6,6 पैड की चौड़ाई के अनुरूप हैं। एक ही विचार लेकिन टुकड़ा एक कम परम ले; निश्चित नहीं है कि यदि स्लाइस सबट्रा की तुलना में तेज़ या धीमा है। बेशक मेरे समाधान को चर असाइनमेंट की आवश्यकता नहीं है।

— slartibartfast

315

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

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

— सीक्स
स्रोत

27

नकारात्मक अंकों और संख्याओं को छोड़कर 4 अंकों की तुलना में अच्छा।

— wberry

12

@wberry यह उत्पादन तैयार कोड होने का इरादा नहीं था, लेकिन हाथ में प्रश्न को हल करने के लिए मूल बातें का अधिक सरल विवरण है। Aka यह निर्धारित करना बहुत आसान है कि क्या कोई संख्या सकारात्मक या नकारात्मक है और यदि आवश्यक हो तो उचित संकेत जोड़ दें, इसलिए मैं उसके लिए अपना आसान उदाहरण नहीं देना चाहता। इसके अलावा, यह एक फ़ंक्शन के रूप में एक अंक लंबाई लेने के लिए एक arg के रूप में और मेरे हार्डकोड किए गए मानों के बजाय इसका उपयोग करना आसान है।

— सीक

5

@Seaux, आपने कहा: "सभी जटिल उत्तरों पर विश्वास नहीं कर सकते हैं" , और फिर टिप्पणी करते समय खुद को जटिलता की व्याख्या करना शुरू कर दिया। इसका मतलब है कि आप समझते हैं कि ऐसे दृष्टिकोण हैं जिनसे आपका उत्तर सही नहीं है। इसलिए जटिलता।

— ओम शंकर

2

@OmShankar द्वारा "जटिल उत्तर", मैं समझाया या विस्तृत उत्तरों की बात नहीं कर रहा था (जो स्पष्ट रूप से इस साइट पर प्रोत्साहित किए जाते हैं, जबकि मेरा उत्तर नहीं है), बल्कि ऐसे उत्तर दिए गए जिनमें अनावश्यक कोड जटिलता थी।

— Seaux

7

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

— पैट्रिक चू

110

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

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

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 एक लघुगणक भिन्नता के साथ आया है जो बेहतर प्रदर्शन करता है।

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

प्रदर्शन की बात करें, तो शीर्ष 3 उत्तरों ( लॉग वेरिएशन के साथ 4 ) की तुलना में टॉस किया गया । लगता है जो एक प्रमुख अन्य दो से बेहतर प्रदर्शन किया? :)

— कोडरजो
स्रोत

9

यह अच्छा है, मुझे पसंद है कि यह कैसे पठनीय और मजबूत है। केवल एक चीज जो मैं numZerosबदलूंगा वह है पैरामीटर का नाम , क्योंकि यह भ्रामक है। यह आपके द्वारा जोड़े जाने वाले शून्य की संख्या नहीं है, यह न्यूनतम लंबाई होनी चाहिए जो संख्या होनी चाहिए। एक बेहतर नाम numLengthया भी होगा length।

— सेंसफुल

13

+1। उच्च मतदान उत्तरों के विपरीत, यह एक नकारात्मक संख्या को संभालता है और अतिप्रवाह पर सकल त्रुटियों को वापस नहीं करता है !!।!

— ब्रॉक एडम्स

10

तीन शीर्ष जवाबों के बीच प्रदर्शन माप यहां: jsperf.com/left-zero-pad

— tomsmeding

4

मैंने लॉगरिदम का उपयोग करके इस उत्तर के प्रदर्शन में 100% से अधिक सुधार किया। कृपया http://jsperf.com/left-zero-pad/10

— XDR

2

मूल समाधान बेहतर है, अगर numशून्य हो सकता है तो लॉगरिदमिक भिन्नता काम नहीं करती ...

— ओन्ड्रा सी।

69

यहाँ मैंने 7 अक्षरों तक की संख्या को पैड किया है।

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

यह दृष्टिकोण संभवतः अधिकांश लोगों के लिए पर्याप्त होगा।

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

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

संपादित करें 2: ध्यान दें कि ES2017 के बाद से आप उपयोग कर सकते हैं String.prototype.padStart:

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

— रेव चेतबॉक्स
स्रोत

यह बड़ी संख्या और नकारात्मक संख्याओं पर बुरी तरह से विफल होता है। number = 123456789, कोड के साथ, ऊपर, उदाहरण के लिए।

— ब्रॉक एडम्स

यह समाधान निश्चित परिदृश्यों के लिए सबसे अच्छा संभव है! मुझे कोई सुराग नहीं मिला है कि हम इससे पहले क्यों नहीं आए। परिदृश्य यह है: आपको एक संख्या मिली है जो हमेशा सकारात्मक है [जैसा कि ब्रॉक ने उल्लेख किया है] और आप जानते हैं कि यह आपकी सीमा से अधिक वर्ण नहीं लेगा। हमारे मामले में हमारे पास एक स्कोर है जिसे हम अमेज़ॅन एसडीबी में स्टोर करते हैं। जैसा कि आप जानते हैं कि एसडीबी संख्याओं की तुलना नहीं कर सकता है, इसलिए सभी अंकों को शून्य गद्देदार होना चाहिए। यह बेहद आसान और प्रभावी है!

— क्रिस्टियन

4

क्षमा याचना, मुझे यह उल्लेख करना चाहिए कि यह ऋणात्मक संख्याओं के लिए काम नहीं करेगा। मुझे लगता है कि यह अधिक सामान्य सकारात्मक संख्या के मामले से संबंधित है, हालांकि। यह वही करता है जो मुझे चाहिए, कम से कम!

— चेतबॉक्स

यह फिर से जरूरत है और एहसास हुआ कि आप की जरूरत नहीं है new String । आप केवल स्ट्रिंग शाब्दिक का उपयोग कर सकते हैं।

— chetbox

3

(new Array(padding + 1).join("0")से बदला जा सकता है"0".repeat(padding)

— पावेल

34

आधुनिक ब्राउज़र अब समर्थन करते हैं padStart, आप बस अब कर सकते हैं:

string.padStart(maxLength, "0");

उदाहरण:

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

स्निपेट का विस्तार करें

— फ्लिम
स्रोत

@ फीलम बेझिझक संपादित करें कि उत्तर में :) यह 4 साल पहले लिखा गया था इसलिए मुझे यकीन है कि चीजें अब बदल गई हैं

— स्टर्लिंग आर्चर

27

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

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" का मान पैदा करेगा। हजारों के लिए अल्पविराम विभाजकों का उपयोग करने के लिए सही का उपयोग करते हुए समूह बदलें।

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

पूरा उदाहरण

— डैनियल बरबलेस
स्रोत

वाह, यह एक सुपर साफ समाधान है और नोड में काम करता है।

— जिशि

मैं चकित हो गया जब मैंने परिचय पढ़ा - "अनावश्यक जटिल सुझाव"। सॉफ्टवेयर इंजीनियरिंग, जैसा कि सभी इंजीनियरिंग विषयों में होता है, इसमें ट्रेड-ऑफ का वजन होता है। मैंने स्वयं "यह मानक तरीका" आजमाया - और इसे समयबद्ध किया। यह निश्चित रूप से काम करता है, लेकिन मैं इसे किसी भी तरह के दोहराए जाने वाले एप्लिकेशन के लिए उपयोग करने का विकल्प कभी नहीं चुनूंगा क्योंकि यह अन्य "होम रोल्ड" समाधानों में से कई की तुलना में धीमा है।

— भालू

1

सच है, बहुत सारे बिल्ट-इन जावास्क्रिप्ट फ़ंक्शंस खराब प्रदर्शन करते हैं जब बहुत सारे डेटा पर लूपिंग होता है, लेकिन मेरा तर्क है कि आपको इसके लिए जावास्क्रिप्ट का उपयोग नहीं करना चाहिए, यहां तक कि नोड-जे की तरह सर्वर-साइड भी। यदि आपके पास सर्वर-साइड को संसाधित करने के लिए बहुत सारे डेटा हैं, तो आपको .NET या Java जैसे बेहतर प्लेटफॉर्म का उपयोग करना चाहिए। यदि आप अंतिम उपयोगकर्ता के प्रदर्शन के लिए क्लाइंट-साइड डेटा संसाधित कर रहे हैं, तो आपको केवल उस डेटा के लिए प्रक्रिया करनी चाहिए जो आप वर्तमान उपयोगकर्ता की स्क्रीन पर दे रहे हैं। उदाहरण के लिए, केवल एक तालिका की दृश्य पंक्तियों को प्रस्तुत करें और अन्य सड़कों के लिए डेटा संसाधित न करें।

— डैनियल बारबेलस

21

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

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/

— jfriend00
स्रोत

@BrockAdams - आपके द्वारा उल्लिखित दोनों मामलों के लिए निर्धारित। यदि संख्या पहले से ही भरण चौड़ाई जितनी चौड़ी है, तो कोई भरण नहीं जोड़ा जाता है।

— jfriend00

धन्यवाद; +1। नकारात्मक संख्या सामान्य सम्मेलन से थोड़ी दूर है, हालांकि। उदाहरण के लिए , आपके परीक्षण के मामले में, -88उपज चाहिए "-00088"।

— ब्रॉक एडम्स

1

@BrockAdams - मुझे यकीन नहीं था कि कॉलिंग zeroFill(-88, 5)का उत्पादन करना चाहिए -00088या -0088? मुझे लगता है कि यह इस बात पर निर्भर करता है कि आप widthतर्क को संख्या की पूरी चौड़ाई या केवल अंकों की संख्या (नकारात्मक संकेत सहित नहीं) चाहते हैं। एक कोडर आसानी --widthसे कोड की लाइन को हटाकर नकारात्मक संकेत को शामिल नहीं करने के लिए व्यवहार को स्विच कर सकता है ।

— jfriend00

19

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

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

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

— जोहान फिलिप स्ट्रैटहॉज़न
स्रोत

1

मुझे मिल गया y="0005"ऊपर के साथ, y = (new Array(count + 1 - x.toString().length)).join('0') + x;क्या मुझे दिया हैy="000005"

— forforf

3

@OrSiloni: सबसे छोटा कोड समाधान वास्तव में है('0000'+n).slice(-4)

— Seaux

14

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

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

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

    return result;
}

— विल्को
स्रोत

मुझे नहीं लगता कि कोई "सरल" समाधान होगा - यह हमेशा किसी प्रकार का एक कार्य होगा। हम एक एल्गोरिथ्म चर्चा कर सकते हैं, लेकिन दिन के अंत में, आप अभी भी एक फ़ंक्शन के साथ समाप्त होंगे जो एक संख्या को फिर से परिभाषित करता है।

— पीटर बैली

मेरी सामान्य सलाह "छोरों" के लिए "का उपयोग करना" है क्योंकि वे आम तौर पर ECMAScript भाषाओं में अधिक स्थिर और तेज़ होते हैं (एक्शनस्क्रिप्ट 1-3 और जावास्क्रिप्ट)

— cwallenpoole

या, पुनरावृति को पूरी तरह से छोड़ दें;)

— पीटर बैली

सरल कार्य? शायद ऩही। एक कि पाश नहीं है? यह संभव है ... हालांकि एल्गोरिथ्म पूरी तरह से तुच्छ नहीं है।

— कोडरजो

1

वाह, बहुत उपरोक्त सभी टिप्पणियां गलत हैं। @ प्रोफाइटोलॉज़ का समाधान सरल और इनलाइनिंग के लिए उपयुक्त है (इसके लिए फ़ंक्शन की आवश्यकता नहीं है)। इस बीच, for.vs whileप्रदर्शन दिलचस्प होने के लिए अलग-अलग नहीं है: jsperf.com/fors-vs-ORE/34

— ब्रूफ़ो

12

यहाँ पार्टी के लिए देर हो रही है, लेकिन मैं अक्सर इस निर्माण का उपयोग कुछ मूल्य के एड-हॉक पैडिंग करने के लिए करता हूं n, जिन्हें एक सकारात्मक, दशमलव के रूप में जाना जाता है:

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

कहाँ पे offset10 ^ ^ अंक है।

उदाहरण के लिए 5 अंक, जहां n = 123:

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

इस का हेक्सिडेसिमल संस्करण थोड़ा अधिक क्रिया है:

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

नोट 1: मुझे @ profitehlolz का सॉल्यूशन भी पसंद है, जो स्लाइस () के निफ्टी निगेटिव-इंडेक्स फीचर का उपयोग करते हुए इसका स्ट्रिंग संस्करण है।

— broofa
स्रोत

12

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

समारोह:

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

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

— Vitim.us
स्रोत

11

मैं 5 अंकों का प्रतिनिधित्व पाने के लिए इस स्निपेट का उपयोग करता हूं

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

— जस्तो सलाटो
स्रोत

11

ECMAScript 2017: पैडस्टार्ट या पैडएंड का उपयोग करें

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

और जानकारी:

— juFo
स्रोत

9

मठ की शक्ति!

x = पैड के लिए
y = शून्य की संख्या के लिए पूर्णांक

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

— टीआईआर
स्रोत

9

मैंने किसी को भी इस तथ्य को इंगित नहीं किया कि आप String.prototype.substr () का उपयोग कब करते हैं नकारात्मक संख्या के साथ करते हैं तो यह दाईं ओर से गिना जाता है।

ओपी के प्रश्न के लिए एक लाइनर समाधान, संख्या 5 का एक 6-अंकीय शून्य प्रतिनिधित्व है:

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

स्निपेट का विस्तार करें

सामान्यीकरण हम प्राप्त करेंगे:

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

स्निपेट का विस्तार करें

— स्टीफन क्वान को दर्शाता है
स्रोत

8

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

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

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

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

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

तो, किस लूप का उपयोग करना है? खैर, यह एक whileपाश होगा। एक forलूप अभी भी तेज है, लेकिन एक 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'

— जैक बी
स्रोत

मैंने इसे दूसरों के परीक्षण के लिए त्वरित बनाने के लिए एक jsfiddle में डाला, कोड के अपने संस्करण को जोड़ते हुए: jsfiddle.net/kevinmicke/vnvghw7y/2 आपका संस्करण हमेशा बहुत प्रतिस्पर्धात्मक होता है, और कभी-कभी सबसे तेज़ होता है। काफी संपूर्ण परीक्षण के लिए धन्यवाद।

— kevinmicke

8

पहला पैरामीटर कोई भी वास्तविक संख्या है, दूसरा पैरामीटर दशमलव बिंदु के बाईं ओर न्यूनतम अंकों की संख्या निर्दिष्ट करने वाला एक सकारात्मक पूर्णांक है और तीसरा पैरामीटर दशमलव बिंदु के दाईं ओर अंक होने पर संख्या को निर्दिष्ट करने वाला एक वैकल्पिक सकारात्मक पूर्णांक है।

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
}

इसलिए

           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'

— जैक एलन को प्रकट करता है
स्रोत

8

पहिया को सुदृढ़ न करें, अंडरस्कोर स्ट्रिंग का उपयोग करें :

jsFiddle

var numToPad = '5';

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

— बेनी बोटेमा
स्रोत

8

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

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

स्निपेट का विस्तार करें

— लेविस
स्रोत

स्पष्ट रूप से सबसे सुरुचिपूर्ण समाधान मैं इसे 2 स्ट्रिंग रूपांतरणों से बचने के लिए संशोधित करूंगा: const numStr = String(num)औरreturn '0'.repeat(len - numStr.length) + numStr;

— 21

8

सभी आधुनिक ब्राउज़रों में आप उपयोग कर सकते हैं

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

स्निपेट का विस्तार करें

यहाँ MDN संदर्भ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart है

— लाइफ हैक
स्रोत

5

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

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

— कला
स्रोत

1

बेहतर:var zfill = _.partialRight(_.padStart, '0');

— दरोगाओं

3

कुछ लोग शायद विरोध करेंगे "मैं लॉश का उपयोग नहीं करना चाहता" लेकिन यह शायद ही अब तक एक वैध तर्क है क्योंकि आप केवल इस फ़ंक्शन को स्थापित कर सकते हैं: और npm install --save lodash.padleftउसके बादimport padLeft from 'lodash.padleft'_.

— एंडी

5

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

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

output: "02"

— MRE
स्रोत

(8).toLocaleString(undefined, {minimumIntegerDigits: 5})"00.008"मेरे लोकल के आधार पर, मेरे लिए रिटर्न ।

— le_m

5

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

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

स्निपेट का विस्तार करें

— चलता है
स्रोत

किस अन्य के रूप में?

— फैबियो का कहना है कि

4

यह कम मूल है, लेकिन सबसे तेज़ हो सकता है ...

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

— जोनाथन नील
स्रोत

मुझे लगता है कि आप करना चाहते हैं pad = count - (num + '').length। नकारात्मक संख्याओं को अच्छी तरह से नियंत्रित नहीं किया जाता है, लेकिन इसके अलावा, यह बुरा नहीं है। +1

— निक सिप

3

मेरा समाधान

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

— अलेक्सांद्र टोपलेक
स्रोत

3

पुनरावृत्ति का उपयोग क्यों नहीं करते?

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

— रेक्स lex82
स्रोत

पैडजेरो (223, 3) '0223' के साथ विफल रहता है

— सेर्जिनो

खैर, मैंने मान लिया कि इस फ़ंक्शन को पहले पैरामीटर के रूप में एक स्ट्रिंग के साथ कहा जाता है। हालाँकि, मैंने इसे ठीक कर लिया।

— lex82

2

कुछ मंकीपैकिंग भी काम करती है

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"

— रॉड्रिगो
स्रोत

1

-1 जावास्क्रिप्ट में टॉपवेल नेमस्पेसिंग को बंद करना बुरा व्यवहार है।

— जेरेमी वॉल

2

ऑब्जेक्ट और एरे ऑब्जेक्ट्स के लिए सही है, लेकिन स्ट्रिंग खराब नहीं है

— रॉड्रिगो

2

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

...आदि।

चियर्स

— Madbreaks
स्रोत

मुझे लगता है कि इसे और अधिक होना चाहिए: var s = String(toPad); return (s.length < length) ? new Array(length - s.length + 1).join('0') + s : s;यदि आप इसे ठीक करते हैं तो मैं अपना डाउन वोट हटा दूंगा।

— '20

@drewish उस पकड़ने के लिए धन्यवाद, मैं आपके संपादन से सहमत हूं (हार्डकॉन्ड 0जॉइन चार को छोड़कर :) - जवाब अपडेट किया गया।

— मैडब्रेक्स

मुझे लगता है कि स्ट्रिंग को एक अस्थायी चर में स्टोर करना बेहतर होगा। मैंने यहाँ कुछ बेंचमार्किंग की थी: jsperf.com/padding-with-memoization यह भी नए "ऐरे" में नए के उपयोग के लिए बेंचमार्क मिला है नए के लिए परिणाम सभी जगह हैं, लेकिन मेमोआजेशन जाने के तरीके की तरह है।

— 12'12

2

सबसे सरल , सबसे सीधा-सीधा समाधान आपको मिलेगा।

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

— d4nyll
स्रोत