ধরুন আমার 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 প্রদর্শিত করব?
উত্তর:
সংখ্যাটিকে স্ট্রিংয়ে রূপান্তর করুন, দ্বিতীয় দশমিক স্থানে নম্বরটি মেলা করুন:
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, তাই এটি সঙ্গে খুব সতর্কতা অবলম্বন করা আবশ্যক।
toFixed, যদিও: তাই (Math.floor(value * 100) / 100).toFixed(2)। আপনি সম্ভবত জানেন যে, অদ্ভুত নির্ভুলতার জিনিসগুলি ভাসমান পয়েন্টের মানগুলির সাথে ঘটতে পারে (এবং বর্ণালীটির অন্যদিকে, সংখ্যাটি যদি হয় 15তবে ওপি চাইবে এমন শোনায় 15.00)।
match(/^-?\d*(?:\.\d{0,2})?/)
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 । তবুও, আমি বিশ্বাস করি যে কেবল স্ট্রিংকে পার্স করা সহজ এবং সর্বদা নির্ভুল হবে।
@ গম্বোর দ্বারা গৃহীত উত্তর থেকে ভাল লিখিত রেজেক্সের আপডেটটি বুক করা, এই নতুন টু ফিক্সড ফাংশনটি সর্বদা প্রত্যাশা অনুযায়ী কাজ করবে।
আপনার নিজের ফিক্সড ফাংশনটি রোল করুন:
function toFixed(num, fixed) {
fixed = fixed || 0;
fixed = Math.pow(10, fixed);
return Math.floor(num * fixed) / fixed;
}
toFixed(0.0000000052, 2)'5.2' ফলন দেয়। return num.toFixed(fixed+1).match(re)[0];গোল করা এড়াতে লক্ষ্যমাত্রার উপরে এক দশমিক জায়গার সাথে ফিক্সড ব্যবহার করে নোটিশ ব্যবহার করে এটি ঠিক করা যেতে পারে, তারপরে আপনার রেজেক্স ম্যাচটি
আমি স্ট্রিংয়ের সাহায্যে বাকী অংশটি ম্যানুয়ালি মুছে ফেলার পরিবর্তে আমি এটি লিখতে পছন্দ করেছি যাতে সংখ্যার সাথে আসা গণিতের সমস্যাগুলির সাথে আমার মোকাবেলা করতে হবে না:
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;
কোনও সংখ্যাকে ছেঁটে ফেলার (কোনও গোলাকার নয়) সাধারণ সমাধান, কোনও n any0 এর জন্য একে ঠিক 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 হয় একটি সংখ্যা (যা স্ট্রিংয়ে রূপান্তরিত হয়) বা একটি স্ট্রিং হতে পারে।
এখানে এন = 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" এর জন্য জাভাস্ক্রিপ্টের অন্তর্নিহিত রূপান্তরিত কারণে এবং এন এর আরও কয়েকটি মানের জন্য:
15.001097 => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)
toFixedTrunc(0.000000199, 2) // 1.99
পার্সইন্টটি দ্রুত ম্যাথ.ফ্লোয়ার
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"
অন্য একক লাইন সমাধান:
number = Math.trunc(number*100)/100
আমি 100 ব্যবহার করেছিলাম কারণ আপনি দ্বিতীয় অঙ্কে ছাঁটাই করতে চান, তবে আরও নমনীয় সমাধানটি হ'ল:
number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)
যেখানে সংখ্যা হ'ল দশমিক অঙ্কের পরিমাণ।
বিশদ এবং ব্রাউজারের সামঞ্জস্যের জন্য ম্যাথ.ট্রুঙ্ক স্পেসগুলি দেখুন ।
num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)
এটি 19.66 এ ফিরে আসবে
এই সমাধানগুলি কাজ করে তবে আমার কাছে অযথা জটিল মনে হয়। বিভাগীয় ক্রিয়াকলাপের বাকী অংশগুলি পাওয়ার জন্য আমি ব্যক্তিগতভাবে মডুলাস অপারেটরটি ব্যবহার করতে এবং এটি সরাতে চাই। এই সংখ্যাটি ধরে নেওয়া = 15.7784514:
num-=num%.01;
এটি num = num - (num% .01) বলার সমতুল্য।
এখানে দেওয়া উত্তরগুলি আমাকে সাহায্য করে না, এটি আমাকে গোলটেপ করে বা ভুল দশমিক দেয়।
আমার সমাধান আপনার দশমিককে একটি স্ট্রিতে রূপান্তর করে, অক্ষরগুলি বের করে এবং তারপরে পুরো জিনিসটিকে একটি সংখ্যা হিসাবে ফিরিয়ে দেয়।
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
ধনাত্মক সংখ্যার জন্য আমার সংস্করণ:
function toFixed_norounding(n,p)
{
var result = n.toFixed(p);
return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}
দ্রুত, সুন্দর, সুস্পষ্ট। (ধনাত্মক সংখ্যার জন্য সংস্করণ)
-0.7752। এটি পরিবর্তে toFixed_norounding(-0.7752,2)ফিরে পরীক্ষা করুন -0.78-0.77
নিম্নলিখিত কোডটি আমার পক্ষে খুব ভাল কাজ করে:
num.toString().match(/.\*\\..{0,2}|.\*/)[0];
-?
আমি নিম্নলিখিত সহজ উপায় ব্যবহার করে স্থির করেছি-
var num = 15.7784514;
Math.floor(num*100)/100;
ফলাফল হবে 15.77
-15.7784514রিটার্ন-15.78
এই তুমি একটি উত্তর যা সমস্যার সমাধানের আরও একটি উপায় দেখায়:
// 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));
}
চূড়ান্ত প্রকাশের আগে + এর ব্যবহারটি নোট করুন। এটি হ'ল আমাদের কাটা, কাটা স্ট্রিংটিকে আবার সংখ্যার ধরণে রূপান্তর করতে।
আশা করি এটা সাহায্য করবে!
শূন্য ছাড়া কাটা
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
এটি আমার পক্ষে ভাল কাজ করেছে। আমি আশা করি এটি আপনার সমস্যাগুলিও ঠিক করবে।
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>এটি করার একটি সহজ উপায় পরবর্তীটি তবে প্রয়োজনীয় প্যারামিটারটি একটি স্ট্রিং হিসাবে দেওয়া হয়েছে তা নিশ্চিত করা দরকার।
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
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টাইপস্ক্রিপ্টে আমার সমাধান (সহজেই জেএসে পোর্ট করা যায়):
/**
* 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');
কোন উন্নতি?
আপনার নিজের 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.
নিয়মিত প্রকাশের সাথে গম্বোর দ্বিতীয় সমাধানটি কাজ করে তবে নিয়মিত প্রকাশের কারণে ধীর হয়। ভাসমান পয়েন্ট সংখ্যায় অস্পষ্টতার কারণে গাম্বোর প্রথম সমাধান নির্দিষ্ট পরিস্থিতিতে ব্যর্থ। জেএসফিডল দেখুনএকটি বিক্ষোভ এবং একটি মানদণ্ডের জন্য । দ্বিতীয় সমাধানটি আমার বর্তমান সিস্টেমে কল প্রতি প্রায় 1636 ন্যানোসেকেন্ড নেয়, ইন্টেল কোর i5-2500 সিপিইউ 3.30 গিগাহার্টজ এ।
আমি যে সমাধানটি লিখেছি তার মধ্যে ভাসমান পয়েন্ট অবজ্ঞানের যত্ন নেওয়ার জন্য একটি ক্ষুদ্র ক্ষতিপূরণ যুক্ত করা জড়িত। এটি মূলত তাত্ক্ষণিক, অর্থাৎ ন্যানোসেকেন্ডের আদেশ অনুসারে। আমি কল প্রতি 2 ন্যানোসেকেন্ড আটকেছি কিন্তু জাভাস্ক্রিপ্ট টাইমার খুব সুনির্দিষ্ট বা দানাদার নয়। এখানে জেএস ফিডল এবং কোড।
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);
ডেভিড ডি এর উত্তর উপর ভিত্তি করে :
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
গোল না করে দুটি ভাসমান পয়েন্ট পাওয়ার পক্ষে এটি আরও নির্ভরযোগ্য।
var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);ধন্যবাদ !
ইতিমধ্যে নিয়মিত অভিব্যক্তি এবং পাটিগণিত গণনা সহ কিছু উপযুক্ত উত্তর রয়েছে, আপনি এটি চেষ্টা করে দেখতেও পারেন
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
স্ট্রিং দিয়ে এটি কী হয়েছে তা এখানে
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;
}
আমি জানি যে ইতিমধ্যে কয়েকটি কার্যনির্বাহী উদাহরণ রয়েছে, তবে আমি মনে করি আমার স্ট্রিং.টোফিক্সড সমতুল্যটি প্রস্তাব করা ভাল, কারও কারও পক্ষে এটি সহায়ক হতে পারে।
এটি আমার টু ফিক্সড বিকল্প, এটি সংখ্যার বৃত্তাকার নয়, কেবল এটি সংক্ষিপ্ত করে দেয় বা প্রদত্ত নির্ভুলতা অনুসারে জিরো যুক্ত করে। অতিরিক্ত দীর্ঘ সংখ্যার জন্য এটি জেএস বিল্ট-ইন রাউন্ডিং ব্যবহার করে যখন যথার্থতা দীর্ঘ হয়। ফ্যাক্সটি স্ট্যাকের মধ্যে পাওয়া সমস্ত সমস্যাযুক্ত সংখ্যার জন্য কাজ করে।
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।
এজন্য জাভাস্ক্রিপ্টে আসল সংখ্যার সাথে ডিল করার সময় এই জাতীয় গুণক / বিভাজকটি ব্যবহার করা এত গুরুত্বপূর্ণ, বিশেষত যখন আপনি অর্থ গণনা করছেন ...