गोलाई के बिना दो दशमलव स्थानों पर नंबर काटें

Question

मान लीजिए मेरे पास 15.7784514 का मूल्य है, मैं इसे 15.77 को बिना किसी राउंडिंग के प्रदर्शित करना चाहता हूं।

var num = parseFloat(15.7784514);
document.write(num.toFixed(1)+"<br />");
document.write(num.toFixed(2)+"<br />");
document.write(num.toFixed(3)+"<br />");
document.write(num.toFixed(10));

का परिणाम -

15.8
15.78
15.778
15.7784514000 

मैं 15.77 कैसे प्रदर्शित करूँ?

Comments

मुझे यह पूछने का लालच है कि आप चक्कर क्यों नहीं चाहते? यह गलत लगता है कि कोई बात नहीं है ...

— कैमिलो मार्टिन

मुद्रा प्रदर्शित करते समय यह उपयोगी है।

— रिचर्ड ये

@ mik01aj - मुद्रा प्रदर्शित करते समय, गणनाओं को गोल करने के बजाय गणना मूल्यों को कम करना अधिक आम है। उदाहरण के लिए, राउंड कैलकुलेटेड फ्रैक्शनल सेंट के बजाय यूएस ट्रंकट में अधिकांश टैक्स फॉर्म। उस स्थिति में, काट दिया गया मान सही मान है।

— स्टीवन बक्स

@CamiloMartin में 1.49 बिलियन डॉलर और 1.0 बिलियन डॉलर के ऋण के बीच बहुत बड़ा अंतर है।

— बड़ौदा नोएल

1.49 बिलियन और 1.50 बिलियन डॉलर के बीच भी बहुत बड़ा अंतर है। वह $ 100 मिलियन है।

— लीगा

Answer 1

संख्या को स्ट्रिंग में परिवर्तित करें, संख्या को दूसरे दशमलव स्थान तक मिलान करें:

function calc(theform) {
    var num = theform.original.value, rounded = theform.rounded
    var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
    rounded.value = with2Decimals
}

<form onsubmit="return calc(this)">
Original number: <input name="original" type="text" onkeyup="calc(form)" onchange="calc(form)" />
<br />"Rounded" number: <input name="rounded" type="text" placeholder="readonly" readonly>
</form>

toFixedविधि इसके विपरीत कुछ मामलों में विफल रहती है toString, इसलिए इसके साथ बहुत सावधान रहें।

Comments

+1 कि गोलाई मुद्दे को हल करना चाहिए। मैं अभी भी उपरोक्त परिणाम का उपयोग कर रहा हूँ toFixed, हालांकि, इसलिए (Math.floor(value * 100) / 100).toFixed(2):। जैसा कि आप शायद जानते हैं, अजीब सटीक चीजें फ्लोटिंग पॉइंट वैल्यू के साथ हो सकती हैं (और स्पेक्ट्रम के दूसरी तरफ, अगर संख्या होती है 15, तो ओपी की तरह लगता है 15.00)।

— टीजे क्राउडर

hehe, या यदि आप दोनों को मिलाते हैं:Number((15.7784514000*100).toString().match(/^\d+/)/100);

— skobaljic

Math.floor (मान * 100) / 100 काम नहीं करेगा यदि मान = 4.27 गंभीरता से, कोशिश करें।

— डार्क हिप्पो

@DarkHippo थॉट्स क्योंकि 4.27 वास्तव में 4.26999999999 है, इसलिए मूल प्रश्न के उत्तर के अनुसार, Math.round आम तौर पर एक बेहतर समाधान है। वास्तविक रूप से दिया गया आउटपुट एक स्ट्रिंग है, जिसे सभी फ्लोटिंग पॉइंट फ़ॉइबल्स के साथ संख्यात्मक समाधान के बजाय स्ट्रिंग हेरफेर का उपयोग करना चाहिए।

— बीजोरी

... यह सही नहीं लगता। किसी भी परिस्थिति में प्रकारों के बीच परिवर्तित करना गोल चक्कर और असुरक्षित लगता है। जब तक कि वास्तव में उन्नत प्रोग्रामर यह तर्क नहीं देगा कि "सभी प्रकार सिर्फ धाराएँ हैं" या कुछ और।

— जैकहैस्केबोर्ड

Answer 2

अपडेट 5 नवंबर 2016

नया उत्तर, हमेशा सटीक

function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

जैसा कि जावास्क्रिप्ट में फ्लोटिंग पॉइंट मैथ में हमेशा किनारे के मामले होंगे, पिछला समाधान ज्यादातर समय सटीक होगा जो पर्याप्त नहीं है। वहाँ करने के लिए इस तरह की कुछ समाधान कर रहे हैं num.toPrecision, BigDecimal.js , और accounting.js । फिर भी, मेरा मानना ​​है कि स्ट्रिंग को केवल पार्स करना सबसे सरल और हमेशा सटीक होगा।

@Gumbo द्वारा स्वीकार किए गए उत्तर से अच्छी तरह से लिखित regex पर अपडेट आधारित, यह नया toFixed फ़ंक्शन हमेशा अपेक्षा के साथ काम करेगा।

---

पुराना उत्तर, हमेशा सटीक नहीं।

अपना स्वयं का बनाया हुआ फ़ंक्शन रोल करें:

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

Comments

toFixed (4.56, 2) = 4.55

— cryss

तो इनमें से कई उत्तरों में एक Math.floor () फ़ंक्शन के अंदर गुणा है। यह कुछ नंबरों के लिए विफल हो जाएगा! फ्लोटिंग पॉइंट अंकगणित सटीक नहीं है और आपको विभिन्न तरीकों का उपयोग करने की आवश्यकता है।

— निको वेस्टरडेल

function toFixedCustom (संख्या, निश्चित) {var re = new RegExp ('^ -? \\ d + (??: \ _ \\ d {0,' + (तय) -1) + '}?'))? if (num.toString ()। match (re)) {return num.toString ()। match (re) [0]; }}

— रयान ऑगस्टीन

अपडेट किया गया उत्तर एक बड़ी या छोटी संख्या के लिए विफल होगा जो जावास्क्रिप्ट वैज्ञानिक नोटेशन में प्रतिनिधित्व करेगा। toFixed(0.0000000052, 2)पैदावार '5.2'। यह return num.toFixed(fixed+1).match(re)[0];सूचना का उपयोग करके तय किया जा सकता है कि मैं गोल से बचने के लिए लक्ष्य के ऊपर एक दशमलव स्थान के साथ फ़िक्स का उपयोग कर रहा हूं, फिर अपना रेगेक्स मैच चला रहा है

— नीदरलैंड्स

Answer 3

मैंने इसे लिखने के बजाय मैन्युअल रूप से शेष को स्ट्रिंग्स के साथ हटाने का विकल्प चुना ताकि मुझे उन गणित के मुद्दों से निपटना न पड़े जो संख्याओं के साथ आते हैं:

num = num.toString(); //If it's not already a String
num = num.slice(0, (num.indexOf("."))+3); //With 3 exposing the hundredths place
Number(num); //If you need it back as a Number

यह आपको "15.77" अंक = 15.7784514 के साथ देगा;

Comments

यदि आप एक दशमलव के लिए मजबूर नहीं कर रहे हैं, तो आप एक सशर्त जोड़ना चाहते हैं यदि आप पूरे नंबर का सामना कर सकते हैं। इस तरह: num = num.toString (); if (num.indexOf ("।")> 0) {num = num.slice (0, (num.indexOf ("।")) + 3)}; संख्या (संख्या);

— ベ ノ ス ベ

अच्छा है अगर यह दशमलव है, लेकिन अगर यह एक पूर्णांक है तो यह विफल हो जाएगा

— रुस्लान लोपेज

यदि अंक 0.00000052 है, तो यह गलत हो जाएगा 5.2e

— वसंत

@ वासंथ यदि संख्या 0.00000052 है तो यह "0.00" देता है। हो सकता है कि इसका उत्तर तब से संपादित किया गया हो

— Drenai

हाँ, यह किनारे के मामलों में विफल रहता है

— वीपॉल

Answer 4

अक्टूबर 2017

एन-वें दशमलव अंक के लिए एक नंबर को छोटा करने (कोई राउंडिंग) करने के लिए सामान्य समाधान और किसी भी n≥0 के लिए इसे बिल्कुल n दशमलव अंकों के साथ एक स्ट्रिंग में परिवर्तित करें।

function toFixedTrunc(x, n) {
  const v = (typeof x === 'string' ? x : x.toString()).split('.');
  if (n <= 0) return v[0];
  let f = v[1] || '';
  if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
  while (f.length < n) f += '0';
  return `${v[0]}.${f}`
}

जहाँ x या तो एक संख्या हो सकती है (जो एक स्ट्रिंग में परिवर्तित हो जाती है) या एक स्ट्रिंग।

यहाँ n = 2 के लिए कुछ परीक्षण हैं (ओपी द्वारा अनुरोधित एक सहित):

0           => 0.00
0.01        => 0.01
0.5839      => 0.58
0.999       => 0.99
1.01        => 1.01
2           => 2.00
2.551       => 2.55
2.99999     => 2.99
4.27        => 4.27
15.7784514  => 15.77
123.5999    => 123.59
0.000000199 => 1.99 *

* जैसा कि नोट में बताया गया है, कि जावास्क्रिप्ट के कारण "1.99e-7" और n के कुछ अन्य मूल्यों के लिए घातीय में रूपांतरण निहित है:

15.001097   => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)

Comments

toFixedTrunc(0.000000199, 2) // 1.99

— महारामॉफ

@ShamkhalMaharramov: यदि आप विकास कंसोल खोलते हैं और 0.000000199 दर्ज करते हैं तो आपको क्या मिलता है? आपको 1.99e-7 मिलता है। इसके अलावा, यदि आप 0.000000199.toString () दर्ज करते हैं तो आपको क्या मिलता है? आपको "1.99e-7" मिलता है, इसलिए, जब आप फ़ंक्शन में 0.000000199 पास करते हैं, तो यह "1.99e-7" पर "0.000000199" नहीं और "सही ढंग से" 1.99 "" काम करता है। देखें ecma-international.org/ecma-262/6.0/…

— SC1000

Answer 5

parseInt तेज है तो Math.floor

function floorFigure(figure, decimals){
    if (!decimals) decimals = 2;
    var d = Math.pow(10,decimals);
    return (parseInt(figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

Comments

यह 1234567.89 के साथ विफल रहता है

— रुस्लान लोपेज़

क्या आप लोपेज का विस्तार कर सकते हैं?

— जरदिल

floorFigure (4.56, 2) = 4.55

— cryss

Answer 6

num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)

यह 19.66 लौटेगा

Comments

(4.9999) .toFixed (3) .slice (0, -1) रिटर्न 5.00, अपेक्षित परिणाम 4.99 है।

— ब्रूनो लेमोस

मैं इसके बजाय .toFixed (6) .slice (0, -4) जैसे कुछ का उपयोग करने की सलाह देता हूं।

— ब्रूनो लेमोस

यह एकदम सही है, मेरे मामले में यह ठीक है। उदाहरण के लिए अगर मैं सिर्फ एक दशमलव संख्या का उपयोग करना चाहता हूँ num.toFixed (2) .slice (0, -1) (यदि संख्या 1.2356 है, तो यह 1.2 वापस आ जाएगी)

— एस्टेबन पेरेज़

Answer 7

सरल यह करो

number = parseInt(number * 100)/100;

Comments

parseInt (8.2 * 100) = 819

— वीपॉल

Answer 8

ये समाधान काम करते हैं, लेकिन मुझे अनावश्यक रूप से जटिल लगते हैं। मैं व्यक्तिगत रूप से एक बंटवारे के संचालन को प्राप्त करने के लिए मापांक ऑपरेटर का उपयोग करना पसंद करता हूं, और इसे हटा देता हूं। उस संख्या को मानकर = 15.7784514:

num-=num%.01;

यह संख्या = संख्या - (संख्या% .01) कहने के बराबर है।

Comments

यह दिलचस्प Nijkokun है, इसे इंगित करने के लिए धन्यवाद। मैंने इस तकनीक का उपयोग करके कभी भी समस्याओं में भाग नहीं लिया है, लेकिन स्पष्ट रूप से मुझे इस तरह के उदाहरणों के लिए करीब से देखना चाहिए। एक विकल्प के रूप में आप उपयोग कर सकते हैं ((संख्या * = 100) - (संख्या 1%)) / 100 जो इस मुद्दे को हल करता है। मेरे मामले में प्राथमिकता निष्पादन की गति है क्योंकि गणना की मात्रा मैं इसे लागू कर रहा हूं, और यह इसे प्राप्त करने का सबसे तेज़ तरीका है जो मैंने पाया है।

— jtrick

बिंदु वस्तु और फ़ंक्शन के लुक्स और रूपांतरणों की पेशकश से बचने के लिए था जो अन्य समाधानों में आवश्यक थे। प्रतिक्रिया के लिए धन्यवाद!

— जेट्रिक

-5 के रूप में नकारात्मक के साथ भी विफल रहता है

— रुस्लान लोपेज़

मुझे भी एक तेज़ राउंडिंग में दिलचस्पी है, आप इस कोड को 1 दशमलव कैसे बनाएंगे?

— thnnp

Answer 9

यहाँ जवाबों ने मेरी मदद नहीं की, यह मुझे गलत दशमलव देता रहा।

मेरा समाधान आपके दशमलव को एक स्ट्रिंग में परिवर्तित करता है, वर्णों को निकालता है और फिर पूरी चीज़ को एक संख्या के रूप में लौटाता है।

function Dec2(num) {
  num = String(num);
  if(num.indexOf('.') !== -1) {
    var numarr = num.split(".");
    if (numarr.length == 1) {
      return Number(num);
    }
    else {
      return Number(numarr[0]+"."+numarr[1].charAt(0)+numarr[1].charAt(1));
    }
  }
  else {
    return Number(num);
  }  
}

Dec2(99); // 99
Dec2(99.9999999); // 99.99
Dec2(99.35154); // 99.35
Dec2(99.8); // 99.8
Dec2(10265.985475); // 10265.98

Comments

Dec2 (99) 99.00

— VPaul

Answer 10

सकारात्मक संख्याओं के लिए मेरा संस्करण:

function toFixed_norounding(n,p)
{
    var result = n.toFixed(p);
    return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}

तेज, सुंदर, स्पष्ट। (सकारात्मक संख्या के लिए संस्करण)

Comments

केवल 1 दशमलव के साथ फ्लोट मान (जैसे धन) के लिए एक गैर-गोलाई की आवश्यकता है। उपरोक्त फ़ंक्शन इस विषय का "उत्तर" होना चाहिए, यह उत्कृष्ट है, एक आकर्षण की तरह काम करता है। लेखक को धन्यवाद और धन्यवाद। :)))

— एड्रियन तनासे

नकारात्मक मान के लिए विफल। -0.7752। टेस्ट में यह toFixed_norounding(-0.7752,2)रिटर्न -0.78के बजाय-0.77

— लिंग Loeng

Answer 11

निम्नलिखित कोड मेरे लिए बहुत अच्छा काम करता है:

num.toString().match(/.\*\\..{0,2}|.\*/)[0];

Comments

मैं इसे सही बनाने के लिए वैकल्पिक माइनस साइन -?

— रुस्लान लोपेज़

Answer 12

मैंने निम्नलिखित सरल तरीके का उपयोग करके तय किया-

var num = 15.7784514;
Math.floor(num*100)/100;

परिणाम 15.77 होंगे

Comments

यह नकारात्मक मूल्यों के साथ काम नहीं करता है: -15.7784514रिटर्न-15.78

— क्लेमेंट बेकोनियर

Answer 13

बस अंकों को काटें:

function truncDigits(inputNumber, digits) {
  const fact = 10 ** digits;
  return Math.floor(inputNumber * fact) / fact;
}

Answer 14

एक और एकल-पंक्ति समाधान:

number = Math.trunc(number*100)/100

मैंने 100 का उपयोग किया है क्योंकि आप दूसरे अंक को कम करना चाहते हैं, लेकिन एक अधिक लचीला समाधान होगा:

number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)

जहां अंकों को रखने के लिए दशमलव अंकों की राशि है।

विवरण और ब्राउज़र संगतता के लिए Math.trunc चश्मा देखें ।

Comments

यह सबसे अच्छा जवाब है अगर आपको IE11 का समर्थन नहीं करना है।

— टीजे

Answer 15

आप यहाँ हैं। एक जवाब जो समस्या को हल करने का एक और तरीका दिखाता है:

// For the sake of simplicity, here is a complete function:
function truncate(numToBeTruncated, numOfDecimals) {
    var theNumber = numToBeTruncated.toString();
    var pointIndex = theNumber.indexOf('.');
    return +(theNumber.slice(0, pointIndex > -1 ? ++numOfDecimals + pointIndex : undefined));
}

अंतिम अभिव्यक्ति से पहले + के उपयोग पर ध्यान दें। यही कारण है कि हमारे छंटनी, कटा हुआ स्ट्रिंग को संख्या प्रकार में बदलना है।

आशा करता हूँ की ये काम करेगा!

Comments

मुझे इस दृष्टिकोण की सादगी पसंद है, और मुझे लगता है कि मैथ्स का उपयोग करने से बचने वाले सभी समाधान इस समस्या को हल करने के लिए अधिक उपयुक्त हैं। तो, स्लाइस () आदि का उपयोग, आगे बढ़ने का सही तरीका है। मेरी पद्धति का एकमात्र लाभ यह है कि इसमें उत्तीर्ण होने वाली संख्याओं को संसाधित किया जाएगा जो कि तार हैं [उद्धरण चिह्नों से घिरे [एकल / दोहरे]]। किसी कारण से, ऊपर के कार्य ने FF में एक त्रुटि डाली, जब मैंने किया: कंसोल.लॉग ('ट्रंकट ("0.85156", 2)', ट्रंकट ("0.85156", 2));

— चार्ल्स रॉबर्टसन

Answer 16

शून्य के बिना छोटा

function toTrunc(value,n){  
    return Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}

या

function toTrunc(value,n){
    x=(value.toString()+".0").split(".");
    return parseFloat(x[0]+"."+x[1].substr(0,n));
}

परीक्षा:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.4

शून्य के साथ काटें

function toTruncFixed(value,n){
    return toTrunc(value,n).toFixed(n);
}

परीक्षा:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.40

Answer 17

इसने मेरे लिए अच्छा काम किया। मुझे उम्मीद है कि यह आपके मुद्दों को भी ठीक कर देगा।

function toFixedNumber(number) {
    const spitedValues = String(number.toLocaleString()).split('.');
    let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
    decimalValue = decimalValue.concat('00').substr(0,2);

    return '$'+spitedValues[0] + '.' + decimalValue;
}

// 5.56789      ---->  $5.56
// 0.342        ---->  $0.34
// -10.3484534  ---->  $-10.34 
// 600          ---->  $600.00

function convertNumber(){
  var result = toFixedNumber(document.getElementById("valueText").value);
  document.getElementById("resultText").value = result;
}


function toFixedNumber(number) {
        const spitedValues = String(number.toLocaleString()).split('.');
        let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
        decimalValue = decimalValue.concat('00').substr(0,2);

        return '$'+spitedValues[0] + '.' + decimalValue;
}

<div>
  <input type="text" id="valueText" placeholder="Input value here..">
  <br>
  <button onclick="convertNumber()" >Convert</button>
  <br><hr>
  <input type="text" id="resultText" placeholder="result" readonly="true">
</div>

Answer 18

ऐसा करने का एक आसान तरीका अगला है लेकिन यह सुनिश्चित करना आवश्यक है कि राशि पैरामीटर को एक स्ट्रिंग के रूप में दिया गया है।

function truncate(amountAsString, decimals = 2){
  var dotIndex = amountAsString.indexOf('.');
  var toTruncate = dotIndex !== -1  && ( amountAsString.length > dotIndex + decimals + 1);
  var approach = Math.pow(10, decimals);
  var amountToTruncate = toTruncate ? amountAsString.slice(0, dotIndex + decimals +1) : amountAsString;  
  return toTruncate
    ?  Math.floor(parseFloat(amountToTruncate) * approach ) / approach
    :  parseFloat(amountAsString);

}

console.log(truncate("7.99999")); //OUTPUT ==> 7.99
console.log(truncate("7.99999", 3)); //OUTPUT ==> 7.999
console.log(truncate("12.799999999999999")); //OUTPUT ==> 7.99

Answer 19

function formatLimitDecimals(value, decimals) {
  value = value.toString().split('.')

  if (value.length === 2) {
    return Number([value[0], value[1].slice(0, decimals)].join('.'))
  } else {
    return Number(value[0]);
  }
}

console.log(formatLimitDecimals(4.156, 2)); // 4.15
console.log(formatLimitDecimals(4.156, 8)); // 4.156
console.log(formatLimitDecimals(4.156, 0)); // 4

Answer 20

मैं (num-0.05).toFixed(1)दूसरे दशमलव को प्राप्त करता था।

Answer 21

टाइपस्क्रिप्ट में मेरा समाधान (जेएस में आसानी से पोर्ट किया जा सकता है):

/**
 * Returns the price with correct precision as a string
 *
 * @param   price The price in decimal to be formatted.
 * @param   decimalPlaces The number of decimal places to use
 * @return  string The price in Decimal formatting.
 */
type toDecimal = (price: number, decimalPlaces?: number) => string;
const toDecimalOdds: toDecimal = (
  price: number,
  decimalPlaces: number = 2,
): string => {
  const priceString: string = price.toString();
  const pointIndex: number = priceString.indexOf('.');

  // Return the integer part if decimalPlaces is 0
  if (decimalPlaces === 0) {
    return priceString.substr(0, pointIndex);
  }

  // Return value with 0s appended after decimal if the price is an integer
  if (pointIndex === -1) {
    const padZeroString: string = '0'.repeat(decimalPlaces);

    return `${priceString}.${padZeroString}`;
  }

  // If numbers after decimal are less than decimalPlaces, append with 0s
  const padZeroLen: number = priceString.length - pointIndex - 1;
  if (padZeroLen > 0 && padZeroLen < decimalPlaces) {
    const padZeroString: string = '0'.repeat(padZeroLen);

    return `${priceString}${padZeroString}`;
  }

  return priceString.substr(0, pointIndex + decimalPlaces + 1);
};

परीक्षण के मामलों:

  expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 2)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 0)).toBe('3');
  expect(filters.toDecimalOdds(3.14159, 10)).toBe('3.1415900000');
  expect(filters.toDecimalOdds(8.2)).toBe('8.20');

कोई सुधार?

Answer 22

अपने स्वयं के toFixedफ़ंक्शन को रोल करें : सकारात्मक मूल्यों के लिए Math.floorठीक काम करता है।

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

नकारात्मक मूल्यों के लिए मूल्यों Math.floorका दौर है। तो आप Math.ceilइसके बजाय उपयोग कर सकते हैं ।

उदाहरण,

Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.

Comments

तो इनमें से कई उत्तरों में एक Math.floor () फ़ंक्शन के अंदर गुणा है। यह कुछ नंबरों के लिए विफल हो जाएगा! फ्लोटिंग पॉइंट अंकगणित सटीक नहीं है और आपको विभिन्न तरीकों का उपयोग करने की आवश्यकता है।

— निको वेस्टरडेल

Answer 23

नियमित अभिव्यक्ति के साथ गुम्बो का दूसरा समाधान, काम करता है लेकिन नियमित अभिव्यक्ति के कारण धीमा है। फ्लोटिंग पॉइंट नंबरों में गड़बड़ी के कारण कुछ स्थितियों में गंबू का पहला समाधान विफल हो जाता है। एक प्रदर्शन और एक बेंचमार्क के लिए JSFiddle देखें । दूसरा समाधान मेरी वर्तमान प्रणाली पर प्रति कॉल लगभग 1636 नैनोसेकंड लेता है, 3.30 गीगाहर्ट्ज़ पर इंटेल कोर i5-2500 सीपीयू।

मैंने जो समाधान लिखा है, उसमें फ्लोटिंग पॉइंट इंप्रेशन की देखभाल के लिए एक छोटा सा मुआवजा शामिल है। यह मूल रूप से तात्कालिक है, अर्थात नैनोसेकंड के क्रम पर। मैंने प्रति कॉल पर 2 नैनोसेकेंड देखे, लेकिन जावास्क्रिप्ट टाइमर बहुत सटीक या दानेदार नहीं हैं। यहाँ JS Fiddle और कोड है।

function toFixedWithoutRounding (value, precision)
{
    var factorError = Math.pow(10, 14);
    var factorTruncate = Math.pow(10, 14 - precision);
    var factorDecimal = Math.pow(10, precision);
    return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}

var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 4));
}

console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));

// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;

for (var run = 0; run < numRun; run++)
    toFixedWithoutRounding(value, 2);

var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);

Answer 24

डेविड डी के जवाब पर बिल्डिंग :

function NumberFormat(num,n) {
  var num = (arguments[0] != null) ? arguments[0] : 0;
  var n = (arguments[1] != null) ? arguments[1] : 2;
  if(num > 0){
    num = String(num);
    if(num.indexOf('.') !== -1) {
      var numarr = num.split(".");
      if (numarr.length > 1) {
        if(n > 0){
          var temp = numarr[0] + ".";
          for(var i = 0; i < n; i++){
            if(i < numarr[1].length){
              temp += numarr[1].charAt(i);
            }
          }
          num = Number(temp);
        }
      }
    }
  }
  return Number(num);
}

console.log('NumberFormat(123.85,2)',NumberFormat(123.85,2));
console.log('NumberFormat(123.851,2)',NumberFormat(123.851,2));
console.log('NumberFormat(0.85,2)',NumberFormat(0.85,2));
console.log('NumberFormat(0.851,2)',NumberFormat(0.851,2));
console.log('NumberFormat(0.85156,2)',NumberFormat(0.85156,2));
console.log('NumberFormat(0.85156,4)',NumberFormat(0.85156,4));
console.log('NumberFormat(0.85156,8)',NumberFormat(0.85156,8));
console.log('NumberFormat(".85156",2)',NumberFormat(".85156",2));
console.log('NumberFormat("0.85156",2)',NumberFormat("0.85156",2));
console.log('NumberFormat("1005.85156",2)',NumberFormat("1005.85156",2));
console.log('NumberFormat("0",2)',NumberFormat("0",2));
console.log('NumberFormat("",2)',NumberFormat("",2));
console.log('NumberFormat(85156,8)',NumberFormat(85156,8));
console.log('NumberFormat("85156",2)',NumberFormat("85156",2));
console.log('NumberFormat("85156.",2)',NumberFormat("85156.",2));

// NumberFormat(123.85,2) 123.85
// NumberFormat(123.851,2) 123.85
// NumberFormat(0.85,2) 0.85
// NumberFormat(0.851,2) 0.85
// NumberFormat(0.85156,2) 0.85
// NumberFormat(0.85156,4) 0.8515
// NumberFormat(0.85156,8) 0.85156
// NumberFormat(".85156",2) 0.85
// NumberFormat("0.85156",2) 0.85
// NumberFormat("1005.85156",2) 1005.85
// NumberFormat("0",2) 0
// NumberFormat("",2) 0
// NumberFormat(85156,8) 85156
// NumberFormat("85156",2) 85156
// NumberFormat("85156.",2) 85156

Answer 25

बिना गोल के दो फ्लोटिंग पॉइंट प्राप्त करना अधिक विश्वसनीय है।

संदर्भ उत्तर

var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);

धन्यवाद !

Answer 26

पहले से ही नियमित अभिव्यक्ति और अंकगणितीय गणना के साथ कुछ उपयुक्त उत्तर हैं, आप यह भी आज़मा सकते हैं

function myFunction() {
    var str = 12.234556; 
    str = str.toString().split('.');
    var res = str[1].slice(0, 2);
    document.getElementById("demo").innerHTML = str[0]+'.'+res;
}

// output: 12.23

Answer 27

यहाँ यह स्ट्रिंग के साथ क्या किया गया है

export function withoutRange(number) {
  const str = String(number);
  const dotPosition = str.indexOf('.');
  if (dotPosition > 0) {
    const length = str.substring().length;
    const end = length > 3 ? 3 : length;
    return str.substring(0, dotPosition + end);
  }
  return str;
}

Answer 28

ये सभी उत्तर थोड़े जटिल लगते हैं। मैं सिर्फ आपके नंबर से 0.5 घटाऊंगा और toFixed () का उपयोग करूंगा।

Comments

आपका मतलब 0.005 है?

— लुआन गुयेन

Answer 29

सबसे कुशल समाधान (2 अंश अंकों के लिए) कॉल करने से पहले 0.005 घटाना है toFixed()

function toFixed2( num ) { return (num-0.005).toFixed(2) }

नकारात्मक संख्याओं को भी नीचे (शून्य से दूर) राउंड किया जाएगा। ओपी ने नकारात्मक संख्याओं के बारे में कुछ नहीं बताया।

Answer 30

मुझे पता है कि पहले से ही काम करने के कुछ उदाहरण हैं, लेकिन मुझे लगता है कि यह मेरे String.toFixed समकक्ष का प्रस्ताव करने के लायक है, कुछ इसे उपयोगी हो सकते हैं।

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

function toFixedFixed(value, precision = 0) {
    let stringValue = isNaN(+value) ? '0' : String(+value);

    if (stringValue.indexOf('e') > -1 || stringValue === 'Infinity' || stringValue === '-Infinity') {
        throw new Error('To large number to be processed');
    }

    let [ beforePoint, afterPoint ] = stringValue.indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];

    // Force automatic rounding for some long real numbers that ends with 99X, by converting it to string, cutting off last digit, then adding extra nines and casting it on number again
    // e.g. 2.0199999999999996: +('2.019999999999999' + '9999') will give 2.02
    if (stringValue.length >= 17 && afterPoint.length > 2 && +afterPoint.substr(afterPoint.length - 3) > 995) {
        stringValue = String(+(stringValue.substr(0, afterPoint.length - 1) + '9'.repeat(stringValue.split('.').shift().length + 4)));
        [ beforePoint, afterPoint ] = String(stringValue).indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];
    }

    if (precision === 0) {
        return beforePoint;
    } else if (afterPoint.length > precision) {
        return `${beforePoint}.${afterPoint.substr(0, precision)}`;
    } else {
        return `${beforePoint}.${afterPoint}${'0'.repeat(precision - afterPoint.length)}`;
    }
}

ध्यान रखें कि सटीक को 18 की संख्या और अधिक से अधिक के लिए ठीक से संभाला नहीं जा सकता है, उदाहरण के लिए 64-बिट क्रोम इसे गोल करेगा या 18 की संख्या रखने के लिए "e +" / "e-" जोड़ देगा।

यदि आप वास्तविक संख्याओं पर संचालन करना चाहते हैं Math.sqrt(10, precision), तो इसे पहले से गुणा करना, गणना करना सुरक्षित है , फिर गुणक के मूल्य से परिणाम प्राप्त करें।

उदाहरण:

0.06 + 0.01है 0.06999999999999999, और गोलाई नहीं है कि हर स्वरूपण समारोह 0.06परिशुद्धता के लिए यह छोटा हो जाएगा 2।

लेकिन अगर आप मल्टीप्लायर और विभक्त के साथ एक ही ऑपरेशन (0.06 * 100 + 0.01 * 100) / 100करेंगे : आपको मिलेगा 0.07।

इसलिए जावास्क्रिप्ट में वास्तविक संख्याओं के साथ काम करते समय ऐसे गुणक / विभक्त का उपयोग करना बहुत महत्वपूर्ण है, खासकर जब आप अपनी गणना कर रहे हैं ...