जावास्क्रिप्ट में, जब एक फ्लोट से स्ट्रिंग में परिवर्तित होता है, तो मैं दशमलव बिंदु के बाद सिर्फ 2 अंक कैसे प्राप्त कर सकता हूं? उदाहरण के लिए, 0.34 के बजाय 0.3445434।
जवाबों:
var result = Math.round(original*100)/100;विशेष मामले में कोड स्वतः स्पष्ट नहीं है।
संपादित करें: ... या टिम ब्युटेtoFixed द्वारा प्रस्तावित के रूप में उपयोग करें । अनुस्मारक के लिए एक, धन्यवाद (और एक upvote) भूल गए :)
toFixed()printf()सी। में क्या कुछ करता है, की नकल करेंगे , toFixed()और Math.round()अलग तरीके से गोलाई संभालेंगे। इस स्थिति में, toFixed()एक ही तरह का प्रभाव Math.floor()होगा (दी गई है कि आप मूल को 10 ^ n से पहले गुणा कर रहे हैं और toFixed()n अंकों के साथ कॉल कर रहे हैं )। उत्तर की "शुद्धता" इस बात पर बहुत निर्भर करती है कि ओपी यहां क्या चाहता है, और दोनों अपने तरीके से "सही" हैं।
संख्याओं को गोल करने के लिए कार्य हैं। उदाहरण के लिए:
var x = 5.0364342423;
print(x.toFixed(2));5.04 प्रिंट करेगा।
संपादित करें: फिडल
var x = 5.036432346; var y = x.toFixed(2) + 100; yबराबर होगा"5.03100"
(0.335).toFixed(2) == 0.34 == (0.345).toFixed(2)...
उपयोग करते समय सावधान रहें toFixed():
सबसे पहले, संख्या को गोल करना, संख्या के द्विआधारी प्रतिनिधित्व का उपयोग करके किया जाता है, जिससे अप्रत्याशित व्यवहार हो सकता है। उदाहरण के लिए
(0.595).toFixed(2) === '0.59'के बजाय '0.6'।
दूसरा, एक IE बग के साथ है toFixed()। IE में (कम से कम संस्करण 7 तक, IE8 की जांच नहीं की), निम्नलिखित सच है:
(0.9).toFixed(0) === '0'यह एक अच्छा विचार हो सकता है कि काकी के सुझाव का पालन करें या एक कस्टम toFixed()फ़ंक्शन का उपयोग करें , जैसे
function toFixed(value, precision) {
var power = Math.pow(10, precision || 0);
return String(Math.round(value * power) / power);
}.toFixed()रिटर्न वैल्यू में मूल विधि जोड़ने का सुझाव दूंगा, जो आवश्यक मात्रा में सटीक जोड़ देगा, उदाहरण के लिए: return (Math.round(value * power) / power).toFixed(precision);और एक स्ट्रिंग के रूप में मान भी लौटाएं। अन्यथा, 20 की शुद्धता को छोटे दशमलव के लिए नजरअंदाज कर दिया जाता है
toFixed: ध्यान दें कि परिशुद्धता बढ़ाने से अप्रत्याशित परिणाम प्राप्त हो सकते हैं: ( (1.2).toFixed(16) === "1.2000000000000000"जबकि (1.2).toFixed(17) === "1.19999999999999996"फ़ायरफ़ॉक्स / क्रोम में; IE8 में उत्तरार्द्ध कम सटीकता के कारण धारण नहीं करता है कि IE8 आंतरिक रूप से पेश कर सकता है)।
(0.598).toFixed(2)उत्पादन भी नहीं करता है 0.6। यह 0.60:)
(0.335).toFixed(2) == 0.34 == (0.345).toFixed(2):।
एक और समस्या के बारे में पता है, यह है कि toFixed()संख्या के अंत में अनावश्यक शून्य का उत्पादन कर सकते हैं। उदाहरण के लिए:
var x=(23-7.37)
x
15.629999999999999
x.toFixed(6)
"15.630000"एक का उपयोग कर उत्पादन को साफ करने के लिए विचार है RegExp:
function humanize(x){
return x.toFixed(6).replace(/\.?0*$/,'');
}RegExpयकीन है कि यह पूर्णांकों के लिए अच्छा के रूप में अच्छी लग रहा है बनाने के लिए अनुगामी शून्य (और वैकल्पिक दशमलव बिंदु) से मेल खाता है।
humanize(23-7.37)
"15.63"
humanize(1200)
"1200"
humanize(1200.03)
"1200.03"
humanize(3/4)
"0.75"
humanize(4/3)
"1.333333"var x = 0.3445434
x = Math.round (x*100) / 100 // this will make nice roundingउन सभी समाधानों के साथ एक समस्या है जो मल्टीप्लायरों के उपयोग के आसपास तैर रहे हैं। किकी और क्रिस्टोफ दोनों के समाधान दुर्भाग्य से गलत हैं।
कृपया अपने कोड को ५५१.१ with५ के लिए २ दशमलव स्थानों के साथ परखें - यह ५५१.१ code को होगा, जबकि यह ५५१.१ number होना चाहिए ! लेकिन अगर आप पूर्व के लिए परीक्षण करते हैं। 451.175 यह ठीक होगा - 451.18। इसलिए इस त्रुटि को पहली नज़र में देखना मुश्किल है।
समस्या गुणा करने के साथ है: 551.175 * 100 = 55117.49999999999 (अप!) का प्रयास करें।
इसलिए मेरा विचार है कि Math.round () का उपयोग करने से पहले इसे toFixed () के साथ व्यवहार करें;
function roundFix(number, precision)
{
var multi = Math.pow(10, precision);
return Math.round( (number * multi).toFixed(precision + 1) ) / multi;
}toFixedसाथ ही प्रभावित होता है - (0.335).toFixed(2) == 0.34 == (0.345).toFixed(2)... जो भी विधि का उपयोग किया जाता है, राउंडिंग से पहले बेहतर एप्सिलॉन जोड़ें।
यहाँ मुझे लगता है कि कुंजी पहले सही ढंग से राउंड अप करना है, फिर आप इसे स्ट्रिंग में बदल सकते हैं।
function roundOf(n, p) {
const n1 = n * Math.pow(10, p + 1);
const n2 = Math.floor(n1 / 10);
if (n1 >= (n2 * 10 + 5)) {
return (n2 + 1) / Math.pow(10, p);
}
return n2 / Math.pow(10, p);
}
// All edge cases listed in this thread
roundOf(95.345, 2); // 95.35
roundOf(95.344, 2); // 95.34
roundOf(5.0364342423, 2); // 5.04
roundOf(0.595, 2); // 0.60
roundOf(0.335, 2); // 0.34
roundOf(0.345, 2); // 0.35
roundOf(551.175, 2); // 551.18
roundOf(0.3445434, 2); // 0.34अब आप सुरक्षित रूप से इस मान को toFixed (p) के साथ स्वरूपित कर सकते हैं। तो अपने विशिष्ट मामले के साथ:
roundOf(0.3445434, 2).toFixed(2); // 0.34यदि आप बिना राउंड के स्ट्रिंग चाहते हैं तो आप इस RegEx (शायद सबसे कुशल तरीका नहीं है ... का उपयोग कर सकते हैं ... लेकिन वास्तव में आसान है)
(2.34567778).toString().match(/\d+\.\d{2}/)[0]
// '2.34'function trimNumber(num, len) {
const modulu_one = 1;
const start_numbers_float=2;
var int_part = Math.trunc(num);
var float_part = String(num % modulu_one);
float_part = float_part.slice(start_numbers_float, start_numbers_float+len);
return int_part+'.'+float_part;
}return float_part ? int_part+'.'+float_part : int_part;अन्यथा यदि आप पूर्णांक पारित कर दिया है, यह अंत में एक बिंदु के साथ संख्या दी (उदाहरण के इनपुट: 2100:, उत्पादन 2100.)
शायद आप दशमलव विभाजक भी चाहते हैं? यहाँ एक समारोह है जिसे मैंने अभी बनाया है:
function formatFloat(num,casasDec,sepDecimal,sepMilhar) {
if (num < 0)
{
num = -num;
sinal = -1;
} else
sinal = 1;
var resposta = "";
var part = "";
if (num != Math.floor(num)) // decimal values present
{
part = Math.round((num-Math.floor(num))*Math.pow(10,casasDec)).toString(); // transforms decimal part into integer (rounded)
while (part.length < casasDec)
part = '0'+part;
if (casasDec > 0)
{
resposta = sepDecimal+part;
num = Math.floor(num);
} else
num = Math.round(num);
} // end of decimal part
while (num > 0) // integer part
{
part = (num - Math.floor(num/1000)*1000).toString(); // part = three less significant digits
num = Math.floor(num/1000);
if (num > 0)
while (part.length < 3) // 123.023.123 if sepMilhar = '.'
part = '0'+part; // 023
resposta = part+resposta;
if (num > 0)
resposta = sepMilhar+resposta;
}
if (sinal < 0)
resposta = '-'+resposta;
return resposta;
}गुणा या भाग का उपयोग करके वास्तविक मूल्य के रूप में x.xx5 के साथ कीमतों के लिए असंगत गोलाई से बचने का कोई तरीका नहीं है। यदि आपको सही मूल्य क्लाइंट-साइड की गणना करने की आवश्यकता है, तो आपको सभी मात्रा को सेंट में रखना चाहिए। यह जावास्क्रिप्ट में संख्यात्मक मूल्यों के आंतरिक प्रतिनिधित्व की प्रकृति के कारण है। ध्यान दें कि एक्सेल समान समस्याओं से ग्रस्त है, इसलिए अधिकांश लोग इस घटनाओं के कारण होने वाली छोटी त्रुटियों को नोटिस नहीं करेंगे। हालाँकि, जब भी आप बहुत सारे परिकलित मान जोड़ते हैं, तो त्रुटियां जमा हो सकती हैं, अंतिम परिणाम में त्रुटि को कम करने के लिए गणनाओं के क्रम और अन्य तरीकों को शामिल करते हुए इसके चारों ओर एक संपूर्ण सिद्धांत है। दशमलव मानों के साथ समस्याओं पर जोर देने के लिए, कृपया ध्यान दें कि 0.1 + 0.2 जावास्क्रिप्ट में 0.3 के बराबर नहीं है, जबकि 1 + 2 3 के बराबर है।
/** don't spend 5 minutes, use my code **/
function prettyFloat(x,nbDec) {
if (!nbDec) nbDec = 100;
var a = Math.abs(x);
var e = Math.floor(a);
var d = Math.round((a-e)*nbDec); if (d == nbDec) { d=0; e++; }
var signStr = (x<0) ? "-" : " ";
var decStr = d.toString(); var tmp = 10; while(tmp<nbDec && d*tmp < nbDec) {decStr = "0"+decStr; tmp*=10;}
var eStr = e.toString();
return signStr+eStr+"."+decStr;
}
prettyFloat(0); // "0.00"
prettyFloat(-1); // "-1.00"
prettyFloat(-0.999); // "-1.00"
prettyFloat(0.5); // "0.50"मैं इस कोड का उपयोग प्रारूप फ़्लोट करने के लिए करता हूं। यह पर आधारित है, toPrecision()लेकिन यह अनावश्यक शून्य को स्ट्रिप्स करता है। मैं regex को सरल बनाने के लिए सुझावों का स्वागत करूंगा।
function round(x, n) {
var exp = Math.pow(10, n);
return Math.floor(x*exp + 0.5)/exp;
}उपयोग उदाहरण:
function test(x, n, d) {
var rounded = rnd(x, d);
var result = rounded.toPrecision(n);
result = result.replace(/\.?0*$/, '');
result = result.replace(/\.?0*e/, 'e');
result = result.replace('e+', 'e');
return result;
}
document.write(test(1.2000e45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2000e+45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2340e45, 3, 2) + '=' + '1.23e45' + '<br>');
document.write(test(1.2350e45, 3, 2) + '=' + '1.24e45' + '<br>');
document.write(test(1.0000, 3, 2) + '=' + '1' + '<br>');
document.write(test(1.0100, 3, 2) + '=' + '1.01' + '<br>');
document.write(test(1.2340, 4, 2) + '=' + '1.23' + '<br>');
document.write(test(1.2350, 4, 2) + '=' + '1.24' + '<br>');