जावास्क्रिप्ट में फ्लोट संख्या को गोल कैसे करें?


298

मैं उदाहरण के लिए दौर की जरूरत 6.688689के लिए 6.7, लेकिन यह हमेशा मुझे पता चलता7

मेरी विधि:

Math.round(6.688689);
//or
Math.round(6.688689, 1);
//or 
Math.round(6.688689, 2);

लेकिन परिणाम हमेशा एक ही होता है 7... मैं क्या गलत कर रहा हूं?




जावास्क्रिप्ट में एन दशमलव स्थानों में राउंड नंबर की संभावित डुप्लिकेट - कृपया एक नया प्रश्न पूछने से पहले खोज का उपयोग करें।
फेलिक्स क्लिंग


1
@ शादो छिपकली सही है। हालाँकि, .toFixedएक स्ट्रिंग लौटाता है। में परिणाम लपेटो सुनिश्चित करें Number()। स्वीकृत उत्तर और अन्य देखें।
जॉर्डन आर्सेनो

जवाबों:


534
Number((6.688689).toFixed(1)); // 6.7

22
एक संख्या को एक स्ट्रिंग में बदलें और फिर से वापस करें? यह तेज नहीं हो सकता।
सीएसएल

यदि आपकी संख्या में आवश्यकता से कम दशमलव है तो अच्छा नहीं है। यह कुछ जोड़ता है
njzk2

2
JS बेंचमार्क शो के रूप में, यह @fivedigit विधि की तुलना में धीमा है
fadomire

13
Number((456.1235).toFixed(3)) -> 456.123, Number((1.235).toFixed(2)) -> 1.24... बेवकूफ JavaSript ...
NoOne

6
यह आप क्या उम्मीद नहीं कर सकते हैं! परिणाम ब्राउज़र पर भी निर्भर हो सकता है, इस प्रश्न को देखें: stackoverflow.com/q/566564/2224996
maja

199
var number = 6.688689;
var roundedNumber = Math.round(number * 10) / 10;

13
यह हमेशा काम नहीं करता है। MDNMath.round(1.005*100)/100 से उदाहरण के लिए ले लो
tybro0103

7
@ tybro0103 फ्लोटिंग पॉइंट एविल: 1.005 * 100 = 100.49999999999999(कम से कम जेएस इंजन में मैंने कोशिश की)। यही कारण है कि यह काम नहीं करता है और आपको कभी भी फ्लोट पर पूरी तरह से सटीक होने पर भरोसा नहीं करना चाहिए।
सूदो

1
गलत। Math.round (1.015 * 100) / 100 रिटर्न 1.01 के बजाय 1.02
Marco Marsala

81

toFixed()फ़ंक्शन का उपयोग करें ।

(6.688689).toFixed(); // equal to 7
(6.688689).toFixed(1); // equal to 6.7
(6.688689).toFixed(2); // equal to 6.69

5
यह आप क्या उम्मीद नहीं कर सकते हैं! परिणाम ब्राउज़र पर भी निर्भर हो सकता है, इस प्रश्न को देखें: stackoverflow.com/q/566564/2224996
maja

9
(6.688689) .toFixed (); "7" के बराबर नहीं है। 7. अन्य उदाहरणों के लिए भी।
वेदो

35

अपडेट (2019-10)। अब नीचे दिए गए रीस डेनियल कोड के लिए धन्यवाद , npm- पैकेज अपेक्षित-राउंड में एक फ़ंक्शन के रूप में उपलब्ध है (एक नज़र डालें)।


आप MDN उदाहरण से सहायक फ़ंक्शन का उपयोग कर सकते हैं । आपके पास और अधिक लचीलापन होगा:

Math.round10(5.25, 0);  // 5
Math.round10(5.25, -1); // 5.3
Math.round10(5.25, -2); // 5.25
Math.round10(5, 0);     // 5
Math.round10(5, -1);    // 5
Math.round10(5, -2);    // 5

अपडेट (2019-01-15)। एमडीएन डॉक्स की तरह लगता है कि अब इस सहायक funcs नहीं है। यहाँ उदाहरण के साथ एक बैकअप है:

// Closure
(function() {
  /**
   * Decimal adjustment of a number.
   *
   * @param {String}  type  The type of adjustment.
   * @param {Number}  value The number.
   * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
   * @returns {Number} The adjusted value.
   */
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === 'undefined' || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
      return NaN;
    }
    // If the value is negative...
    if (value < 0) {
      return -decimalAdjust(type, -value, exp);
    }
    // Shift
    value = value.toString().split('e');
    value = Math[type](+(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));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function(value, exp) {
      return decimalAdjust('round', value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function(value, exp) {
      return decimalAdjust('floor', value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function(value, exp) {
      return decimalAdjust('ceil', value, exp);
    };
  }
})();

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

// Round
Math.round10(55.55, -1);   // 55.6
Math.round10(55.549, -1);  // 55.5
Math.round10(55, 1);       // 60
Math.round10(54.9, 1);     // 50
Math.round10(-55.55, -1);  // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1);      // -50
Math.round10(-55.1, 1);    // -60
Math.round10(1.005, -2);   // 1.01 -- compare this with Math.round(1.005*100)/100 above
Math.round10(-1.005, -2);  // -1.01
// Floor
Math.floor10(55.59, -1);   // 55.5
Math.floor10(59, 1);       // 50
Math.floor10(-55.51, -1);  // -55.6
Math.floor10(-51, 1);      // -60
// Ceil
Math.ceil10(55.51, -1);    // 55.6
Math.ceil10(51, 1);        // 60
Math.ceil10(-55.59, -1);   // -55.5
Math.ceil10(-59, 1);       // -50

2
?? "Math.round10 एक फ़ंक्शन नहीं है"
पीटर क्रूस

1
मुझे यह बेहद उपयोगी लगा, इसलिए इसे बिना अतिरिक्त कोड ब्लोटिंग के उपयोग करने के इच्छुक लोगों के लिए एक त्वरित npm पैकेज में देखा। मूल उत्तर के साथ @aspanchenko को भी श्रेय दिया गया: npmjs.com/package/ अप्रत्याशित-round
रीस डेनियल

19
> +(6.688687).toPrecision(2)
6.7

Numberजावास्क्रिप्ट में एक वस्तु की एक विधि होती है जो वास्तव में आपकी आवश्यकता है। वह विधि है Number.toPrecision([precision])

जैसे इसके साथ .toFixed(1)परिणाम को एक स्ट्रिंग में परिवर्तित करता है, और इसे वापस एक संख्या में परिवर्तित करने की आवश्यकता होती है। +यहाँ उपसर्ग का उपयोग किया गया ।

मेरे लैपटॉप पर साधारण बेंचमार्क:

number = 25.645234 typeof number
50000000 x number.toFixed(1) = 25.6 typeof string / 17527ms
50000000 x +(number.toFixed(1)) = 25.6 typeof number / 23764ms
50000000 x number.toPrecision(3) = 25.6 typeof string / 10100ms
50000000 x +(number.toPrecision(3)) = 25.6 typeof number / 18492ms
50000000 x Math.round(number*10)/10 = 25.6 typeof number / 58ms
string = 25.645234 typeof string
50000000 x Math.round(string*10)/10 = 25.6 typeof number / 7109ms

मेरी राय में यह सबसे अच्छा उत्तर है (सबसे अच्छा अभ्यास के पद में, सबसे सीधा दृष्टिकोण)।
सीजेर

1
1e-10.toPrecision(3): "1.00e-10" - यह महत्वपूर्ण अंकों के लिए गोल है ।
वेस्वोलोड गोलोवानोव

9

आप न केवल उपयोग करना चाहते हैं toFixed(), लेकिन यह भी ceil()और floor()एक नाव पर तो आप निम्न फ़ंक्शन का उपयोग कर सकते हैं:

function roundUsing(func, number, prec) {
    var tempnumber = number * Math.pow(10, prec);
    tempnumber = func(tempnumber);
    return tempnumber / Math.pow(10, prec);
}

पैदा करता है:

> roundUsing(Math.floor, 0.99999999, 3)
0.999
> roundUsing(Math.ceil, 0.1111111, 3)
0.112

युपीडी:

दूसरा संभावित तरीका यह है:

Number.prototype.roundUsing = function(func, prec){
    var temp = this * Math.pow(10, prec)
    temp = func(temp);
    return temp / Math.pow(10, prec)
}

पैदा करता है:

> 6.688689.roundUsing(Math.ceil, 1)
6.7
> 6.688689.roundUsing(Math.round, 1)
6.7
> 6.688689.roundUsing(Math.floor, 1)
6.6

हम कैसे तय करते हैं कि राउंडिंग के लिए छत, फर्श या गोल का उपयोग कब किया जाए? पूर्व के लिए: राउंडयूज़िंग (मैथ.आर्द, 1.015, 2) राउंडयूज़िंग (मैथ.सील, 1.015, 2) 2 अलग-अलग मूल्य दें हम जानते हैं कि
किसका

7

मेरा विस्तारित दौर समारोह:

function round(value, precision) {
  if (Number.isInteger(precision)) {
    var shift = Math.pow(10, precision);
    // Limited preventing decimal issue
    return (Math.round( value * shift + 0.00000000000001 ) / shift);
  } else {
    return Math.round(value);
  }
} 

उदाहरण आउटपुट:

round(123.688689)     // 123
round(123.688689, 0)  // 123
round(123.688689, 1)  // 123.7
round(123.688689, 2)  // 123.69
round(123.688689, -2) // 100
round(1.015, 2) // 1.02

1
यह @ fivedigit के उत्तर के समान है। राउंड (1.015, 2) अभी भी 1.02 के बजाय 1.01 देता है
gaurav5430

@ gaurav5430, आपकी रिपोर्ट के लिए धन्यवाद, मैंने इसे ठीक कर दिया है।
निक त्साइ

6

निचे देखो

var original = 28.59;

var result=Math.round(original*10)/10 तुम लौटोगे वापस 28.6

आशा है कि आप यही चाहते हैं ..


7
"अगर मेरे पास हर बार के लिए एक पैसा था, तो मैंने देखा कि किसी ने मुद्रा को संग्रहीत करने के लिए FLOAT का उपयोग किया है, मेरे पास $ 999.997634 होगा" - बिल्विन।
एमिक्स

2
गलत। Math.round (1.015 * 100) / 100
मार्को मार्सला


2

मुझे लगता है कि यह फ़ंक्शन मदद कर सकता है।

 function round(value, ndec){
    var n = 10;
    for(var i = 1; i < ndec; i++){
        n *=10;
    }

    if(!ndec || ndec <= 0)
        return Math.round(value);
    else
        return Math.round(value * n) / n;
}


round(2.245, 2) //2.25
round(2.245, 0) //2

कुछ अन्य उत्तरों के समान, यह राउंड के लिए विफल रहता है (1.015, 2), जो 1.02 देना चाहिए
gaurav5430

1

मुझे लगता है कि नीचे फ़ंक्शन मदद कर सकता है

function roundOff(value,round) {
   return (parseInt(value * (10 ** (round + 1))) - parseInt(value * (10 ** round)) * 10) > 4 ? (((parseFloat(parseInt((value + parseFloat(1 / (10 ** round))) * (10 ** round))))) / (10 ** round)) : (parseFloat(parseInt(value * (10 ** round))) / ( 10 ** round));
}

उपयोग: roundOff(600.23458,2);वापस आ जाएगी600.23


क्या आप बता सकते हैं कि यह उत्तर क्या जोड़ता है जो पहले से ही पिछले उत्तरों से कवर नहीं किया गया है?
स्टील्थेंनिजा

कुछ अन्य उत्तरों के समान, यह राउंड के लिए विफल रहता है (1.015, 2), जो 1.02 देना चाहिए
gaurav5430

1

यदि आप नोड के संदर्भ में हैं, तो आप मैथज की कोशिश कर सकते हैं

const math = require('mathjs')
math.round(3.1415926, 2) 
// result: 3.14

1

वहाँ विकल्प है .toLocaleString () प्रारूप नंबरों के लिए, स्थानों के बारे में एक बहुत कुछ विकल्प, समूहीकरण, मुद्रा formating, अंकन के साथ। कुछ उदाहरण:

1 दशमलव तक गोल, एक फ्लोट लौटें:

const n = +6.688689.toLocaleString('fullwide', {maximumFractionDigits:1})
console.log(
  n, typeof n
)

2 दशमलव तक गोल, निर्दिष्ट प्रतीक वाली मुद्रा के रूप में प्रारूपित , हजारों के लिए अल्पविराम समूहन का उपयोग करें:

console.log(
  68766.688689.toLocaleString('fullwide', {maximumFractionDigits:2, style:'currency', currency:'USD', useGrouping:true})   
)

स्थानीय मुद्रा के रूप में प्रारूपित करें :

console.log(
  68766.688689.toLocaleString('fr-FR', {maximumFractionDigits:2, style:'currency', currency:'EUR'})   
)

न्यूनतम 3 दशमलव तक, ज़ीरो को प्रदर्शित करने के लिए मजबूर करें:

console.log(
  6.000000.toLocaleString('fullwide', {minimumFractionDigits:3})
)

अनुपात के लिए प्रतिशत शैली। इनपुट * 100% चिन्ह के साथ

console.log(
  6.688689.toLocaleString('fullwide', {maximumFractionDigits:2, style:'percent'})
)



1

मैं बहुत अच्छा समाधान के साथ अगर toFixed () काम नहीं कर रहा है।

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

उदाहरण

roundOff(10.456,2) //output 10.46

0

यदि आप आज Browserify का उपयोग कर रहे हैं, तो आपको कोशिश करनी होगी: roundTo एक बहुत ही उपयोगी NPM लिबास


0

माइनर ने इस उत्तर को दिया :

function roundToStep(value, stepParam) {
   var step = stepParam || 1.0;
   var inv = 1.0 / step;
   return Math.round(value * inv) / inv;
}

roundToStep(2.55, 0.1) = 2.6
roundToStep(2.55, 0.01) = 2.55
roundToStep(2, 0.01) = 2

राउंडटस्टेप (1.015, 0.002) 1.014 देता है। क्या इसका उपयोग करने का सही तरीका है
gaurav5430

@ gaurav5430 कोशिश करें roundToStep(1.015, 0.001)
Crashalot
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.