एक नंबर से नगण्य अनुगामी शून्य निकालें?

Question

क्या मैंने एक मानक एपीआई कॉल को याद किया है जो एक नंबर से नगण्य शून्य को हटा देता है?

पूर्व।

var x = 1.234000 // to become 1.234;
var y = 1.234001; // stays 1.234001

Number.toFixed () और Number.toPreicy () काफी नहीं हैं जो मैं देख रहा हूं।

Comments

उम, 1.234000 === 1.234।

— गुमबो ३

हाँ, अगर आप सतर्क करते हैं (x) यह बिना पीछे वाले शून्य के पॉप अप करता है

— JKirchartz

कई ग्राहकों के साथ काम करने के बाद, मैं गवाही दे सकता हूं कि 1.234000 === 1.234 होने के बावजूद, ग्राहक उन अतिरिक्त शून्य को नहीं देखना चाहते हैं, अगर उन्हें जरूरत नहीं है।

— संपर्कमात

का उपयोग करें parseFloat(n)?

— श्री एलियन

यह सबसे आसान समाधान था जिसने मेरे लिए सभी किनारे मामलों को कवर किया, धन्यवाद @ Mr.Alien।

— जेम्स पेरिह

Answer 1

यदि आप इसे एक स्ट्रिंग में परिवर्तित करते हैं, तो यह किसी भी अनुगामी शून्य को प्रदर्शित नहीं करेगा, जो पहले नंबर पर चर में संग्रहीत नहीं किया गया है क्योंकि इसे एक संख्या के रूप में बनाया गया था, न कि एक स्ट्रिंग के रूप में।

var n = 1.245000
var noZeroes = n.toString() // "1.245" 

Comments

मैं शून्य को हटाने के लिए कुछ कोड पोस्ट करने वाला था, लेकिन डैनियल का समाधान काम करने लगता है। यह "1.2345000" जैसे स्ट्रिंग्स के लिए भी काम करता है। ("1.2345000" * 1) .toString (); // बन जाता है 1.2345

— स्टीवन

बेशक, यदि आपका

— संस्करण

यह बहुत अच्छा काम किया। मैं एक ही मुद्दा था, स्ट्रिंग के लिए नाव और फिर parseFloat परिवर्तित इसे सही स्वरूप में वापस लाने के लिए, केवल पीछे चल रहे शून्य के बिना।

— मैट वेस्ट

यह पूर्ण समाधान नहीं है। यह आपको कुछ चल बिन्दु प्रतिनिधित्व त्रुटि के साथ चर, जैसे जब काम नहीं करता है: var n = 1.245000000000001(यह मानते हुए यह उपयोगकर्ता के लिए प्रतिनिधित्व करने नगण्य है)

— शकुनश

संख्याओं के लिए अप्रत्याशित परिणाम उत्पन्न कर सकते हैं: 1231111111111111111111111111112122222222222222222222222222222222222222222222222.00 से लोगों के लिए परिणाम देखें। स्ट्रिंग प्रतिनिधित्व घातीय प्रारूप में होगा: 1.231111111111111e + 81

— स्टैस मकुतिन

Answer 2

मेरे पास एक समान उदाहरण था जहां मैं .toFixed()जहां आवश्यक था उपयोग करना चाहता था , लेकिन मैं नहीं चाहता था कि जब यह नहीं था तो पैडिंग नहीं थी। तो मैं समाप्त हो गया parFFloat का उपयोग कर के साथ संयोजन में।

पैडिंग के बिना

parseFloat(n.toFixed(4));

एक अन्य विकल्प जो लगभग एक ही काम करता है
यह उत्तर आपके निर्णय की मदद कर सकता है

Number(n.toFixed(4));

---

toFixedएक विशिष्ट लंबाई के लिए संख्या को गोल / पैड करेगा, लेकिन इसे स्ट्रिंग में भी बदल देगा। एक संख्यात्मक प्रकार पर वापस लौटना, न केवल अंक को अंकगणितीय रूप से उपयोग करने के लिए सुरक्षित करेगा, बल्कि स्वचालित रूप से किसी भी 0 के निशान को छोड़ देगा। उदाहरण के लिए:

var n = "1.234000";
    n = parseFloat(n);
 // n is 1.234 and in number form

क्योंकि यहां तक ​​कि अगर आप शून्य को पीछे छोड़ते हुए एक संख्या को परिभाषित करते हैं तो वे गिर जाते हैं।

var n = 1.23000;
 // n == 1.23;

Comments

ध्यान दें कि यह केवल तभी काम करता है जब दशमलव की प्रासंगिक संख्या फ़िक्स्ड तर्क से समान या अधिक हो। यदि संख्या उदाहरण के लिए 1.200000 है तोफल (3) का परिणाम 1.200 होगा और इस प्रकार, सभी अनुगामी शून्य को हटाया नहीं जाएगा।

— लियोपोल्डो सैंसिएक

@LeopoldoSanczyk नहीं, यह केवल तभी सच है जब आप केवल उपयोग कर रहे हैं, क्योंकि यह एक स्ट्रिंग लौटाता है। संख्या प्रकार स्वचालित रूप से ट्रेलिंग शून्य खो देते हैं। इसलिए मैंने दोनों को मिलाप में इस्तेमाल किया।

— गैरी

@ गैरी, मैं अपनी टिप्पणी वापस लेता हूं, मैंने parseFloat(n).toFixed(4);आपके वास्तविक उत्तर के बजाय देखा है । मुझे माफ कर दो।

— लियोपोल्डो सैंसिएक 5

क्यों नहीं +(n.toFixed(4))?

— Константин Ван

upvoted! आपके उत्तर के साथ केवल एक समस्या 0.00000005 5e-8 में परिवर्तित हो जाती है मैं इस समस्या के बिना तुच्छ जीरो को कैसे हटा सकता हूं, मैं छोटी संख्या के साथ काम कर रहा हूं जैसे कि 0.000058000 जहां अंत में शून्य हटाए जाने की आवश्यकता है

— PiritAppApp

Answer 3

मैंने पहली बार मैटी-लिरा और गैरी के उत्तरों का एक संयोजन इस्तेमाल किया:

r=(+n).toFixed(4).replace(/\.0+$/,'')

परिणाम:

• 1234870.98762341: "1234870.9876"
• 1230009100: "1230009100"
• 0.0012234: "0.0012"
• 0.1200234: "0.12"
• 0.000001231: "0"
• 0.10001: "0.1000"
• "asdf": "NaN" (तो कोई रनटाइम त्रुटि)

कुछ समस्याग्रस्त मामला 0.10001 है। मैंने इस लंबे संस्करण का उपयोग करके समाप्त किया:

    r = (+n).toFixed(4);
    if (r.match(/\./)) {
      r = r.replace(/\.?0+$/, '');
    }

• 1234870.98762341: "1234870.9876"
• 1230009100: "1230009100"
• 0.0012234: "0.0012"
• 0.1200234: "0.12"
• 0.000001231: "0"
• 0.10001: "0.1"
• "asdf": "NaN" (तो कोई रनटाइम त्रुटि)

अपडेट : और यह गैरी का नया संस्करण है (टिप्पणियां देखें):

r=(+n).toFixed(4).replace(/([0-9]+(\.[0-9]+[1-9])?)(\.?0+$)/,'$1')

यह ऊपर के रूप में एक ही परिणाम देता है।

Comments

मुझे एक शुद्ध रेगेक्स समाधान मिला है जो मुझे लगता है कि काम करता हैtoFixed(4).replace(/([0-9]+(\.[1-9]+)?)(\.?0+$)/,"$1")

— गैरी

गाह! जाहिरा तौर पर मैं दूसरों की तुलना में अपने खुद के RegExes को तोड़ने में लगभग उतना अच्छा नहीं हूं। मैं यह मुझे हरा नहीं होने दूंगा! मैंने इसे आपके सभी परीक्षण मामलों के विरुद्ध चलाया (कोई भी मान्य) जो मैं सोच सकता था([0-9]+(\.[0-9]+[1-9])?)(\.?0+$)

— गैरी

रेगेक्स एक लालच है कभी-कभी पूर्णांक भाग से एक "0" निकालता है! :-( सिर्फ क्यों नहीं replace(/[,.][1-9]+(0+)/,'')?

— सेबेस्टियन सेबल

इसका उत्तर दिया गया।

— चार्ली

@ w00t ओह, माफ करना, मैं अब समझ गया हूं। मैं जिस तरह से परीक्षण किया था जब मैं अपना बना (ऊपर लिंक देखें)। जब आप फ़िक्स का उपयोग करते हैं तो आपका विफल नहीं होता है, क्योंकि नंबर की बिंदी की गारंटी होती है, लेकिन यह मेरे परीक्षणों में विफल हो रहा था क्योंकि मैं चाहता था कि किसी भी संख्या के लिए regex काम करे, जिसमें कोई भी बिंदु नहीं है। बिना फ़िक्स के, यह अंत में एक शून्य खाता है। मेरी गलती।

— गीकले

Answer 4

toFixedविधि आवश्यक होने पर उपयुक्त राउंडिंग करेंगे। इसमें ट्रेलिंग जीरो भी जोड़ा जाएगा, जो हमेशा आदर्श नहीं होता है।

(4.55555).toFixed(2);
//-> "4.56"

(4).toFixed(2);
//-> "4.00"

यदि आप किसी संख्या में रिटर्न वैल्यू डालते हैं, तो वे अनुगामी शून्य को गिरा दिया जाएगा। यह आपकी खुद की गोलाई या ट्रंकेशन गणित करने की तुलना में एक सरल तरीका है।

+(4.55555).toFixed(2);
//-> 4.56

+(4).toFixed(2);
//-> 4

Comments

मुश्किल है, लेकिन वास्तव में मैं क्या देख रहा हूँ: महत्वपूर्ण अनुगामी शून्य को हटाना (जो निश्चित रूप से हमने toFixedकॉल के माध्यम से महत्वपूर्ण बना दिया है )। यह एक अजीब यूएक्स एज मामला है।

— वर्स

Answer 5

मुझे मूल रूप से एक ही आवश्यकता थी, और पाया कि इस कार्यक्षमता के लिए कोई अंतर्निहित तंत्र नहीं है।

अनुगामी शून्य को ट्रिम करने के अलावा, मुझे उपयोगकर्ता के वर्तमान लोकेल (यानी 123,456.789) के लिए आउटपुट को राउंड ऑफ और फॉर्मेट करने की भी आवश्यकता थी।

इस पर मेरे सभी काम GitHub पर prettyFloat.js (MIT लाइसेंस प्राप्त) के रूप में शामिल किए गए हैं: https://github.com/dperish/prettyFloat.js

---

उपयोग के उदाहरण:

prettyFloat(1.111001, 3) // "1.111"
prettyFloat(1.111001, 4) // "1.111"
prettyFloat(1.1111001, 5) // "1.1111"
prettyFloat(1234.5678, 2) // "1234.57"
prettyFloat(1234.5678, 2, true) // "1,234.57" (en-us)

---

---

अपडेट किया गया - अगस्त, 2018

---

सभी आधुनिक ब्राउज़र अब ECMAScript अंतर्राष्ट्रीयकरण API का समर्थन करते हैं , जो भाषा को संवेदनशील स्ट्रिंग तुलना, संख्या स्वरूपण और दिनांक और समय स्वरूपण प्रदान करता है।

let formatters = {
    default: new Intl.NumberFormat(),
    currency: new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', minimumFractionDigits: 0, maximumFractionDigits: 0 }),
    whole: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }),
    oneDecimal: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 1, maximumFractionDigits: 1 }),
    twoDecimal: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 2, maximumFractionDigits: 2 })
};

formatters.twoDecimal.format(1234.5678);  // result: "1,234.57"
formatters.currency.format(28761232.291); // result: "$28,761,232"

पुराने ब्राउज़रों के लिए, आप इस पॉलीफ़िल का उपयोग कर सकते हैं: https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.en

Comments

यही वह चीज थी जिसकी तलाश थी। आपको एक npm पैकेज बनाना होगा।

— EnZo

इसलिए मुझे शायद इसे अपडेट करना चाहिए, क्योंकि यह अब अंतर्राष्ट्रीयकरण एपीआई के माध्यम से संभव है।

— dperish

यह बहुत उपयोगी है, साझा करने के लिए धन्यवाद और अपडेट के लिए धन्यवाद।

— jaggedsoft

Answer 6

कैसे इस तरह से एक से गुणा करने के बारे में?

var x = 1.234000*1; // becomes 1.234

var y = 1.234001*1; // stays as 1.234001

Answer 7

आप फ़्लोटिंग संख्याओं को छोटा करने के लिए इसे आज़मा सकते हैं

var n = 0.0000;
n = parseFloat(n.toString()); 

//output n = 0; 
// n = 3.14000; --> n = 3.14;

Answer 8

शुद्ध रेगेक्स उत्तर

n.replace(/(\.[0-9]*[1-9])0+$|\.0*$/,'$1');

मुझे आश्चर्य है कि किसी ने एक क्यों नहीं दिया!

Comments

यह संख्याओं के साथ काम नहीं करेगा (मूल प्रश्न में संख्याएँ बताई गई हैं)। मैं एक स्ट्रिंग प्रतिनिधित्व के लिए समाधान प्यार करता हूँ, हालांकि!

— बेनीहिलर्स

Answer 9

मुझे इस समस्या को भी हल करने की आवश्यकता थी जब Django एक पाठ क्षेत्र में दशमलव प्रकार के मानों को प्रदर्शित कर रहा था। उदा जब '1' का मान था। यह '1.00000000' दिखाएगा। यदि '1.23' मान था, तो यह '1.23000000' दिखाएगा (8 के 'दशमलव_प्लेसेस' की सेटिंग के मामले में)

ParseFloat का उपयोग करना मेरे लिए कोई विकल्प नहीं था क्योंकि यह संभव है कि यह ठीक उसी मूल्य को वापस नहीं करता है। toFixed एक विकल्प नहीं था क्योंकि मैं कुछ भी गोल नहीं करना चाहता था, इसलिए मैंने एक फ़ंक्शन बनाया:

function removeTrailingZeros(value) {
    value = value.toString();

    # if not containing a dot, we do not need to do anything
    if (value.indexOf('.') === -1) {
        return value;
    }

    # as long as the last character is a 0 or a dot, remove it
    while((value.slice(-1) === '0' || value.slice(-1) === '.') && value.indexOf('.') !== -1) {
        value = value.substr(0, value.length - 1);
    }
    return value;
}

Comments

यह काम करता है, हालांकि यह काफी अक्षम है, क्योंकि इसके परिणामस्वरूप प्रति निष्पादन कई तार पैदा होते हैं। एक तालिका में सभी कक्षों पर इसे चलाने की कल्पना करें, जहां एक अच्छी संख्या थी। एक बेहतर विकल्प यह निर्धारित करना होगा कि कितने ट्रेलिंग शून्य थे, फिर एक बार में स्लाइस करें। यह निर्धारित करना कि एक चरित्र क्या है, काफी हद तक कुशल है, विभाजन को कम करना इतना कम है।

— डेरेक निगेल बार्ट्राम

मैंने आपके सुझाव के समान कुछ किया है डेरेक: github.com/rek/remove-trailing-zeros/blob/master/…

— rekarnar

परफ़ेक्ट टेस्ट यहाँ है: jsperf.com/remove-trailing-zeros/1 , आप सही थे, शून्य को ढूंढना और उन्हें हटाना तेजी से रास्ता है!

— 9

Answer 10

इनमें से किसी भी समाधान ने मेरे लिए बहुत कम संख्या में काम नहीं किया। http://numeraljs.com/ ने मेरे लिए इसे हल किया।

parseFloat(0.00000001.toFixed(8));
// 1e-8

numeral(0.00000001).format('0[.][00000000]');
// "0.00000001"

Comments

यह 6 से अधिक परिशुद्धता नहीं संभाल सकता है। मैं कहूंगा कि यह पुस्तकालय बेकार है अगर यह छोटी संख्या के लिए है। निश्चित रूप से अनुशंसित नहीं है।

— डैनियल Kmak

Answer 11

यदि आप किसी भी कारण से फ्लोट्स का उपयोग नहीं कर सकते हैं (जैसे मनी-फ़्लोट्स शामिल हैं) और पहले से ही एक स्ट्रिंग से शुरू हो रहा है जो एक सही संख्या का प्रतिनिधित्व करता है, तो आप इस समाधान को ढूंढ सकते हैं। यह संख्या को डब्ल्यू / आउट ट्रेलिंग जीरो का प्रतिनिधित्व करते हुए एक स्ट्रिंग को एक संख्या में बदल देता है।

function removeTrailingZeroes( strAmount ) {
    // remove all trailing zeroes in the decimal part
    var strDecSepCd = '.'; // decimal separator
    var iDSPosition = strAmount.indexOf( strDecSepCd ); // decimal separator positions
    if ( iDSPosition !== -1 ) {
        var strDecPart = strAmount.substr( iDSPosition ); // including the decimal separator

        var i = strDecPart.length - 1;
        for ( ; i >= 0 ; i-- ) {
            if ( strDecPart.charAt(i) !== '0') {
                break;
            }
        }

        if ( i=== 0 ) {
            return strAmount.substring(0, iDSPosition);
        } else {
            // return INTPART and DS + DECPART including the rightmost significant number
            return strAmount.substring(0, iDSPosition) + strDecPart.substring(0,i + 1);
        }
    }

    return strAmount;
}

Answer 12

सभी उत्तरों को पढ़ने के बाद - और टिप्पणियाँ - मैंने इसे समाप्त किया:

function isFloat(n) {
    let number = (Number(n) === n && n % 1 !== 0) ? eval(parseFloat(n)) : n;
    return number;
}

मुझे पता है कि प्रयोग करना evalकिसी भी तरह से हानिकारक हो सकता है लेकिन इससे मुझे बहुत मदद मिली।

इसलिए:

isFloat(1.234000);     // = 1.234;
isFloat(1.234001);     // = 1.234001
isFloat(1.2340010000); // = 1.234001

यदि आप दशमलव स्थानों को सीमित करना चाहते हैं, तो toFixed()अन्य के रूप में उपयोग करें ।

let number = (Number(n) === n && n % 1 !== 0) ? eval(parseFloat(n).toFixed(3)) : n;

बस।

Answer 13

मुझे किसी भी ट्रेलिंग शून्य को हटाने की आवश्यकता थी, लेकिन किसी भी शून्य सहित कम से कम 2 दशमलव रखें ।
मैं जिन संख्याओं के साथ काम कर रहा हूं, वे 6 दशमलव संख्या तार हैं, जो .toFixed (6) द्वारा निर्मित हैं।

अपेक्षित परिणाम:

var numstra = 12345.000010 // should return 12345.00001
var numstrb = 12345.100000 // should return 12345.10
var numstrc = 12345.000000 // should return 12345.00
var numstrd = 12345.123000 // should return 12345.123

उपाय:

var numstr = 12345.100000

while (numstr[numstr.length-1] === "0") {           
    numstr = numstr.slice(0, -1)
    if (numstr[numstr.length-1] !== "0") {break;}
    if (numstr[numstr.length-3] === ".") {break;}
}

console.log(numstr) // 12345.10

तर्क:

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

Answer 14

यहाँ एक संभावित समाधान है:

var x = 1.234000 // to become 1.234;
var y = 1.234001; // stays 1.234001

eval(x) --> 1.234
eval(y) --> 1.234001

Comments

आप इस सरल कार्य के लिए जरूरी नहीं है! parseFloat()बहुत उचित होगा।

— हचबाट

eval == दुष्ट। यह प्रयोग कभी मत करो

— ईगोर