javascript - मतलब - दशमलव भिन्न में बदलना




अधिकतर 2 दशमलव स्थानों पर गोल करें(केवल तभी आवश्यक हो) (20)

मैं अधिकतर 2 दशमलव स्थानों पर घूमना चाहता हूं, लेकिन केवल तभी आवश्यक हो

इनपुट:

10
1.7777777
9.1

आउटपुट:

10
1.78
9.1

मैं जावास्क्रिप्ट में यह कैसे कर सकता हूं?


2017
बस देशी कोड का उपयोग करें .toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

यदि आपको सख्त होने की आवश्यकता है और आवश्यकता होने पर अंक जोड़ना है तो यह replace कर सकता है

number = 1; // "1"
number.toFixed(5).replace(/\.?0*$/g,'');

आप उपयोग कर सकते हैं

function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}

मैंने इसे MDN पर पाया। उनका तरीका 1.005 के साथ समस्या से बचाता है जिसका mentioned गया था।

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

इस हल्के वजन समाधान का प्रयास करें:

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

इसे करने का एक आसान तरीका यहां दिया गया है:

Math.round(value * 100) / 100

आप आगे बढ़ना चाहते हैं और यह आपके लिए ऐसा करने के लिए एक अलग कार्य कर सकते हैं हालांकि:

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

तो आप बस मूल्य में गुजरेंगे।

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

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}

कोई भी .toFixed(NumberOfDecimalPlaces) उपयोग कर सकते हैं।

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

मार्कजी का जवाब सही है। यहां दशमलव स्थानों की किसी भी संख्या के लिए एक सामान्य विस्तार है।

Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "e-" + places);
}

उपयोग:

var n = 1.7777;    
n.round(2); // 1.78

अध्याय परीक्षा:

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})

यह सवाल जटिल है।

मान लें कि हमारे पास एक फ़ंक्शन, roundTo2DP(num) , जो एक तर्क के रूप में एक फ्लोट लेता है और 2 दशमलव स्थानों पर एक मान देता है। इन अभिव्यक्तियों में से प्रत्येक का मूल्यांकन क्या होना चाहिए?

  • roundTo2DP(0.014999999999999999)
  • roundTo2DP(0.0150000000000000001)
  • roundTo2DP(0.015)

'स्पष्ट' उत्तर यह है कि पहला उदाहरण 0.01 तक होना चाहिए (क्योंकि यह 0.02 से 0.02 के करीब है) जबकि अन्य दो को 0.02 तक गोल करना चाहिए (क्योंकि 0.0150000000000000001 0.01 से 0.02 के करीब है, और क्योंकि 0.015 बिल्कुल आधे रास्ते के बीच है उन्हें और एक गणितीय सम्मेलन है कि इस तरह के नंबर गोलाकार हो जाते हैं)।

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

0,01499999999999999944488848768742172978818416595458984375

जो 0.01 से 0.02 के करीब है।

आप देख सकते हैं कि सभी तीन नंबर आपके ब्राउज़र कंसोल, नोड शैल, या अन्य जावास्क्रिप्ट दुभाषिया पर समान हैं। बस उनकी तुलना करें:

> 0.014999999999999999 === 0.0150000000000000001
true

तो जब मैं m = 0.0150000000000000001 , तो m = 0.0150000000000000001 का सटीक मान जो मैं समाप्त करता हूं वह 0.02 मुकाबले 0.01 करीब है। और फिर भी, अगर मैं m को एक स्ट्रिंग में परिवर्तित करता हूं ...

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

... मुझे 0.015 मिलते हैं, जो 0.02 तक गोल होना चाहिए, और जो कि 56-दशमलव-स्थान संख्या नहीं है, मैंने पहले कहा था कि ये सभी संख्या बिल्कुल बराबर थीं। तो यह क्या अंधेरा जादू है?

उत्तर 7.1.12.1 में ईसीएमएस्क्रिप्ट विनिर्देश में पाया जा सकता है : संख्या प्रकार पर लागू ToString । यहां कुछ संख्या मीटर को स्ट्रिंग में बदलने के नियम निर्धारित किए गए हैं। मुख्य भाग बिंदु 5 है, जिसमें एक पूर्णांक उत्पन्न होता है जिसका अंक एम के स्ट्रिंग प्रतिनिधित्व में उपयोग किया जाएगा:

एन , के , और एस पूर्णांक हो जैसे कि ≥ 1, 10 के -1एस <10 के , एस × 10 एन के लिए संख्या मान मीटर है , और के जितना संभव हो उतना छोटा है। ध्यान दें कि के एस के दशमलव प्रतिनिधित्व में अंकों की संख्या है, यह 10 तक विभाजित नहीं है, और कम से कम महत्वपूर्ण अंक इन मानदंडों द्वारा विशिष्ट रूप से निर्धारित नहीं है।

यहां महत्वपूर्ण हिस्सा यह है कि "के जितना संभव हो उतना छोटा" है। उस आवश्यकता की मात्रा क्या है, एक संख्या m देखते हुए, String(m) के मूल्य में संख्याओं की कम से कम संभव संख्या होनी चाहिए, जबकि Number(String(m)) === m की आवश्यकता को पूरा करने के दौरान अंकों की कम से कम संख्या होनी चाहिए। चूंकि हम पहले से ही जानते हैं कि 0.015 === 0.0150000000000000001 , अब यह स्पष्ट है कि क्यों String(0.0150000000000000001) === '0.015' सत्य होना चाहिए।

बेशक, इस चर्चा में से कोई भी सीधे जवाब नहीं दिया है कि किस roundTo2DP(m) वापस आना चाहिए । यदि m का सटीक मान 0.0149 99 99 99 99 99 99 9944488848768742172978818416595458984375 है, लेकिन इसका स्ट्रिंग प्रतिनिधित्व '0.015' है, तो सही जवाब क्या है - गणितीय, व्यावहारिक रूप से, दार्शनिक रूप से, या जो कुछ भी - जब हम इसे दो दशमलव स्थानों पर ले जाते हैं?

इसके लिए कोई भी सही जवाब नहीं है। यह आपके उपयोग के मामले पर निर्भर करता है। आप शायद स्ट्रिंग प्रतिनिधित्व और ऊपर की ओर सम्मान करना चाहते हैं जब:

  • प्रतिनिधित्व किया जा रहा मूल्य मूल रूप से अलग है, उदाहरण के लिए 3-दशमलव-स्थान मुद्रा में दीनार की तरह मुद्रा की मात्रा। इस मामले में, 0.015 जैसी संख्या का वास्तविक मान 0.015 है , और 0.0149 99 99 99 ... प्रतिनिधित्व यह है कि यह बाइनरी फ़्लोटिंग पॉइंट में मिलता है एक गोल त्रुटि है। (बेशक, कई तर्क देंगे, तर्कसंगत है कि आपको ऐसे मूल्यों को संभालने के लिए दशमलव पुस्तकालय का उपयोग करना चाहिए और उन्हें पहले स्थान पर बाइनरी फ़्लोटिंग पॉइंट नंबर के रूप में कभी भी प्रस्तुत नहीं करना चाहिए।)
  • मान उपयोगकर्ता द्वारा टाइप किया गया था। इस मामले में, फिर से, सही दशमलव संख्या दर्ज की गई निकटतम बाइनरी फ़्लोटिंग पॉइंट प्रस्तुति से अधिक 'सत्य' है।

दूसरी तरफ, आप संभवतः बाइनरी फ़्लोटिंग पॉइंट वैल्यू का सम्मान करना चाहते हैं और नीचे की ओर जब आपका मान एक अंतर्निहित निरंतर पैमाने से है - उदाहरण के लिए, यदि यह सेंसर से पढ़ रहा है।

इन दो दृष्टिकोणों के लिए अलग-अलग कोड की आवश्यकता होती है। संख्या के स्ट्रिंग प्रतिनिधित्व का सम्मान करने के लिए, हम अपने स्वयं के राउंडिंग को लागू कर सकते हैं जो स्ट्रिंग प्रस्तुति पर सीधे कार्य करता है, अंकों द्वारा अंक, उसी एल्गोरिदम का उपयोग करके, जब आप स्कूल में उपयोग करते थे संख्याओं को गोल करने के लिए सिखाया गया था। नीचे एक उदाहरण है जो दशमलव बिंदु के बाद पिछली ज़ीरो को अलग करके "केवल जब आवश्यक हो" की संख्या को 2 दशमलव स्थानों का प्रतिनिधित्व करने की ओपी की आवश्यकता का सम्मान करता है; आप निश्चित रूप से, इसे अपनी सटीक आवश्यकताओं के साथ बदलने की जरूरत हो सकती है।

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}

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

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

उपर्युक्त कार्य संभवत: आप जो भी उपयोग करना चाहते हैं, उपयोगकर्ताओं को उन संख्याओं को देखने से बचने के लिए उपयोग करना चाहते हैं जिन्हें उन्होंने गलत तरीके से गोल किया है।

(एक विकल्प के रूप में, आप github.com/jhohlfeld/round10 लाइब्रेरी को भी आजमा सकते हैं जो एक समान रूप से अलग कार्यान्वयन के साथ एक समान व्यवहार कार्य प्रदान करता है।)

लेकिन क्या होगा यदि आपके पास दूसरी तरह की संख्या है - एक निरंतर पैमाने से लिया गया मूल्य, जहां ऐसा सोचने का कोई कारण नहीं है कि कम दशमलव स्थानों के साथ अनुमानित दशमलव प्रतिनिधित्व अधिक से अधिक सटीक हैं? उस स्थिति में, हम स्ट्रिंग प्रतिनिधित्व का सम्मान नहीं करना चाहते हैं, क्योंकि उस प्रतिनिधित्व (जैसा कि spec में बताया गया है) पहले से ही गोलाकार है; हम "0.0149 99 999 ... 375 राउंड 0.015 तक की गलती नहीं करना चाहते हैं, जो 0.02 तक है, इसलिए 0.0149 99 999 ... 375 राउंड 0.02 तक"।

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

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}


यहां पाए गए उत्तरों में से कोई भी सही नहीं है । @stinkycheeseman ने गोल करने के लिए कहा, आप सभी ने संख्या को गोल किया।

गोल करने के लिए, इसका उपयोग करें:

Math.ceil(num * 100)/100;

A simpler ES6 way is

const round = (x, n) => 
  parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n);

This pattern also returns the precision asked for.

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

round(44.7826456, 4)  // yields 44.7826
round(78.12, 4)       // yields 78.1200

Here is a prototype method:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

I'll add one more approach to this.

number = 16.6666666;
console.log(parseFloat(number.toFixed(2)));
"16.67"

number = 16.6;
console.log(parseFloat(number.toFixed(2)));
"16.6"

number = 16;
console.log(parseFloat(number.toFixed(2)));
"16"

.toFixed(2) returns a string with exactily 2 decimal points, that may or may not be trailing zeros. Doing a parseFloat() will eliminate those trailing zeros.




One way to achieve such a rounding only if necessary is to use Number.prototype.toLocaleString() :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

This will provide exactly the output you expect, but as strings. You can still convert those back to numbers if that's not the data type you expect.


Since ES6 there is a 'proper' way (without overriding statics and creating workarounds) to do this by using toPrecision

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));


This is the simplest, more elegant solution (and I am the best of the world;):

function roundToX(num, X) {    
    return +(Math.round(num + "e+"+X)  + "e-"+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9


Use this function Number(x).toFixed(2);


+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12







decimal-point