दिलचस्प पोस्ट
मैं एक वेबसाइट में अप्रयुक्त छवियों और सीएसएस शैलियों कैसे पा सकता हूं? android.util.AndroidRuntimeException: requestFeature () सामग्री जोड़ने से पहले कहा जाना चाहिए एसक्यूएल सर्वर सीटीई और रिकर्सन उदाहरण जावा में "अंतिम" के रूप में स्थानीय वैरिएबल और विधि मापदंडों को क्यों चिह्नित किया जाएगा? $ रूटस्स्कोप। $ प्रसारण बनाम $ दायरा। $ emit कई बिल्ड कॉन्फ़िगरेशन के लिए अलग ऐप। कॉन्फ़िग कैसे चुनना है PHP के लिए सबसे अच्छा पीडीएफ-एपीआई कौन सा है? वेब एपीआई नियंत्रक में एकाधिक एचटीपीपीओस्ट विधि मैं आईआईएस के लिए आईआईएस को एचटीएमएल 5 मोड में एन्जिलरजेएस एप्लीकेशन में लिखने के लिए कैसे कॉन्फ़िगर करूं? बैंकिंग परिदृश्य के लिए संबंधपरक बीजगणित एक उपकुंजी में एक एकल अल्पविराम से अलग किए गए मान में कई परिणाम एकत्र करें इकाई फ़्रेमवर्क 6 (कोड-प्रथम) में संग्रहित प्रक्रिया को कैसे कॉल करें? समान उपयोगकर्ता नाम के साथ किसी अन्य तालिका से तालिका मान अपडेट करें जावा में प्रतिबिंब के माध्यम से निजी विरासत वाले क्षेत्रों तक पहुंच क्यों एक अप्रयुक्त फ़ंक्शन पैरामीटर मान शून्य करने के लिए डाली?

जावास्क्रिप्ट में सटीक दो दशमलव के साथ एक संख्या को स्वरूपित करना

मेरे पास कोड की यह रेखा है जो मेरी संख्याओं को दो दशमलव स्थानों पर चक्कर लगाती है। लेकिन मुझे इस तरह की संख्याएं मिलती हैं: 10.8, 2.4, आदि। ये दो दशमलव स्थानों का मेरा विचार नहीं हैं, इसलिए मैं निम्नलिखित कैसे सुधार सकता हूं?

Math.round(price*Math.pow(10,2))/Math.pow(10,2); 

मुझे संख्याएं जैसे 10.80, 2.40, आदि चाहिए। JQuery का उपयोग मेरे साथ ठीक है।

वेब के समाधान से एकत्रित समाधान "जावास्क्रिप्ट में सटीक दो दशमलव के साथ एक संख्या को स्वरूपित करना"

फिक्स्ड-पॉइंट नोटेशन का उपयोग कर एक नंबर को प्रारूपित करने के लिए, आप बस फिक्स्ड विधि का उपयोग कर सकते हैं:

 (10.8).toFixed(2); // "10.80" var num = 2.4; alert(num.toFixed(2)); // "2.40" 

ध्यान दें कि toFixed() एक स्ट्रिंग देता है

महत्वपूर्ण : ध्यान दें कि टूफिक्स वास्तव में गोल नहीं है, समय का 90%, यह गोल मान वापस करेगा लेकिन कई मामलों में यह वास्तव में काम नहीं करता है। अपने कंसोल में इसे आज़माएं:

2.005.toFixed(2)

आपको गलत जवाब मिलेगा

जावास्क्रिप्ट में दशमलव गोल करने का कोई स्वाभाविक तरीका नहीं है, आपको अपनी खुद की पॉलिफ़िल की आवश्यकता होगी या पुस्तकालय का उपयोग करना होगा। आप इस https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round के लिए मोज़िला के पॉलीफ़िल को देख सकते हैं

यह एक पुराना विषय है, लेकिन फिर भी शीर्ष-रीलिड Google परिणामों और समाधानों ने समान अस्थायी बिंदु दशांश के मुद्दे को साझा किया। यहां (बहुत सामान्य) फ़ंक्शन जो मैं उपयोग करता हूं, MDN के लिए धन्यवाद :

 function round(value, exp) { if (typeof exp === 'undefined' || +exp === 0) return Math.round(value); value = +value; exp = +exp; if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) return NaN; // Shift value = value.toString().split('e'); value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp))); // Shift back value = value.toString().split('e'); return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)); } 

जैसा कि हम देख सकते हैं, हम इन मुद्दों को नहीं प्राप्त करते हैं:

 round(1.275, 2); // Returns 1.28 round(1.27499, 2); // Returns 1.27 

यह सामान्यता कुछ अच्छे सामान भी प्रदान करता है:

 round(1234.5678, -2); // Returns 1200 round(1.2345678e+2, 2); // Returns 123.46 round("123.45"); // Returns 123 

अब, ओपी के सवाल का जवाब देने के लिए, एक को टाइप करना होगा:

 round(10.8034, 2).toFixed(2); // Returns "10.80" round(10.8, 2).toFixed(2); // Returns "10.80" 

या, एक अधिक संक्षिप्त, कम जेनेरिक फ़ंक्शन के लिए:

 function round2Fixed(value) { value = +value; if (isNaN(value)) return NaN; // Shift value = value.toString().split('e'); value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2))); // Shift back value = value.toString().split('e'); return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2); } 

आप इसे इस पर कॉल कर सकते हैं:

 round2Fixed(10.8034); // Returns "10.80" round2Fixed(10.8); // Returns "10.80" 

विभिन्न उदाहरण और परीक्षण ( @ tj-crowder के लिए धन्यवाद!):

 function round(value, exp) { if (typeof exp === 'undefined' || +exp === 0) return Math.round(value); value = +value; exp = +exp; if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) return NaN; // Shift value = value.toString().split('e'); value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp))); // Shift back value = value.toString().split('e'); return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)); } function naive(value, exp) { if (!exp) { return Math.round(value); } var pow = Math.pow(10, exp); return Math.round(value * pow) / pow; } function test(val, places) { subtest(val, places); val = typeof val === "string" ? "-" + val : -val; subtest(val, places); } function subtest(val, places) { var placesOrZero = places || 0; var naiveResult = naive(val, places); var roundResult = round(val, places); if (placesOrZero >= 0) { naiveResult = naiveResult.toFixed(placesOrZero); roundResult = roundResult.toFixed(placesOrZero); } else { naiveResult = naiveResult.toString(); roundResult = roundResult.toString(); } $("<tr>") .append($("<td>").text(JSON.stringify(val))) .append($("<td>").text(placesOrZero)) .append($("<td>").text(naiveResult)) .append($("<td>").text(roundResult)) .appendTo("#results"); } test(0.565, 2); test(0.575, 2); test(0.585, 2); test(1.275, 2); test(1.27499, 2); test(1234.5678, -2); test(1.2345678e+2, 2); test("123.45"); test(10.8034, 2); test(10.8, 2); test(1.005, 2); test(1.0005, 2); 
 table { border-collapse: collapse; } table, td, th { border: 1px solid #ddd; } td, th { padding: 4px; } th { font-weight: normal; font-family: sans-serif; } td { font-family: monospace; } 
 <table> <thead> <tr> <th>Input</th> <th>Places</th> <th>Naive</th> <th>Thorough</th> </tr> </thead> <tbody id="results"> </tbody> </table> <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> 

मैं आमतौर पर इसे मेरी निजी लाइब्रेरी में, और कुछ सुझावों के बाद और @ TMINeutron समाधान का उपयोग करने में भी जोड़ता हूं, और इसे दशमलव लंबाई के लिए अनुकूली बनाकर, यह सबसे अच्छा फिट बैठता है:

 function precise_round(num, decimals) { var t = Math.pow(10, decimals); return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals); } 

रिपोर्ट अपवादों के लिए काम करेगा

मुझे नहीं पता है कि मैं पिछले उत्तर में शायद एक टिप्पणी क्यों नहीं जोड़ सकता (हो सकता है कि मैं नापसंद अंधा हूँ), लेकिन मैं @ मिगेल के जवाब का उपयोग करते हुए एक समाधान के साथ आया:

 function precise_round(num,decimals) { return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals); } 

और इसकी दो टिप्पणियां (@ बिगोस्तकिम और @ इमर) से:

  • precise_round(1.275,2) साथ समस्या 1.28 नहीं लौट रही है
  • precise_round(6,2) साथ समस्या 6.00 नहीं लौट रही (जैसा कि वह चाहता था)।

मेरा अंतिम समाधान इस प्रकार है:

 function precise_round(num,decimals) { var sign = num >= 0 ? 1 : -1; return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals); } 

जैसा कि आप देख सकते हैं कि मुझे "सुधार" का थोड़ा सा जोड़ना था (यह नहीं है कि यह क्या है, लेकिन मठ के बाद से नुकसानदेह है – आप इसे jsfiddle.net पर देख सकते हैं – यह एकमात्र तरीका है जिसे मैं जानता था कि "ठीक कैसे करना है "यह) यह पहले से गद्देदार संख्या से 0.001 जोड़ता है, इसलिए यह दशमलव मान के दायीं ओर 1 3 0 एस जोड़ रहा है। तो इसका उपयोग करने के लिए सुरक्षित होना चाहिए।

उसके बाद मैंने जोड़ा .toFixed(decimal) को हमेशा सही प्रारूप में संख्या में (दशमलव के सही मात्रा के साथ .toFixed(decimal) आउटपुट करना।

तो यह बहुत ज्यादा है इसे भी इस्तेमाल करें 😉

संपादित करें: नकारात्मक संख्याओं की "सुधार" में जोड़ा गया कार्यक्षमता।

tofixed (एन) दशमलव बिंदु के बाद n लंबाई प्रदान करता है; प्रशुद्धता (एक्स) एक्स कुल लंबाई प्रदान करता है

नीचे इस विधि का उपयोग करें

 // Example: toPrecision(4) when the number has 7 digits (3 before, 4 after) // It will round to the tenths place num = 500.2349; result = num.toPrecision(4); // result will equal 500.2 

और यदि आप चाहते हैं कि संख्या को तय किया जाए

 result = num.toFixed(2); 

100% सुनिश्चित करने का एक तरीका यह है कि आपको 2 दशमलव के साथ एक नंबर मिलता है:

 (Math.round(num*100)/100).toFixed(2) 

यदि यह गोलाई त्रुटियों का कारण बनता है, तो आप निम्नलिखित का उपयोग कर सकते हैं जैसा कि जेम्स ने अपनी टिप्पणी में समझाया है:

 (Math.round((num * 1000)/10)/100).toFixed(2) 

मुझे इस समस्या का सटीक समाधान नहीं मिला, इसलिए मैंने अपना बनाया:

 function inprecise_round(value, decPlaces) { return Math.round(value*Math.pow(10,decPlaces))/Math.pow(10,decPlaces); } function precise_round(value, decPlaces){ var val = value * Math.pow(10, decPlaces); var fraction = (Math.round((val-parseInt(val))*10)/10); //this line is for consistency with .NET Decimal.Round behavior // -342.055 => -342.06 if(fraction == -0.5) fraction = -0.6; val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces); return val; } 

उदाहरण:

 function inprecise_round(value, decPlaces) { return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces); } function precise_round(value, decPlaces) { var val = value * Math.pow(10, decPlaces); var fraction = (Math.round((val - parseInt(val)) * 10) / 10); //this line is for consistency with .NET Decimal.Round behavior // -342.055 => -342.06 if (fraction == -0.5) fraction = -0.6; val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces); return val; } // This may produce different results depending on the browser environment console.log("342.055.toFixed(2) :", 342.055.toFixed(2)); // 342.06 on Chrome & IE10 console.log("inprecise_round(342.055, 2):", inprecise_round(342.055, 2)); // 342.05 console.log("precise_round(342.055, 2) :", precise_round(342.055, 2)); // 342.06 console.log("precise_round(-342.055, 2) :", precise_round(-342.055, 2)); // -342.06 console.log("inprecise_round(0.565, 2) :", inprecise_round(0.565, 2)); // 0.56 console.log("precise_round(0.565, 2) :", precise_round(0.565, 2)); // 0.57 

@ हेरडेव और मैंने jQuery में एक छोटा फ़ंक्शन बनाया है।

आप आगे की कोशिश कर सकते हैं:

एचटीएमएल

 <input type="text" name="one" class="two-digits"><br> <input type="text" name="two" class="two-digits">​ 

jQuery

 // apply the two-digits behaviour to elements with 'two-digits' as their class $( function() { $('.two-digits').keyup(function(){ if($(this).val().indexOf('.')!=-1){ if($(this).val().split(".")[1].length > 2){ if( isNaN( parseFloat( this.value ) ) ) return; this.value = parseFloat(this.value).toFixed(2); } } return this; //for chaining }); }); 

डेमो ऑनलाइन:

http://jsfiddle.net/c4Wqn/

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

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

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

  • एक समर्पित पुस्तकालय का उपयोग करें
  • भंडारण और मान के चारों ओर गुजरने के लिए स्ट्रिंग का उपयोग करें (स्ट्रिंग ऑपरेशन के साथ)
  • पूर्णांक का उपयोग करें (जैसे आप अपने वास्तविक मूल्य के सौवें राशि के आसपास हो सकते हैं, उदाहरण के लिए डॉलर में राशि की बजाय सेंट में राशि)

उदाहरण के लिए, जब सालों की संख्या को संचित करने के लिए पूर्णांक का उपयोग करते हुए, वास्तविक मान को खोजने के लिए कार्य काफी सरल है:

 function descale(num, decimals) { var hasMinus = num < 0; var numString = Math.abs(num).toString(); var precedingZeroes = ''; for (var i = numString.length; i <= decimals; i++) { precedingZeroes += '0'; } numString = precedingZeroes + numString; return (hasMinus ? '-' : '') + numString.substr(0, numString.length-decimals) + '.' + numString.substr(numString.length-decimals); } alert(descale(127, 2)); 

तार के साथ, आपको गोलाई की आवश्यकता होगी, लेकिन यह अभी भी प्रबंधनीय है:

 function precise_round(num, decimals) { var parts = num.split('.'); var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-'; var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]); var decimalPart = parts.length > 1 ? parts[1] : ''; if (decimalPart.length > decimals) { var roundOffNumber = decimalPart.charAt(decimals); decimalPart = decimalPart.substr(0, decimals); if ('56789'.indexOf(roundOffNumber) > -1) { var numbers = integralPart + decimalPart; var i = numbers.length; var trailingZeroes = ''; var justOneAndTrailingZeroes = true; do { i--; var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i))); if (roundedNumber === '0') { trailingZeroes += '0'; } else { numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes; justOneAndTrailingZeroes = false; break; } } while (i > 0); if (justOneAndTrailingZeroes) { numbers = '1' + trailingZeroes; } integralPart = numbers.substr(0, numbers.length - decimals); decimalPart = numbers.substr(numbers.length - decimals); } } else { for (var i = decimalPart.length; i < decimals; i++) { decimalPart += '0'; } } return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : ''); } alert(precise_round('1.275', 2)); alert(precise_round('1.27499999999999993', 2)); 

नोट करें कि यह समारोह निकटतम तक चलता है, शून्य से संबंधों को दूर करता है , जबकि आईईईई 754 ने निकटतम को गोल करने की सिफारिश की है, फ्लोटिंग प्वाइंट ऑपरेशंस के लिए डिफ़ॉल्ट व्यवहार के रूप में भी संबंध । ऐसे संशोधनों को पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है 🙂

यहाँ एक सरल एक है

 function roundFloat(num,dec){ var d = 1; for (var i=0; i<dec; i++){ d += "0"; } return Math.round(num * d) / d; } 

alert(roundFloat(1.79209243929,4)); तरह प्रयोग करें alert(roundFloat(1.79209243929,4));

Jsfiddle

अपने दशमलव मूल्य को गोल करें, फिर अपने अपेक्षित अंक (ओं) के लिए toFixed(x) लिए उपयोग करें

 function parseDecimalRoundAndFixed(num,dec){ var d = Math.pow(10,dec); return (Math.round(num * d) / d).toFixed(dec); } 

कॉल

parseDecimalRoundAndFixed (10.800243929,4) => 10.80 पार्सदिकमलराउंड एंडफिक्स (10.807243929,2) => 10.81

कुछ वैश्विक गुंजाइश में निम्नलिखित को रखें:

 Number.prototype.getDecimals = function ( decDigCount ) { return this.toFixed(decDigCount); } 

और फिर कोशिश करें :

 var a = 56.23232323; a.getDecimals(2); // will return 56.23 

अद्यतन करें

ध्यान दें कि toFixed() केवल 0-20 बीच दशमलव अंकों की संख्या के लिए काम कर सकता है अर्थात a.getDecimals(25) एक जावास्क्रिप्ट त्रुटि उत्पन्न कर सकते हैं, ताकि आप कुछ अतिरिक्त चेक यानी जोड़ सकें

 Number.prototype.getDecimals = function ( decDigCount ) { return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount); } 

मैं संशोधक को समस्या ठीक कर रहा हूँ केवल 2 दशमलव का समर्थन करें

 $(function(){ //input number only. convertNumberFloatZero(22); // output : 22.00 convertNumberFloatZero(22.5); // output : 22.50 convertNumberFloatZero(22.55); // output : 22.55 convertNumberFloatZero(22.556); // output : 22.56 convertNumberFloatZero(22.555); // output : 22.55 convertNumberFloatZero(22.5541); // output : 22.54 convertNumberFloatZero(22222.5541); // output : 22,222.54 function convertNumberFloatZero(number){ if(!$.isNumeric(number)){ return 'NaN'; } var numberFloat = number.toFixed(3); var splitNumber = numberFloat.split("."); var cNumberFloat = number.toFixed(2); var cNsplitNumber = cNumberFloat.split("."); var lastChar = splitNumber[1].substr(splitNumber[1].length - 1); if(lastChar > 0 && lastChar < 5){ cNsplitNumber[1]--; } return Number(splitNumber[0]).toLocaleString('en').concat('.').concat(cNsplitNumber[1]); }; }); 
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script> 
 (Math.round((10.2)*100)/100).toFixed(2) 

यह उपज होना चाहिए: 10.20

 (Math.round((.05)*100)/100).toFixed(2) 

यह पैदा करना चाहिए: 0.05

 (Math.round((4.04)*100)/100).toFixed(2) 

इसका उत्पन्न होना चाहिए: 4.04

आदि।

 Number(((Math.random() * 100) + 1).toFixed(2)) 

यह एक यादृच्छिक संख्या को 1 से 100 गोल करने के लिए दो दशमलव स्थानों पर वापस लौटाएगा।

 /*Due to all told stuff. You may do 2 things for different purposes: When showing/printing stuff use this in your alert/innerHtml= contents: YourRebelNumber.toFixed(2)*/ var aNumber=9242.16; var YourRebelNumber=aNumber-9000; alert(YourRebelNumber); alert(YourRebelNumber.toFixed(2)); /*and when comparing use: Number(YourRebelNumber.toFixed(2))*/ if(YourRebelNumber==242.16)alert("Not Rounded"); if(Number(YourRebelNumber.toFixed(2))==242.16)alert("Rounded"); /*Number will behave as you want in that moment. After that, it'll return to its defiance. */ 

यह बहुत सरल है और साथ ही अन्य में से किसी के भी काम करता है:

 function parseNumber(val, decimalPlaces) { if (decimalPlaces == null) decimalPlaces = 0 var ret = Number(val).toFixed(decimalPlaces) return Number(ret) } 

चूंकि फिक्स () को केवल संख्याओं पर कॉल किया जा सकता है, और दुर्भाग्य से एक स्ट्रिंग लौटाता है, यह आपके लिए दोनों दिशाओं में सभी पार्सिंग करता है आप एक स्ट्रिंग या एक संख्या पास कर सकते हैं, और आपको हर बार वापस एक नंबर मिलता है! पार्स नंबर (1.4 9) कॉल करने से आपको 1 मिलेगा, और पार्स नंबर (1.4 9 .2) आपको 1.50 दे देंगे। बस उन्हें सर्वश्रेष्ठ की तरह!

आप .toPrecision() विधि और कुछ कस्टम कोड का भी उपयोग कर सकते हैं, और हमेशा एनएटी दशमलव अंकों तक .toPrecision() पूर्णांक लंबाई की परवाह किए बिना।

 function glbfrmt (number, decimals, seperator) { return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals); } 

आप इसे बेहतर उपयोग के लिए एक प्लगइन भी बना सकते हैं।

 Number(Math.round(1.005+'e2')+'e-2'); // 1.01 

यह मेरे लिए काम किया है: राउंडिंग डेसिमलल्स इन जावास्क्रिप्ट

संदर्भ द्वारा इस प्रतिक्रिया का उपयोग करना: https://stackoverflow.com/a/21029698/454827

मैं दशकों के गतिशील संख्या प्राप्त करने के लिए एक फ़ंक्शन का निर्माण करता हूं:

 function toDec(num, dec) { if(typeof dec=='undefined' || dec<0) dec = 2; var tmp = dec + 1; for(var i=1; i<=tmp; i++) num = num * 10; num = num / 10; num = Math.round(num); for(var i=1; i<=dec; i++) num = num / 10; num = num.toFixed(dec); return num; } 

यहाँ काम कर रहे उदाहरण: https://jsfiddle.net/wpxLduLc/

 parse = function (data) { data = Math.round(data*Math.pow(10,2))/Math.pow(10,2); if (data != null) { var lastone = data.toString().split('').pop(); if (lastone != '.') { data = parseFloat(data); } } return data; }; $('#result').html(parse(200)); // output 200 $('#result1').html(parse(200.1)); // output 200.1 $('#result2').html(parse(200.10)); // output 200.1 $('#result3').html(parse(200.109)); // output 200.11 
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"></script> <div id="result"></div> <div id="result1"></div> <div id="result2"></div> <div id="result3"></div> 

100% काम !!! कोशिश करो

 <html> <head> <script> function replacePonto(){ var input = document.getElementById('qtd'); var ponto = input.value.split('.').length; var slash = input.value.split('-').length; if (ponto > 2) input.value=input.value.substr(0,(input.value.length)-1); if(slash > 2) input.value=input.value.substr(0,(input.value.length)-1); input.value=input.value.replace(/[^0-9.-]/,''); if (ponto ==2) input.value=input.value.substr(0,(input.value.indexOf('.')+3)); if(input.value == '.') input.value = ""; } </script> </head> <body> <input type="text" id="qtd" maxlength="10" style="width:140px" onkeyup="return replacePonto()"> </body> </html>