জাভাস্ক্রিপ্টে দশমিক সংখ্যাগুলি কাটা (গোলাকার নয়)

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হয় তবে প্রথম লাইনে একটি কল sert োকান:

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

সম্পাদনা: শেন্ডজ সঠিকভাবে উল্লেখ করে যে এই সমাধানটি ব্যবহার করে 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);
}

যাদের গতি প্রয়োজন তবে ভাসমান-পয়েন্ট ত্রুটিগুলি এড়াতে চান তাদের জন্য, বিগডেসিমাল.জেসের মতো কিছু চেষ্টা করুন । আপনি এই অন্যান্য প্রশ্নে অন্যান্য জাভাস্ক্রিপ্ট বিগডিসিমাল লাইব্রেরিগুলি খুঁজে পেতে পারেন: "একটি ভাল জাভাস্ক্রিপ্ট বিগডিসিমাল লাইব্রেরি আছে কি?" এবং জাভাস্ক্রিপ্টের জন্য গণিত লাইব্রেরি সম্পর্কে একটি ভাল ব্লগ পোস্ট এখানে

Question 4

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

Question 5

আপনি টু ফিক্সডের জন্য 0.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

জেএসফিডাল লিংক ।

সম্পাদনা: পিছনে সন্ধান, আমি অনিচ্ছাকৃতভাবে দশমিক বাম এছাড়াও বন্ধ গোলাকার মামলা পরিচালনা করেছি।

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 ফিরে পেয়েছি তবে আমি অবশ্যই এটি অনাকাঙ্ক্ষিত বলব। - @ নিককনলসন

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 দশমিক দুটি বা দুটি বা ওয়্যারইভার চান তবে কী, আপনাকে ডানদিকে অগ্রণী শূন্যগুলি সম্পন্ন করতে হবে

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

@ কিরিলয়েডের উত্তরটি সঠিক উত্তর বলে মনে হচ্ছে, তবে প্রধান কোডটি আপডেট করা দরকার। তার সমাধান নেতিবাচক সংখ্যার (যা মন্তব্য মন্তব্যে কেউ উল্লেখ করেছে তবে মূল কোডে আপডেট হয়নি) যত্ন নেয় না।

একটি সম্পূর্ণ চূড়ান্ত পরীক্ষিত সমাধানে এটি আপডেট করা:

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

ফিডল: জেএস নম্বরটি রাউন্ড ডাউন

PS: সমাধান সম্পর্কে মন্তব্য করার মতো পর্যাপ্ত রেপো নেই।

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

আপনি স্ট্রিং দিয়ে কাজ করতে পারেন। এটি পরীক্ষা করে যদি '।' উপস্থিত থাকে এবং তারপরে স্ট্রিংয়ের কিছু অংশ সরিয়ে দেয়।

কাটা (7.88, 1) -> 7.8

কাটা (7.889, 2) -> 7.89

কাটা (-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

আমি কেন এইরকম মৌলিক সরল প্রশ্নের অনেকগুলি ভিন্ন উত্তর রয়েছে তা সম্পর্কে কিছুটা বিভ্রান্তি; কেবল দুটি উপায় আছে যা আমি দেখেছিলাম যা দেখে মনে হবে উপযুক্ত worth 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];

স্নিপেট প্রসারিত করুন

যাইহোক, এটি স্ট্রিং এবং রেজেক্স স্টাফ করছে যা সাধারণত খুব দক্ষ হয় না, এবং একটি ম্যাথ.ট্রুঙ্ক ফাংশন রয়েছে যা হুবহু করে ওপি কোনও দশমিক ছাড়াই কী চায়। সুতরাং, একই জিনিসটি পেতে আপনি সহজেই সেই প্লাসটি সামান্য অতিরিক্ত পাটিগণিত ব্যবহার করতে পারেন।

এই থ্রেডটিতে আমি আরও একটি সমাধান পেয়েছি, যা আমি ব্যবহার করব:

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% ধীর", সুতরাং দ্বিতীয়টি অবশ্যই আমি ব্যবহারের পরামর্শ দিচ্ছি।

ঠিক আছে, কাজ এড়ানোর জন্য অন্য উপায়গুলি সন্ধান করতে ফিরে ...