जावास्क्रिप्ट में दशमलव संख्याओं को काटें (गोल न करें)

Question 1

मैं दशमलव संख्याओं को दशमलव स्थानों पर कम करने का प्रयास कर रहा हूँ। कुछ इस तरह:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)सिर्फ सही काम के बारे में करता है, लेकिन यह मूल्य से दूर है। मुझे राउंड ऑफ वैल्यू की जरूरत नहीं है। आशा है कि जावास्क्रिप्ट में यह संभव है।

Question 2

अद्यतन :

तो, यह सब हो जाने के बाद, गोल कीड़े हमेशा आपको परेशान करेंगे, फिर चाहे आप उन्हें कितना भी मुआवजा दें। इसलिए समस्या को दशमलव संकेतन में बिल्कुल संख्याओं का प्रतिनिधित्व करते हुए हमला किया जाना चाहिए।

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

[   5.467.toFixedDown(2),
    985.943.toFixedDown(2),
    17.56.toFixedDown(2),
    (0).toFixedDown(1),
    1.11.toFixedDown(1) + 22];

// [5.46, 985.94, 17.56, 0, 23.1]

दूसरों के संकलन के आधार पर पुरानी त्रुटि-प्रवण समाधान: '

Number.prototype.toFixedDown = function(digits) {
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Question 3

डॉगबर्ट का जवाब अच्छा है, लेकिन अगर आपके कोड को नकारात्मक संख्या से निपटना पड़ सकता है, तो Math.floorस्वयं अप्रत्याशित परिणाम दे सकता है।

जैसे Math.floor(4.3) = 4, लेकिनMath.floor(-4.3) = -5

सुसंगत परिणाम प्राप्त करने के लिए इस तरह एक सहायक फ़ंक्शन का उपयोग करें:

truncateDecimals = function (number) {
    return Math[number < 0 ? 'ceil' : 'floor'](number);
};

// Applied to Dogbert's answer:
var a = 5.467;
var truncated = truncateDecimals(a * 100) / 100; // = 5.46

यहाँ इस समारोह का एक और अधिक सुविधाजनक संस्करण है:

truncateDecimals = function (number, digits) {
    var multiplier = Math.pow(10, digits),
        adjustedNum = number * multiplier,
        truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);

    return truncatedNum / multiplier;
};

// Usage:
var a = 5.467;
var truncated = truncateDecimals(a, 2); // = 5.46

// Negative digits:
var b = 4235.24;
var truncated = truncateDecimals(b, -2); // = 4200

यदि वह वांछित व्यवहार नहीं है, Math.absतो पहली पंक्ति में कॉल डालें :

var multiplier = Math.pow(10, Math.abs(digits)),

संपादित करें: shendz सही ढंग से बताता है कि इस समाधान का उपयोग a = 17.56गलत तरीके से होगा 17.55। ऐसा क्यों होता है, इसके बारे में अधिक जानने के लिए, फ्लोटिंग-पॉइंट अंकगणित के बारे में हर कंप्यूटर वैज्ञानिक को क्या जानना चाहिए । दुर्भाग्य से, एक समाधान लिखना जो फ्लोटिंग-पॉइंट त्रुटि के सभी स्रोतों को समाप्त करता है, जावास्क्रिप्ट के साथ बहुत मुश्किल है। किसी अन्य भाषा में आप पूर्णांक या शायद दशमलव प्रकार का उपयोग करेंगे, लेकिन जावास्क्रिप्ट के साथ ...

यह समाधान 100% सटीक होना चाहिए , लेकिन यह भी धीमा होगा:

function truncateDecimals (num, digits) {
    var numS = num.toString(),
        decPos = numS.indexOf('.'),
        substrLength = decPos == -1 ? numS.length : 1 + decPos + digits,
        trimmedResult = numS.substr(0, substrLength),
        finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    return parseFloat(finalResult);
}

उन लोगों के लिए जिन्हें गति की आवश्यकता है, लेकिन फ़्लोटिंग-पॉइंट त्रुटियों से भी बचना चाहते हैं, BigDecimal.js की तरह कुछ आज़माएं । आप इस SO प्रश्न में अन्य जावास्क्रिप्ट BigDecimal पुस्तकालयों को पा सकते हैं: "क्या एक अच्छी जावास्क्रिप्ट Bigececimal पुस्तकालय है?" और यहाँ जावास्क्रिप्ट के लिए गणित पुस्तकालयों के बारे में एक अच्छा ब्लॉग पोस्ट है

Question 4

var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46

Question 5

आप ०.फिक्स के लिए ०.५ घटाकर गोलाई को ठीक कर सकते हैं, जैसे

(f - 0.005).toFixed(2)

Question 6

डबल टिल्ड का लाभ लेने~~ पर विचार करें :।

संख्या में लें। दशमलव के बाद महत्वपूर्ण अंकों से गुणा करें ताकि आप के साथ शून्य स्थानों को काट सकें ~~। उस गुणक को वापस विभाजित करें। फायदा।

function truncator(numToTruncate, intDecimalPlaces) {    
    var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
    return ~~(numToTruncate * numPower)/numPower;
}

मैं ~~कॉल को परेंस में लपेटने का विरोध करने की कोशिश कर रहा हूं ; संचालन के क्रम को उस काम को सही ढंग से करना चाहिए, मुझे विश्वास है।

alert(truncator(5.1231231, 1)); // is 5.1

alert(truncator(-5.73, 1)); // is -5.7

alert(truncator(-5.73, 0)); // is -5

JSFiddle लिंक ।

संपादित करें: वापस देख रहे हैं, मैंने अनजाने में भी मामलों को संभाल लिया है ताकि दशमलव के बाईं ओर गोल हो सकें।

alert(truncator(4343.123, -2)); // gives 4300.

लॉजिक थोड़ा निराला है जो उस उपयोग की तलाश में है, और एक त्वरित रिफ्लेक्टर से लाभ हो सकता है। लेकिन यह अभी भी काम करता है। अच्छे से बेहतर भाग्यशाली।

Question 7

अच्छा एक लाइन समाधान:

function truncate (num, places) {
  return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}

फिर इसके साथ कॉल करें:

truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632

Question 8

मैंने सोचा कि मैं एक उत्तर का उपयोग करके फेंक दूंगा |क्योंकि यह सरल है और अच्छी तरह से काम करता है।

truncate = function(number, places) {
  var shift = Math.pow(10, places);

  return ((number * shift) | 0) / shift;
};

Question 9

बिटकॉइन संचालकों का उपयोग करना बंद करें:

~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439

Question 10

@ डॉगबर्ट के उत्तर के साथ सुधार किया जा सकता है Math.trunc, जो गोलाई के बजाय कम हो जाता है।

गोलाई और छंटाई के बीच अंतर है। ट्रंकटिंग स्पष्ट रूप से वह व्यवहार है जो यह प्रश्न चाह रहा है। यदि मैं ट्रंकट (-3.14) को कॉल करता हूं और -4 वापस प्राप्त करता हूं, तो मैं निश्चित रूप से उस अवांछनीय को कॉल करूंगा। - @NickKnowlson

var a = 5.467;
var truncated = Math.trunc(a * 100) / 100; // = 5.46

var a = -5.467;
var truncated = Math.trunc(a * 100) / 100; // = -5.46

Question 11

मैंने एक छोटी विधि का उपयोग करके उत्तर लिखा। यहां वह है जो मैंने जुटाया

function truncate(value, precision) {
    var step = Math.pow(10, precision || 0);
    var temp = Math.trunc(step * value);

    return temp / step;
}

विधि का उपयोग इस तरह किया जा सकता है

truncate(132456.25456789, 5)); // Output: 132456.25456
truncate(132456.25456789, 3)); // Output: 132456.254
truncate(132456.25456789, 1)); // Output: 132456.2   
truncate(132456.25456789));    // Output: 132456

या, यदि आप एक छोटे वाक्यविन्यास चाहते हैं, तो यहां आप जाएं

function truncate(v, p) {
    var s = Math.pow(10, p || 0);
    return Math.trunc(s * v) / s;
}

Question 12

Number.prototype.trim = function(decimals) {
    var s = this.toString();
    var d = s.split(".");
    d[1] = d[1].substring(0, decimals);
    return parseFloat(d.join("."));
}

console.log((5.676).trim(2)); //logs 5.67

Question 13

मुझे लगता है कि यह फ़ंक्शन एक सरल समाधान हो सकता है:

function trunc(decimal,n=2){
  let x = decimal + ''; // string 
  return x.lastIndexOf('.')>=0?parseFloat(x.substr(0,x.lastIndexOf('.')+(n+1))):decimal; // You can use indexOf() instead of lastIndexOf()
}

console.log(trunc(-241.31234,2));
console.log(trunc(241.312,5));
console.log(trunc(-241.233));
console.log(trunc(241.2,0));  
console.log(trunc(241));

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

Question 14

मुझे एक समस्या मिली: अगली स्थिति पर विचार: 2.1 या 1.2 या -6.4

क्या होगा यदि आप हमेशा 3 डेसीमल या दो या wharever चाहते हैं, तो, आपको दाईं ओर अग्रणी शून्य पूरा करना होगा

// 3 decimals numbers
0.5 => 0.500

// 6 decimals
0.1 => 0.10000

// 4 decimales
-2.1 => -2.1000

// truncate to 3 decimals
3.11568 => 3.115

यह निक नॉल्ससन का निश्चित कार्य है

function truncateDecimals (num, digits) 
{
    var numS = num.toString();
    var decPos = numS.indexOf('.');
    var substrLength = decPos == -1 ? numS.length : 1 + decPos + digits;
    var trimmedResult = numS.substr(0, substrLength);
    var finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    // adds leading zeros to the right
    if (decPos != -1){
        var s = trimmedResult+"";
        decPos = s.indexOf('.');
        var decLength = s.length - decPos;

            while (decLength <= digits){
                s = s + "0";
                decPos = s.indexOf('.');
                decLength = s.length - decPos;
                substrLength = decPos == -1 ? s.length : 1 + decPos + digits;
            };
        finalResult = s;
    }
    return finalResult;
};

https://jsfiddle.net/huttn155/7/

Question 15

function toFixed(number, digits) {
    var reg_ex = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)")
    var array = number.toString().match(reg_ex);
    return array ? parseFloat(array[1]) : number.valueOf()
}

var test = 10.123456789
var __fixed = toFixed(test, 6)
console.log(__fixed)
// => 10.123456

Question 16

@Kirilloid द्वारा उत्तर सही उत्तर लगता है, हालाँकि, मुख्य कोड को अपडेट करने की आवश्यकता है। उसका समाधान नकारात्मक संख्याओं का ध्यान नहीं रखता (जो किसी ने टिप्पणी अनुभाग में उल्लेख किया है लेकिन मुख्य कोड में अपडेट नहीं किया गया है)।

अद्यतन करने के लिए एक पूर्ण अंतिम परीक्षण समाधान:

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("([-]*\\d+\\.\\d{" + digits + "})(\\d)"),
    m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

नमूना उपयोग:

var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log

फिडल: JS Number राउंड डाउन

पुनश्च: उस समाधान पर टिप्पणी करने के लिए पर्याप्त रेपो नहीं।

Question 17

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

           function truncateNumber(num) {
                var num1 = "";
                var num2 = "";
                var num1 = num.split('.')[0];
                num2 = num.split('.')[1];
                var decimalNum = num2.substring(0, 2);
                var strNum = num1 +"."+ decimalNum;
                var finalNum = parseFloat(strNum);
                return finalNum;
            }

Question 18

परिणामी प्रकार एक नंबर रहता है ...

/* Return the truncation of n wrt base */
var trunc = function(n, base) {
    n = (n / base) | 0;
    return base * n;
};
var t = trunc(5.467, 0.01);

Question 19

Lodash कुछ गणित उपयोगिता तरीकों है कि कर सकते हैं दौर , फर्श , और प्लस्तर लगाना एक दिया दशमलव परिशुद्धता के लिए एक नंबर। यह पीछे चल रहे शून्य को छोड़ देता है।

वे एक संख्या के प्रतिपादक का उपयोग करके एक दिलचस्प दृष्टिकोण लेते हैं। जाहिरा तौर पर यह गोल मुद्दों से बचा जाता है।

(नोट: funcहै Math.roundया ceilया floorनीचे दिए गए कोड में)

// Shift with exponential notation to avoid floating-point issues.
var pair = (toString(number) + 'e').split('e'),
    value = func(pair[0] + 'e' + (+pair[1] + precision));

pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));

स्रोत कोड से लिंक करें

Question 20

यहाँ मेरे विषय पर ले:

convert.truncate = function(value, decimals) {
  decimals = (decimals === undefined ? 0 : decimals);
  return parseFloat((value-(0.5/Math.pow(10, decimals))).toFixed(decimals),10);
};

यह अभी थोड़ा अधिक विस्तृत संस्करण है

(f - 0.005).toFixed(2)

Question 21

जो समाधान के रूप में चिह्नित है वह बेहतर समाधान है जो मुझे आज तक मिला है, लेकिन 0 के साथ एक गंभीर समस्या है (उदाहरण के लिए, 0.toFixedDown (2) -0.01 देता है)। इसलिए मैं इसका उपयोग करने का सुझाव देता हूं:

Number.prototype.toFixedDown = function(digits) {
  if(this == 0) {
    return 0;
  }
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Question 22

यहाँ मेरा उपयोग है:

var t = 1;
for (var i = 0; i < decimalPrecision; i++)
    t = t * 10;

var f = parseFloat(value);
return (Math.floor(f * t)) / t;

Question 23

const TO_FIXED_MAX = 100;

function truncate(number, decimalsPrecison) {
  // make it a string with precision 1e-100
  number = number.toFixed(TO_FIXED_MAX);

  // chop off uneccessary digits
  const dotIndex = number.indexOf('.');
  number = number.substring(0, dotIndex + decimalsPrecison + 1);

  // back to a number data type (app specific)
  return Number.parseFloat(number);
}

// example
truncate(0.00000001999, 8);
0.00000001

के साथ काम करता है:

नकारात्मक संख्या
बहुत कम संख्या (संख्या। ईपीएसलोन परिशुद्धता)

Question 24

बस मेरे लिए काम करने वाले एक सरल उपाय को इंगित करने के लिए

इसे स्ट्रिंग में परिवर्तित करें और फिर इसे फिर से जोड़ें ...

var number = 123.45678;
var number_s = '' + number;
var number_truncated_s = number_s.match(/\d*\.\d{4}/)[0]
var number_truncated = parseFloat(number_truncated_s)

इसे संक्षिप्त किया जा सकता है

var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])

Question 25

यहाँ एक ES6 कोड है जो आप चाहते हैं

const truncateTo = (unRouned, nrOfDecimals = 2) => {
      const parts = String(unRouned).split(".");

      if (parts.length !== 2) {
          // without any decimal part
        return unRouned;
      }

      const newDecimals = parts[1].slice(0, nrOfDecimals),
        newString = `${parts[0]}.${newDecimals}`;

      return Number(newString);
    };

// your examples 

 console.log(truncateTo(5.467)); // ---> 5.46

 console.log(truncateTo(985.943)); // ---> 985.94

// other examples 

 console.log(truncateTo(5)); // ---> 5

 console.log(truncateTo(-5)); // ---> -5

 console.log(truncateTo(-985.943)); // ---> -985.94

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

Question 26

Number.prototype.truncate = function(places) {
  var shift = Math.pow(10, places);

  return Math.trunc(this * shift) / shift;
};

Question 27

आप तार के साथ काम कर सकते हैं। यह जाँच करता है अगर '।' मौजूद है, और फिर स्ट्रिंग का हिस्सा निकाल देता है।

truncate (7.88, 1) -> 7.8

truncate (7.889, 2) -> 7.89

truncate (-7.88, 1) -> -7.88

function  truncate(number, decimals) {
    const tmp = number + '';
    if (tmp.indexOf('.') > -1) {
        return +tmp.substr(0 , tmp.indexOf('.') + decimals+1 );
    } else {
        return +number
    }
 }

Question 28

मैं थोड़ा उलझन में हूं कि इस तरह के मूल रूप से सरल प्रश्न के इतने अलग-अलग उत्तर क्यों हैं; केवल दो दृष्टिकोण हैं जिन्हें मैंने देखा था जो देखने लायक थे। मैंने https://jsbench.me/ का उपयोग करके गति अंतर को देखने के लिए एक त्वरित बेंचमार्क किया ।

यह वह समाधान है जो वर्तमान में (9/26/2020) उत्तर के रूप में चिह्नित किया गया है:

function truncate(n, digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = n.toString().match(re);
    return m ? parseFloat(m[1]) : n.valueOf();
};

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

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

हालांकि, यह स्ट्रिंग और रेगेक्स सामान कर रहा है, जो आमतौर पर बहुत कुशल नहीं है, और एक Math.trunc फ़ंक्शन है जो वास्तव में करता है क्या ओपी बस कोई दशमलव के साथ चाहता है। इसलिए, आप आसानी से उसी चीज़ को प्राप्त करने के लिए उस अतिरिक्त अतिरिक्त अंकगणित का उपयोग कर सकते हैं।

यहाँ एक और समाधान है जो मुझे इस धागे पर मिला है, जो कि मैं उपयोग करूंगा:

function truncate(n, digits) {
    var step = Math.pow(10, digits || 0);
    var temp = Math.trunc(step * n);

    return temp / step;
}

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

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

पहली विधि दूसरी की तुलना में "99.92% धीमी" है, इसलिए दूसरी निश्चित रूप से है वह है जिसका मैं उपयोग करने की सलाह ।

ठीक है, काम से बचने के अन्य तरीके खोजने के लिए वापस ...