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

Question

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

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

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

Comments

आपका कोड वास्तव में वही है जो मैं देख रहा था (छोटी JSON फ़ाइल के लिए 7 दशमलव स्थानों पर फ्लोट प्रिसिजन को कम करने के लिए) स्किप करना। स्पीड वैल के लिए Math.pow = Math.round (val * 10000000) / 10000000);

— पावेल

जैसा कि वर्तमान में स्वीकार किया गया उत्तर यकीनन एक व्यापक श्रेणी के मूल्यों के लिए एक गलत परिणाम देता है 0.565, क्योंकि संख्याओं ( 0.575, 1.005) में व्याप्त बढ़ती खराबी के लिए धन्यवाद , क्या मैं इस उत्तर को फिर से देखने का सुझाव दे सकता हूं , जो उन्हें सही लगता है?

— टीजे क्राउडर

हो सकता है कि आप जावास्क्रिप्ट stackoverflow.com/questions/610406/… के

— Thilo

दशमलव स्थान स्थानांतरण और गोलाई विधि के साथ सही तरीके से राउंडिंग करने के बाद, आप number.toFixed(x)इसे आवश्यक राशि के साथ स्ट्रिंग में बदलने के लिए विधि का उपयोग कर सकते हैं । उदाहरण के दौर 1.34को 1.3पार ब्राउज़र विधि के साथ तो साथ स्ट्रिंग के लिए 1 शून्य और परिवर्तित जोड़ने 1.3.toFixed(2)(पाने के लिए "1.30")।

— एडवर्ड

Answer 1

निश्चित-बिंदु संकेतन का उपयोग करके संख्या को प्रारूपित करने के लिए, आप बस toFixed विधि का उपयोग कर सकते हैं :

(10.8).toFixed(2); // "10.80"

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

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

महत्वपूर्ण : ध्यान दें कि toFixed समय का 90% चक्कर नहीं लगाता है, यह गोल मान लौटा देगा, लेकिन कई मामलों के लिए, यह काम नहीं करता है।

उदाहरण के लिए:

2.005.toFixed(2) === "2.00"

अपडेट करें:

आजकल, आप Intl.NumberFormatकंस्ट्रक्टर का उपयोग कर सकते हैं । यह ECMAScript अंतर्राष्ट्रीयकरण एपीआई विशिष्टता (ECMA402) का हिस्सा है । यह भी IE11 सहित बहुत अच्छा ब्राउज़र समर्थन है , और यह पूरी तरह से Node.js में समर्थित है ।

const formatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});

console.log(formatter.format(2.005)); // "2.01"
console.log(formatter.format(1.345)); // "1.35"

आप वैकल्पिक रूप से toLocaleStringविधि का उपयोग कर सकते हैं , जो आंतरिक रूप से Intlएपीआई का उपयोग करेगा :

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

इस API भी आप प्रारूप करने के लिए विकल्प की एक विस्तृत विविधता प्रदान करता है, हजार तरह विभाजक, मुद्रा प्रतीकों, आदि

Comments

सभी ब्राउज़रों में लगातार काम नहीं करता है, यानी (0.09).toFixed(1);IE8 में 0.0 देता है

— ajbeaven

निश्चित नहीं होता है, आप इसे पहले कर सकते हैं: (Math.round (0.09))। toFixed (1);

— 20:02 12

@ ट्रेकंस: यह गलत है। Math.Round(0.09)लौटेगा 0इसलिए यह हमेशा देगा 0.0...

— क्रिस

यह ज्यादातर स्थितियों में एक बुरा विचार है, यह कुछ मामलों में संख्या को स्ट्रिंग या फ्लोट बिंदु संख्या में परिवर्तित करता है।

— ऐश ब्लू

यहाँ @AshBlue साथ सहमत होना होगा ... इस मूल्यों की प्रस्तुति फ़ॉर्मेट करने के लिए केवल सुरक्षित है। आगे की गणना के साथ कोड को तोड़ सकते हैं। अन्यथा Math.round(value*100)/1002DP के लिए बेहतर काम करता है।

— अपरान्ह

Answer 2

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

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>

Comments

ऐसा करने का एक सरल तरीका कैसे नहीं है? बचाव के लिए ES6?

— शून्य_

MDN पॉलीफ़िल पोस्ट करने के लिए धन्यवाद। लिंक किए गए MDN पृष्ठ पर पॉलीफ़िल अब नहीं है। मुझे आश्चर्य है कि इसे क्यों हटा दिया गया ...

— राजा होली

Answer 3

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

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

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

Comments

exact_round (1.275,2) 1.27 है?

— allenhwkim

@Imre वापसी मान को बदलें (Math.round (num * Math.pow (10, दशमलव)) / Math.pow (10, दशमलव))। ToFixed (2); और आपके पास अब वह मुद्दा नहीं होगा।

— dkroy

यदि आप "साइन" और "डिक" की घोषणा करते हैं तो यदि आपका दूसरा कार्य उठाया जाता है तो क्या उन्हें अपरिभाषित नहीं होना चाहिए?

— १२:४४ पर Ady Ngom

मैंने IE में मिगिन साइन मेथड के लिए वर्कअराउंड जोड़ा है: gist.github.com/ArminVieweg/28647e735aa6efaba401

— Armin

@ अर्मिन आपका फिक्स भी सफारी में काम करता है। मूल कार्य सफारी में काम नहीं किया।

— डेव

Answer 4

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

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

और इसकी दो टिप्पणियाँ (@bighostkim और @Imre से):

• 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तीन 0एस जोड़ रहा है । इसलिए इसका उपयोग करना सुरक्षित होना चाहिए।

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

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

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

Comments

"सुधार" ज्यादातर सुरक्षित है, लेकिन उदाहरण के लिए precise_round(1.27499,2)अब 1.28 भी लौटाता है ... ऐसा नहीं है Math.roundकि यह हानिपूर्ण है; जिस तरह से कंप्यूटर आंतरिक रूप से फ्लोटिंग पॉइंट वैल्यू को स्टोर करता है। मूल रूप से, आपके डेटा को आपके फ़ंक्शन तक पहुंचने से पहले कुछ मानों के साथ विफल करने के लिए आपको बर्बाद किया जाता है :)

— Imre

@ मैं, तुम निरपेक्ष सही हो। इसलिए मैं समझाता हूं कि यह 0.001 क्या कर रहा है, अगर कोई इसे "अधिक सटीक " बनाना चाहता है या यहां तक ​​कि इसे हटा भी सकता है (यदि आपके पास प्रति फ्लोट में 2 Mbytes के साथ एक सुपर कंप्यूटर है, तो मुझे नहीं लगता कि यहां कोई भी ऐसा करता है। ;)

— tfrascaroli

वास्तव में, भाषा विनिर्देश संख्या मूल्यों के लिए 64 बिट्स का उपयोग करने के बारे में बहुत विशिष्ट है, इसलिए सुपर कंप्यूटर का उपयोग करने / करने से कुछ भी बदलाव नहीं होगा :)

— Imre

0.001 के लिए आप दशमलव की लंबाई के अनुसार कई शून्य जोड़कर बदल सकते हैं। so ..

— मिगुएल

Answer 5

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

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

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

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

Comments

यह इसे करने का सबसे अच्छा, सरल तरीका है। हालाँकि, फ़्लोटिंग पॉइंट गणित के कारण, 1.275 * 100 = 127.49999999999999 है, जो गोलाई में छोटी त्रुटियों का कारण बन सकता है। इसे ठीक करने के लिए, हम 1000 से गुणा कर सकते हैं और 10 से विभाजित कर सकते हैं, (1.275 * 1000) / 10 = 127.5 के रूप में। इस प्रकार है: var answer = (Math.round((num * 1000)/10)/100).toFixed(2);

— जेम्स गोल्ड

(Math.round ((1.015 * 1000) / 10) / 100) .toFixed (2) अभी भी 1.01 देता है, क्या यह 1.02 नहीं होना चाहिए?

— गौरव ५०३० २६'१

Answer 6

TheFixed (n) दशमलव बिंदु के बाद n लंबाई प्रदान करता है; .Preults (x) x कुल लंबाई प्रदान करता है।

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

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

Comments

यह अच्छी तरह से काम नहीं करता है ... संख्या संख्या = 50.2349 के लिए आपको 50.2 पाने के लिए ThePreaches (3) लिखना चाहिए

— Piotr Czyot

इसका सिर्फ एक उदाहरण आप इसे अपनी आवश्यकता के अनुसार बदल सकते हैं @ PiotrCzy Sy

— सैयद उमर अहमद

Answer 7

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

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

Comments

धन्यवाद। यहाँ यह परीक्षण करने के लिए एक किटी है: jsfiddle.net/lamarant/ySXuF । मैं इसे वापस करने से पहले मूल्य में toFixed () को लागू कर रहा हूं जो कि दिए गए मान के अंत में शून्य की सही संख्या को जोड़ता है।

— लैमरेंट

मान के लिए काम नहीं कर रहा है = 0,004990845956707237 और inprecise_round (value, 8) 0,00499085 रिटर्न करता है, लेकिन इसे 0,00499084

— MERT DOĞAN

Answer 8

@heridev और मैंने 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/

Comments

मैं योगदान की सराहना कर सकता हूं, हालांकि मुझे लगता है कि मिश्रण में DOM तत्वों और jQuery को जोड़ना सवाल के दायरे से बाहर लगता है।

— क्रिस मे

आपको कीअप ईवेंट को नहीं सुनना चाहिए, क्योंकि यह खराब दिखता है और स्क्रिप्ट के साथ कुछ जोड़ने पर सक्रिय नहीं होता है। मैं इस inputघटना को सुनना चाहता हूँ । जब आप JS

— Le 'nton

Answer 9

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

जब कोई कंप्यूटर 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));

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

Answer 10

यहाँ एक सरल है

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

Jsfiddle

Answer 11

अपने दशमलव मान को गोल करें, फिर 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 parseDecimalRoundAndFixed (10.807243929,2) => 10.81

Answer 12

नीचे घूमो

function round_down(value, decPlaces) {
    return Math.floor(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

बढ़ाना

function round_up(value, decPlaces) {
    return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

निकटतम दौर

function round_nearest(value, decPlaces) {
    return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

मर्ज किए गए https://stackoverflow.com/a/7641824/1889449 और https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm उन्हें धन्यवाद दें।

Answer 13

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num + c) * p) / p;
}

// testing some +ve edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

// testing some -ve edge cases
console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

Answer 14

यहाँ मेरा 1-लाइन समाधान है: Number((yourNumericValueHere).toFixed(2));

यहाँ क्या होता है:

1) सबसे पहले, आप .toFixed(2)उस संख्या पर लागू होते हैं, जिसे आप दशमलव स्थानों के चक्कर लगाना चाहते हैं। ध्यान दें कि यह मान को संख्या से स्ट्रिंग में बदल देगा। यदि आप टाइपस्क्रिप्ट का उपयोग कर रहे हैं, तो यह इस तरह एक त्रुटि फेंक देगा:

"टाइप 'स्ट्रिंग' टाइप करने के लिए असाइन नहीं है 'नंबर'"

2) संख्यात्मक मान वापस पाने या स्ट्रिंग को संख्यात्मक मान में बदलने के लिए, बस Number()उस तथाकथित 'स्ट्रिंग' मान पर फ़ंक्शन लागू करें ।

स्पष्टीकरण के लिए, नीचे दिए गए उदाहरण को देखें:

उदाहरण: मेरे पास एक राशि है जो दशमलव स्थानों में ५ अंकों तक है और मैं इसे २ स्थानों तक छोटा करना चाहूंगा। मुझे यह पसंद है:

var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);

Answer 15

रखो निम्नलिखित कुछ वैश्विक दायरे में:

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

Answer 16

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

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

Answer 17

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

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

Answer 18

संदर्भ द्वारा इस प्रतिक्रिया का उपयोग करना: 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/

Answer 19

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>

Answer 20

इन उदाहरणों के साथ आपको अभी भी एक त्रुटि मिलेगी जब नंबर 1.005 को गोल करने की कोशिश करना या तो Math.js या इस फ़ंक्शन जैसी लाइब्रेरी का उपयोग करना है:

function round(value: number, decimals: number) {
    return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}

Answer 21

मुझे कुछ महीने पहले इस पोस्ट से कुछ विचार मिले, लेकिन यहाँ कोई भी उत्तर, और न ही अन्य पोस्ट / ब्लॉग के उत्तर सभी परिदृश्यों को संभाल सकते थे (जैसे नकारात्मक संख्या और कुछ "भाग्यशाली संख्या" जो हमारे परीक्षक को मिली)। अंत में, हमारे परीक्षक को इस विधि के साथ कोई समस्या नहीं मिली। मेरे कोड का स्निपेट पेस्ट करना:

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

मेरे पास कोड टिप्पणियां भी हैं (क्षमा करें, मैं पहले से ही सभी विवरणों को भूल गया हूं) ... मैं भविष्य में संदर्भ के लिए अपना जवाब यहां पोस्ट कर रहा हूं:

9.995 * 100 = 999.4999999999999
Whereas 9.995e2 = 999.5
This discrepancy causes Math.round(9.995 * 100) = 999 instead of 1000.
Use e notation instead of multiplying /dividing by Math.Pow(10,precision).

Answer 22

मैं संशोधक समस्या को ठीक कर रहा हूँ। केवल 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>

Answer 23

(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

आदि।

Answer 24

/*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.
*/

Answer 25

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

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

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

Answer 26

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

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

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

Answer 27

इस के रूप में सरल।

var rounded_value=Math.round(value * 100) / 100;

Comments

गलत। 1.015

— मार्को मार्सला

Answer 28

मुझे एक बहुत ही सरल तरीका मिला जिसने मेरे लिए इस समस्या को हल कर दिया और इसका उपयोग किया जा सकता है या इसे अनुकूलित किया जा सकता है:

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

Answer 29

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>

Comments

एसओ में आपका स्वागत है। कृपया इसे कैसे पढ़ें -उत्तर दें और उत्तर देने के लिए दिशानिर्देश का पालन करें।

— द वेवेयेरे