मैं एक संख्या को राउंड करने के लिए जावास्क्रिप्ट का उपयोग करना चाहता हूं। चूंकि संख्या मुद्रा है, मैं चाहता हूं कि यह इन उदाहरणों (2 दशमलव अंक) की तरह गोल हो जाए:
जावास्क्रिप्ट का उपयोग करके इसे कैसे प्राप्त करें? अंतर्निहित जावास्क्रिप्ट फ़ंक्शन मानक तर्क के आधार पर संख्या को कम करेगा (कम से कम 5 से अधिक गोल करने के लिए)।
जवाबों:
/**
* @param num The number to round
* @param precision The number of decimal places to preserve
*/
function roundUp(num, precision) {
precision = Math.pow(10, precision)
return Math.ceil(num * precision) / precision
}
roundUp(192.168, 1) //=> 192.2ceil()आप दे देंगे 193, तो हम यह सुनिश्चित करना चाहिए कि सभी परिशुद्धता हम रखना चाहते दशमलव बिंदु से पहले है। फिर हम "मूल" मान को पुनर्स्थापित करने के लिए उलटा ऑपरेशन करते हैं।
192.19999999999997, तो आप आवेदन कर सकते हैं .toFixed(1)करने के लिएnum
थोड़ी देर लेकिन, इस उद्देश्य के लिए एक पुन: प्रयोज्य जावास्क्रिप्ट समारोह बना सकते हैं:
// Arguments: number to round, number of decimal places
function roundNumber(rnum, rlength) {
var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
return newnumber;
}फ़ंक्शन को कॉल करें
alert(roundNumber(192.168,2));छोटे गोलाई के साथ सामान्य गोलाई काम करेगी:
Math.round(price * 10)/10और यदि आप एक मुद्रा प्रारूप रखना चाहते हैं, तो आप संख्या पद्धति का उपयोग कर सकते हैं .toFixed()
(Math.round(price * 10)/10).toFixed(2)हालांकि यह इसे एक स्ट्रिंग बना देगा =)
price.toFixed(2)
TheEye जवाब के बहुत करीब है , लेकिन मैं इसे काम करने के लिए एक छोटी सी चीज को बदल देता हूं:
var num = 192.16;
console.log( Math.ceil(num * 10) / 10 );ओपी को दो चीजों की उम्मीद है:
ए दसवें स्थान पर चक्कर लगाने के लिए, और
बी को सौवें स्थान पर एक शून्य दिखाने के लिए (मुद्रा के साथ एक विशिष्ट आवश्यकता)।
उपरोक्त दोनों में से प्रत्येक के लिए एक अलग विधि की आवश्यकता प्रतीत होती है। यहाँ एक दृष्टिकोण है जो सुर्यकिरण के सुझाए गए उत्तर पर बनाता है:
//Arguments: number to round, number of decimal places.
function roundPrice(rnum, rlength) {
var newnumber = Math.ceil(rnum * Math.pow(10, rlength-1)) / Math.pow(10, rlength-1);
var toTenths = newnumber.toFixed(rlength);
return toTenths;
}
alert(roundPrice(678.91011,2)); // returns 679.00
alert(roundPrice(876.54321,2)); // returns 876.60महत्वपूर्ण नोट: यह समाधान नकारात्मक और घातीय संख्याओं के साथ एक बहुत अलग परिणाम पैदा करता है।
इस उत्तर और दो के बीच तुलना के लिए जो बहुत समान हैं, निम्नलिखित 2 दृष्टिकोण देखें। पहला बस सामान्य रूप से निकटतम सौवें के लिए गोल होता है, और दूसरा बस निकटतम सौवें (बड़े) तक गोल होता है।
function roundNumber(rnum, rlength) {
var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
return newnumber;
}
alert(roundNumber(678.91011,2)); // returns 678.91
function ceilNumber(rnum, rlength) {
var newnumber = Math.ceil(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
return newnumber;
}
alert(ceilNumber(678.91011,2)); // returns 678.92ठीक है, यह उत्तर दिया गया है, लेकिन मैंने सोचा कि आप मेरे उत्तर को देखना पसंद कर सकते हैं जो एक बार math.pow () फ़ंक्शन को कॉल करता है। मुझे लगता है कि मैं चीजों को रखना पसंद करता हूं DRY।
function roundIt(num, precision) {
var rounder = Math.pow(10, precision);
return (Math.round(num * rounder) / rounder).toFixed(precision)
};यह सभी को एक साथ रखता है। Math.ceil () को Math.ceil () के साथ राउंड-अप के बजाय राउंड-अप में बदलें, जो कि ओपी चाहता था।
यह फ़ंक्शन गोल संख्या के बिना दशमलव को सीमित करता है
function limitDecimal(num,decimal){
return num.toString().substring(0, num.toString().indexOf('.')) + (num.toString().substr(num.toString().indexOf('.'), decimal+1));
}मैं लंबे समय से @AndrewMarshall उत्तर का उपयोग कर रहा हूं, लेकिन कुछ किनारे मामले पाए गए। निम्नलिखित परीक्षण पास नहीं हैं:
equals(roundUp(9.69545, 4), 9.6955);
equals(roundUp(37.760000000000005, 4), 37.76);
equals(roundUp(5.83333333, 4), 5.8333);यहाँ है कि मैं अब सही ढंग से व्यवहार करने के लिए क्या उपयोग करता हूं:
// 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स्रोत: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
roundUp(37.760000000000005, 4)होना चाहिए 37.7601, और roundUp(5.83333333, 4)होना चाहिए 5.8334। ये दोनों (और आपका पहला) सभी मेरे द्वारा दिए गए fn के लिए सही हैं।