आप जावास्क्रिप्ट में 1 दशमलव स्थान पर कैसे घूमते हैं?

378

क्या आप दशमलव बिंदु (ठीक से गोल) के बाद एक संख्या को जावास्क्रिप्ट में 1 वर्ण पर गोल कर सकते हैं?

मैंने कोशिश की * 10, गोल, / 10 लेकिन यह अंत के अंत में दो दशमलव छोड़ देता है।

javascript rounding

— वॉकर
स्रोत

9

Math.round(n * 10) / 10काम करेगा। आपका कोड क्या है?

— बेन फ्लेमिंग

FYI करें डेवलपर.

— mozilla.org/en/JavaScript/Reference/Global_Objects/…

729

Math.round(num * 10) / 10 काम करता है, यहाँ एक उदाहरण है ...

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

यदि आप चाहते हैं कि यह एक दशमलव स्थान हो, तब भी जब यह 0 होगा, तो जोड़ें ...

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

संपादित करें: सटीक फ़ंक्शन के साथ राउंड जोड़ें ...

इस सिद्धांत का उपयोग करते हुए, संदर्भ के लिए, यहां एक आसान सा गोल कार्य है जो सटीक रूप से होता है ...

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

... उपयोग ...

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

... निकटतम पूर्ण संख्या (सटीक 0) के चक्कर में चूक ...

round(12345.6789) // 12346

... और इसका उपयोग निकटतम 10 या 100 आदि के लिए किया जा सकता है ...

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

... और निगेटिव नंबरों की सही हैंडलिंग ...

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

... और स्ट्रिंग के रूप में लगातार स्वरूपित toFixed के साथ जोड़ा जा सकता है ...

round(456.7, 2).toFixed(2) // "456.70"

— बिली मून
स्रोत

45

.toFixed()जब आप शायद एक नंबर चाहते हैं तो यह एक स्ट्रिंग लौटाते समय सावधानी बरतें ।

— कोबी

1

कूल, स्पष्ट रूप से उपयोग करके parseFloatदशमलव को छोड़ दिया जाएगा .toFixed()यदि यह एक संपूर्ण संख्या (शून्य) है। आम तौर पर, यदि आप गणित करना चाहते हैं तो अपने पहले उदाहरण का पालन करना सबसे अच्छा है। अगर आप अपने यूआई में नंबर दिखाना चाहते हैं तो उपयोग करें .toFixed()।

— 1:17 पर कॉब

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

— बिली मून

2

.toFixed()इसके उपयोग से सावधान रहें क्योंकि यह विभिन्न ब्राउज़रों के लिए अलग-अलग दौर परिणाम लौटा सकता है। विषय पर विवरण के लिए इस पोस्ट को पढ़ें !

— विल्ट

1

यदि कोई डीपी मौजूद नहीं है तो क्या मैं एक शून्य जोड़ सकता हूं?

— निक

101

var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5

— पाब्लो फर्नांडीज
स्रोत

4

कभी-कभी toFixed()ग्लिट्स होते हैं - मैंने इसे क्रोम ब्राउज़र में देखा है जहां मैं कॉल करता हूं toFixed(), फिर एक स्ट्रिंग में परिवर्तित होता है, और यह कुछ ऐसा दिखाता है 10.00000000068- अजीब। हालांकि इस मज़बूती से पुन: पेश नहीं किया जा सकता है।

— हमीश ग्रुबीजन

हां, मैंने केवल कुछ डेसीमल के साथ भी () के साथ ग्लिच का सामना किया। यदि मैंने सही ढंग से याद किया तो यह कम के बजाय अगले 4 की संख्या में गोल है।

— डालीबोर

1

जैसा कि ऊपर @cobby ने उल्लेख किया है: जब आप शायद चाहते हैं तो इसका उपयोग करते समय सावधान रहें.toFixed()StringNumber

— रिकार्डो

28

यदि आप उपयोग करते हैं Math.round(5.01)तो आपको 5इसके बदले मिलेगा 5.0।

यदि आप उपयोग करते हैं toFixedतो आप गोल मुद्दों में भाग लेंगे ।

यदि आप चाहते हैं कि दोनों दुनिया के सर्वश्रेष्ठ दो को मिलाएं:

(Math.round(5.01 * 10) / 10).toFixed(1)

आप इसके लिए एक फ़ंक्शन बनाना चाहते हैं:

function roundedToFixed(_float, _digits){
  var rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}

— जैस्पर डे व्रीस
स्रोत

क्यों परों के लिए अंडरस्कोर यानी (_float, _digits)? बेझिझक एक लिंक पोस्ट करें जहां मैं अपने लिए उत्तर पा सकता हूं। साभार

— शार्क लार्स

23

lodashएक roundविधि है:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

डॉक्स ।

स्रोत ।

— केविन लेरी
स्रोत

11

मैं वोट देता हूं toFixed(), लेकिन रिकॉर्ड के लिए, यहां एक और तरीका है जो नंबर को इंट में डालने के लिए बिट शिफ्टिंग का उपयोग करता है। तो, यह हमेशा शून्य (सकारात्मक संख्या के लिए, नकारात्मक के लिए नीचे) की ओर गोल होता है।

var rounded = ((num * 10) << 0) * 0.1;

लेकिन अरे, चूंकि कोई फ़ंक्शन कॉल नहीं हैं, इसलिए यह तेजी से दुष्ट है। :)

और यहाँ एक है जो स्ट्रिंग मिलान का उपयोग करता है:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

मैं स्ट्रिंग संस्करण का उपयोग करने की सलाह नहीं देता, बस कह रहा हूं।

— jimbo
स्रोत

7

इसके साथ प्रयास करें:

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

कम जटिल और लागू करने में आसान ...

इसके साथ, आप ऐसा करने के लिए एक फ़ंक्शन बना सकते हैं:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

कोड स्निपेट दिखाएं

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}
console.log (RoundAndFix(8.111111, 3));

स्निपेट का विस्तार करें

EDIT : यह देखें कि ROUND HALF UP का उपयोग कैसे करें। राउंडिंग मोड जो हम में से अधिकांश को ग्रेड स्कूल में पढ़ाया जाता था

— atiruz
स्रोत

नोप: राउंडअंडिक्स (1.005, 2)।

— 17

4

x = संख्या, n = दशमलव-स्थान:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}

— उत्तम
स्रोत

रस्सी: गोल (1.005, 2)।

— नोयो

4

सिर्फ क्यों नहीं

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3

TheFixed : फिक्स्ड-पॉइंट नोटेशन का उपयोग करके दिए गए नंबर का प्रतिनिधित्व करने वाला एक स्ट्रिंग देता है।
यूनीरी प्लस (+) : यूनीरी प्लस ऑपरेटर अपने ऑपरेंड से पहले और उसके ऑपरेंड का मूल्यांकन करता है, लेकिन अगर यह पहले से ही नहीं है, तो इसे एक नंबर में बदलने का प्रयास करता है।

— goulashsoup
स्रोत

3

var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8

— जोसेफ सिलबर
स्रोत

3

सर्वश्रेष्ठ उत्तर को पूरा करने के लिए:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

इनपुट पैरामीटर नंबर हमेशा "नंबर" हो सकता है, इस मामले में .toFixed मौजूद नहीं है।

— klodoma
स्रोत

3

ES 6 स्वीकृत उत्तर का संस्करण:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

— कोतावत रे
स्रोत

3

उपयोग करने के लिए। विधि:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

— ईज़ी
स्रोत

अब तक का सबसे अच्छा जवाब मैंने कोशिश की है। धन्यवाद।

— Ste

लेकिन आपको सावधान रहने की वजह से है 12.345.toPrecision( 2 )है "12"।

— जोशुआ पिंटर

2

यदि आपका तरीका काम नहीं करता है, तो plz अपना कोड पोस्ट करें।

हालाँकि, आप निम्न कार्य को पूरा कर सकते हैं:

var value = Math.round(234.567*100)/100

आपको 234.56 देगा

उसी प्रकार

 var value = Math.round(234.567*10)/10

234.5 देंगे

इस तरह आप स्थिरांक के स्थान पर एक चर का उपयोग कर सकते हैं जैसा कि ऊपर प्रयोग किया गया है।

— jagbandhuster
स्रोत

1

अगर कोई चाहे तो लिटिल एंगुलर फिल्टर:

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

अगर के माध्यम से उपयोग करें:

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

:)

— sidonaldson
स्रोत

1

सामान्य तौर पर, गोलाई स्केलिंग द्वारा की जाती है: round(num / p) * p

घातीय संकेतन का उपयोग करते हुए, सही ढंग से + वी संख्याओं की गोलाई संभालती है। हालाँकि, यह विधि सही-सही किनारे के मामलों में विफल रहती है।

function round(num, precision = 2) {
	var scaled = Math.round(num + "e" + precision);
	return Number(scaled + "e" + -precision);
}

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

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

स्निपेट का विस्तार करें

यहाँ, एक फ़ंक्शन है जिसे मैंने अंकगणितीय गोलाई करने के लिए लिखा है, आप इसे स्वयं परीक्षण कर सकते हैं।

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

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

स्निपेट का विस्तार करें

— अमर अली
स्रोत

0

यह मेरे द्वारा फेंकी गई किसी भी चीज़ पर मज़बूती से काम करता है:

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

यह गोल है, इसलिए आपको उपयोग के मामले के अनुसार इसे संशोधित करने की आवश्यकता हो सकती है। यह काम करना चाहिए:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1

— एग gezcan
स्रोत

0

यदि आप उचित चक्कर लगाने की परवाह करते हैं तो:

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

यदि आप नहीं तो आप पहले से ही पिछले पोस्ट से एक उत्तर है

str.slice(0, -1)

— jsNovice
स्रोत

0

Math.round( num * 10) / 10 काम नहीं करता है।

उदाहरण के लिए, 1455581777.8-145558160.4आपको देता है 1310023617.3999999।

इसलिए केवल उपयोग करें num.toFixed(1)

— पीडब्लू
स्रोत

0

मैंने एक ऐसा नंबर बनाया है, जिसमें जरूरत पड़ने पर ही डेसीमल रखा जाता है (कोई 0 पेडिंग नहीं)।

उदाहरण:

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10

roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

कोड:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}

— अल्बर्टो
स्रोत

0

मुझे सटीक समस्याओं से बचने का एक तरीका मिला:

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1

function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01

— लुकास मोंटेनेग्रो
स्रोत

0

Math.round( mul/count * 10 ) / 10

Math.round(Math.sqrt(sqD/y) * 10 ) / 10

धन्यवाद

— रॉय नव
स्रोत