জাভাস্ক্রিপ্টে ঠিক দুটি দশমিক সহ একটি সংখ্যা ফর্ম্যাট করা

Question

আমার কাছে কোডের এই লাইনটি রয়েছে যা আমার সংখ্যাকে দুটি দশমিক স্থানে নিয়ে যায়। তবে আমি এই জাতীয় সংখ্যা পেয়েছি: 10.8, 2.4, ইত্যাদি। এগুলি দুটি দশমিক স্থান সম্পর্কে আমার ধারণা নয় সুতরাং আমি কীভাবে নীচেরগুলিকে উন্নতি করতে পারি?

Math.round(price*Math.pow(10,2))/Math.pow(10,2);

আমি 10.80, 2.40 ইত্যাদির মতো নম্বর চাই want

Comments

আপনার কোডটি ঠিক ঠিক আমি যা খুঁজছিলাম (ছোট জেএসওএন ফাইলের জন্য ভাসমান যথার্থতা 7 দশমিক স্থানে হ্রাস করতে) গতিপথের জন্য ম্যাথ.পো স্কিপিং ছাড়ছেন = ম্যাথ.াউন্ড (ভাল * 10000000) / 10000000);

— পাভেল

হিসাবে বর্তমানে গৃহীত উত্তর তর্কসাপেক্ষে অনির্দিষ্টতা সংখ্যায় সহজাত বিরক্তিকর মান ধন্যবাদ একটি ব্যাপক পরিসরের জন্য একটি ভুল ফলাফল দেয় ( 0.565, 0.575, 1.005), আমি আবার খুঁজছেন পরামর্শ দিতে পারেন এই উত্তরটি যা তাদের সংশোধন পায়?

— টিজে ক্রাউডার

হতে পারে আপনি জাভাস্ক্রিপ্টের জন্য একটি স্প্রিন্ট লাইব্রেরি অন্তর্ভুক্ত করতে চান স্ট্যাকওভারফ্লো.com

— প্রশ্নস /

দশমিক স্থান স্থানান্তর এবং গোল করার পদ্ধতিটি সঠিকভাবে গোল করার পরে, আপনি number.toFixed(x)পদ্ধতিটি প্রয়োজনীয় পরিমাণ জিরো দিয়ে স্ট্রিংয়ে রূপান্তর করতে ব্যবহার করতে পারেন । যেমন বৃত্তাকার 1.34থেকে 1.3ক্রস ব্রাউজার পদ্ধতি দিয়ে তারপর সাথে STRING 1 শূন্য এবং ধর্মান্তরিত যোগ 1.3.toFixed(2)(পেতে "1.30")।

— এডওয়ার্ড

Answer 1

নির্দিষ্ট বিন্দু স্বরলিপি ব্যবহার করে একটি নম্বর বিন্যাস করার জন্য, আপনাকে কেবল ব্যবহার করতে পারেন toFixed পদ্ধতি:

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

নোট করুন যে toFixed()একটি স্ট্রিং প্রদান করে।

গুরুত্বপূর্ণ : নোট করুন যে টু ফিক্সড 90% সময়কে গোল করে না, এটি গোলাকার মানটি ফিরিয়ে দেবে, তবে অনেক ক্ষেত্রে এটি কার্যকর হয় না।

এই ক্ষেত্রে:

2.005.toFixed(2) === "2.00"

হালনাগাদ:

আজকাল, আপনি Intl.NumberFormatনির্মাণকারী ব্যবহার করতে পারেন । এটি ECMAScript আন্তর্জাতিককরণ API স্পেসিফিকেশন (ECMA402) এর অংশ । আইই 11 সহ এটির বেশ ভাল ব্রাউজার সমর্থন রয়েছে এবং এটি সম্পূর্ণ নোড.জেজে সমর্থিত ।

const formatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});

console.log(formatter.format(2.005)); // "2.01"
console.log(formatter.format(1.345)); // "1.35"

আপনি বিকল্পভাবে toLocaleStringপদ্ধতিটি ব্যবহার করতে পারেন , যা অভ্যন্তরীণভাবে Intlএপিআই ব্যবহার করবে :

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

এই এপিআই আপনাকে ফরম্যাট করার বিভিন্ন ধরণের বিকল্প সরবরাহ করে, যেমন হাজার বিভাজক, মুদ্রা প্রতীক ইত্যাদি provides

Comments

সমস্ত ব্রাউজারে (0.09).toFixed(1);

— অবিচ্ছিন্নভাবে

ফিক্সডটি গোলাকার হয় না, আপনি প্রথমে এটি করতে পারেন: (ম্যাথ.াউন্ড (0.09)) টু ফিক্সড (1);

— রেকানস

@ রেকানস: এটি ভুল। Math.Round(0.09)ফিরে আসবে 0তাই এটি সর্বদা দেবে 0.0...

— ক্রিস

এটি বেশিরভাগ পরিস্থিতিতে এটি একটি খারাপ ধারণা, এটি কিছু ক্ষেত্রে স্ট্রিং বা ফ্লোট পয়েন্ট সংখ্যায় রূপান্তর করে।

— অ্যাশ ব্লু

এখানে @ অ্যাশ ব্লুয়ের সাথে একমত হতে হবে ... এটি কেবল মানগুলির উপস্থাপনা বিন্যাসের জন্য নিরাপদ। আরও গণনা সহ কোড ভাঙতে পারে। অন্যথায় Math.round(value*100)/1002DP এর জন্য আরও ভাল কাজ করে।

— আপক্রিক 6

Answer 2

এটি একটি পুরানো বিষয় তবে এখনও শীর্ষস্থানীয় গুগলের ফলাফল এবং প্রদত্ত সমাধানগুলি একই ভাসমান পয়েন্ট দশমিকের ইস্যু ভাগ করে share এখানে আমি ব্যবহার করছি (খুব জেনেরিক) ফাংশন, এমডিএনকে ধন্যবাদ :

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}

আমরা দেখতে পাচ্ছি, আমরা এই সমস্যাগুলি পাই না:

round(1.275, 2);   // Returns 1.28
round(1.27499, 2); // Returns 1.27

এই উদারতা কিছু দুর্দান্ত জিনিস সরবরাহ করে:

round(1234.5678, -2);   // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45");        // Returns 123

---

এখন, ওপি-র প্রশ্নের উত্তর দিতে, একটি টাইপ করতে হবে:

round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2);    // Returns "10.80"

---

বা, আরও সংক্ষিপ্ত, কম জেনেরিক ফাংশনের জন্য:

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2)));

  // Shift back
  value = value.toString().split('e');
  return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2);
}

আপনি এটি দিয়ে কল করতে পারেন:

round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8);    // Returns "10.80"

---

বিভিন্ন উদাহরণ এবং পরীক্ষাগুলি ( @ টিজে-কর্ডারকে ধন্যবাদ !):

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}
function naive(value, exp) {
  if (!exp) {
    return Math.round(value);
  }
  var pow = Math.pow(10, exp);
  return Math.round(value * pow) / pow;
}
function test(val, places) {
  subtest(val, places);
  val = typeof val === "string" ? "-" + val : -val;
  subtest(val, places);
}
function subtest(val, places) {
  var placesOrZero = places || 0;
  var naiveResult = naive(val, places);
  var roundResult = round(val, places);
  if (placesOrZero >= 0) {
    naiveResult = naiveResult.toFixed(placesOrZero);
    roundResult = roundResult.toFixed(placesOrZero);
  } else {
    naiveResult = naiveResult.toString();
    roundResult = roundResult.toString();
  }
  $("<tr>")
    .append($("<td>").text(JSON.stringify(val)))
    .append($("<td>").text(placesOrZero))
    .append($("<td>").text(naiveResult))
    .append($("<td>").text(roundResult))
    .appendTo("#results");
}
test(0.565, 2);
test(0.575, 2);
test(0.585, 2);
test(1.275, 2);
test(1.27499, 2);
test(1234.5678, -2);
test(1.2345678e+2, 2);
test("123.45");
test(10.8034, 2);
test(10.8, 2);
test(1.005, 2);
test(1.0005, 2);

table {
  border-collapse: collapse;
}
table, td, th {
  border: 1px solid #ddd;
}
td, th {
  padding: 4px;
}
th {
  font-weight: normal;
  font-family: sans-serif;
}
td {
  font-family: monospace;
}

<table>
  <thead>
    <tr>
      <th>Input</th>
      <th>Places</th>
      <th>Naive</th>
      <th>Thorough</th>
    </tr>
  </thead>
  <tbody id="results">
  </tbody>
</table>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Comments

কীভাবে এটি করার সহজ উপায় নেই? ES6 উদ্ধার?

— শূন্য_কুল

MDN পলিফিল পোস্ট করার জন্য আপনাকে ধন্যবাদ। লিঙ্কযুক্ত এমডিএন পৃষ্ঠায় পলিফিল আর নেই। আমি অবাক হয়েছি কেন এটি সরানো হয়েছে ...

— কিং হলি

Answer 3

আমি সাধারণত এটি আমার ব্যক্তিগত লাইব্রেরিতে যুক্ত করি এবং কিছু পরামর্শ দেওয়ার পরে এবং @ টিআইএমআইএন নিউট্রন সমাধানটিও ব্যবহার করে এবং এটি দশমিক দৈর্ঘ্যের জন্য অভিযোজ্য করে তোলা, এটি সেরা ফিট করে:

function precise_round(num, decimals) {
   var t = Math.pow(10, decimals);   
   return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals);
}

রিপোর্ট ব্যতিক্রম জন্য কাজ করবে।

Comments

অবিকল_আউন্ড (1.275,2) 1.27?

— অ্যালেনহক্কিম

@ আইমরে রিটার্ন মানটি (ম্যাথ.াউন্ড (নম্ব * ম্যাথ.প্যাও (10, দশমিক)) / ম্যাথ.পো (10, দশমিক) এ পরিবর্তন করুন to এবং আপনার আর এই সমস্যা থাকবে না।

— dkroy

আপনার দ্বিতীয় ফাংশনটি যদি এমনভাবে গ্রহণ করা হয় তবে এটি "সংকেত" এবং "ডিস" ঘোষণা করবেন যেখানে এটি অপরিজ্ঞাত হওয়া উচিত নয়?

— অ্যাডি এনগম

আইই-তে মিসাইন সাইন পদ্ধতির জন্য আমি একটি ওয়ার্কআরাউন্ড যুক্ত করেছি: gist.github.com/ArminVieweg/28647e735aa6efaba401

— আর্মিন

@ আর্মিন আপনার ফিক্স এটিকে সাফারিতে কাজ করে। আসল ফাংশনটি সাফারিটিতে কাজ করেনি।

— ডেভ

Answer 4

আমি জানি না কেন আমি পূর্বের উত্তরে একটি মন্তব্য যুক্ত করতে পারি না (সম্ভবত আমি আশাহত অন্ধ, দুনো) তবে @ মিগুয়ের উত্তরটি ব্যবহার করে আমি একটি সমাধান নিয়ে এসেছি:

function precise_round(num,decimals) {
   return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}

এবং এটির দুটি মন্তব্য (@ বিঘোস্টকিম এবং @ ইম্রে থেকে):

• precise_round(1.275,2)1.28 ফেরত না দেওয়ার ক্ষেত্রে সমস্যা
• precise_round(6,2)6.00 (তিনি যেমন চেয়েছিলেন) ফিরে না আসায় সমস্যা ।

আমার চূড়ান্ত সমাধানটি নিম্নরূপ:

function precise_round(num,decimals) {
    var sign = num >= 0 ? 1 : -1;
    return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals);
}

যেমন আপনি দেখতে পাচ্ছেন আমাকে কিছুটা "সংশোধন" যুক্ত করতে হয়েছিল (এটি কী তা নয় তবে যেহেতু ম্যাথগ্রাউন্ডটি ক্ষতিকারক - আপনি এটি jsfiddle.net এ যাচাই করতে পারেন - এটি কেবলমাত্র আমি কীভাবে "ঠিক করতে" জানতাম "এটি)। এটি ইতিমধ্যে প্যাডড সংখ্যায় 0.001 যুক্ত করে, তাই এটি দশমিক মানের ডানদিকে একটি 1তিনটি যুক্ত করছে 0। সুতরাং এটি ব্যবহার করা নিরাপদ হওয়া উচিত।

এর পরে আমি .toFixed(decimal)সর্বদা সংখ্যাকে সঠিক বিন্যাসে আউটপুট যোগ করেছিলাম (দশমিকের সঠিক পরিমাণ সহ)।

সুতরাং এটি বেশ। এটি ভালভাবে ব্যবহার করুন;)

সম্পাদনা: negativeণাত্মক সংখ্যার "সংশোধন" এ কার্যকারিতা যুক্ত করেছে।

Comments

"সংশোধন" বেশিরভাগ সুরক্ষিত, তবে উদাহরণস্বরূপ precise_round(1.27499,2)এখন ১.২৮ টিও ফিরে আসে ... এটি Math.roundক্ষতিগ্রস্থ নয়; কম্পিউটারগুলি যেভাবে অভ্যন্তরীণভাবে ভাসমান পয়েন্টের মানগুলি সঞ্চয় করে is মূলত, ডেটা এমনকি আপনার ফাংশনে পৌঁছানোর আগে আপনি কিছু মান নিয়ে ব্যর্থ হয়ে

— যাবেন

ইমর, আপনি একদম ঠিক বলেছেন। এই কারণেই আমি এখানে এটি কী করছে তা আমি ব্যাখ্যা করছি, যদি কেউ এটিকে "আরও সুনির্দিষ্ট " করতে বা এমনকি এটি মুছতে চায় (যদি আপনার প্রতি ফ্লোটে 2 এমবিটাইট সহ একটি সুপার কম্পিউটার থাকে তবে আমি মনে করি না যে এখানে কেউ করেনি ;)

— tfrascaroli

প্রকৃতপক্ষে, ভাষা মান নির্দিষ্টকরণের জন্য সংখ্যাগুলির জন্য 64 বিট ব্যবহার সম্পর্কে নির্দিষ্ট, সুতরাং / একটি সুপার কম্পিউটার ব্যবহার করে কোনও পরিবর্তন হবে না :)

— ইম্রে

0.001 এর জন্য আপনি দশমিকের দৈর্ঘ্য অনুসারে অনেকগুলি শূন্য যোগ করে প্রতিস্থাপন করতে পারেন। তাই ..

— মিগুয়েল

Answer 5

১০০% নিশ্চিত হওয়ার একটি উপায় যে আপনি 2 দশমিক সহ একটি নম্বর পেয়েছেন:

(Math.round(num*100)/100).toFixed(2)

যদি এটি গোলাকার ত্রুটির কারণ হয়ে থাকে, আপনি জেমস তার মন্তব্যে যেমন ব্যাখ্যা করেছেন তেমনভাবে আপনি নিম্নলিখিতটি ব্যবহার করতে পারেন:

(Math.round((num * 1000)/10)/100).toFixed(2)

Comments

এটি করার সর্বোত্তম, সহজতম উপায়। তবে, ভাসমান পয়েন্ট গণিতের কারণে, 1.275 * 100 = 127.49999999999999, যা রাউন্ডিংয়ে সামান্য ত্রুটি ঘটাতে পারে। এটি ঠিক করার জন্য, আমরা 1000 দ্বারা গুণিত করতে এবং 10 দ্বারা ভাগ করতে পারি, (1.275 * 1000) / 10 = 127.5 হিসাবে। নিম্নরূপ: var answer = (Math.round((num * 1000)/10)/100).toFixed(2);

— জেমস গোল্ড

(ম্যাথ.াউন্ড ((1.015 * 1000) / 10) / 100) টোটিক্সড (2) এখনও 1.01 দেয়, এটি 1.02 হওয়া উচিত না?

— gaurav5430

Answer 6

toFixed (n) দশমিক বিন্দুর পরে n দৈর্ঘ্য সরবরাহ করে; toPrecision (x) এক্স মোট দৈর্ঘ্য সরবরাহ করে।

নীচে এই পদ্ধতিটি ব্যবহার করুন

// Example: toPrecision(4) when the number has 7 digits (3 before, 4 after)
    // It will round to the tenths place
    num = 500.2349;
    result = num.toPrecision(4); // result will equal 500.2

এবং আপনি যদি নম্বরটি নির্দিষ্ট ব্যবহারের জন্য চান

result = num.toFixed(2);

Comments

এটি ভালভাবে কাজ করে না ... সংখ্যাটির জন্য = 50.2349 আপনার 50.2 পাওয়ার জন্য প্রিসিশন (3) এ লিখতে হবে

— পাইট্র সিজিż

এটির একটি উদাহরণ আপনি এটি আপনার প্রয়োজন অনুসারে পরিবর্তন করতে পারেন @ পিওটারসিজিż

— সৈয়দ উমর আহমেদ

Answer 7

আমি এই সমস্যার সঠিক সমাধান খুঁজে পাইনি, তাই আমি নিজের তৈরি করেছি:

function inprecise_round(value, decPlaces) {
  return Math.round(value*Math.pow(10,decPlaces))/Math.pow(10,decPlaces);
}

function precise_round(value, decPlaces){
    var val = value * Math.pow(10, decPlaces);
    var fraction = (Math.round((val-parseInt(val))*10)/10);

    //this line is for consistency with .NET Decimal.Round behavior
    // -342.055 => -342.06
    if(fraction == -0.5) fraction = -0.6;

    val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
    return val;
}

উদাহরণ:

function inprecise_round(value, decPlaces) {
  return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

function precise_round(value, decPlaces) {
  var val = value * Math.pow(10, decPlaces);
  var fraction = (Math.round((val - parseInt(val)) * 10) / 10);

  //this line is for consistency with .NET Decimal.Round behavior
  // -342.055 => -342.06
  if (fraction == -0.5) fraction = -0.6;

  val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
  return val;
}

// This may produce different results depending on the browser environment
console.log("342.055.toFixed(2)         :", 342.055.toFixed(2)); // 342.06 on Chrome & IE10

console.log("inprecise_round(342.055, 2):", inprecise_round(342.055, 2)); // 342.05
console.log("precise_round(342.055, 2)  :", precise_round(342.055, 2));   // 342.06
console.log("precise_round(-342.055, 2) :", precise_round(-342.055, 2));  // -342.06

console.log("inprecise_round(0.565, 2)  :", inprecise_round(0.565, 2));   // 0.56
console.log("precise_round(0.565, 2)    :", precise_round(0.565, 2));     // 0.57

Comments

ধন্যবাদ। এটি পরীক্ষা করার জন্য এখানে একটি ছদ্মবেশ রয়েছে : jsfiddle.net/lamarant/ySXuF । আমি এটি ফিরিয়ে দেওয়ার আগে মানটিতে ফিক্সড () প্রয়োগ করছি যা প্রত্যাবর্তিত মানের শেষে শূন্যের সঠিক সংখ্যা সংযোজন করে।

— লামারেন্ট

মানটির জন্য কাজ করছে না = 0,004990845956707237 এবং ইনপ্রিসাইজ_উন্ড (মান, 8) 0,00499085 প্রদান করে তবে এটি অবশ্যই 0,00499084 ফিরে আসতে হবে

— MERT DOĞAN

Answer 8

@ হরিদেব এবং আমি jQuery এ একটি ছোট ফাংশন তৈরি করেছি।

আপনি পরবর্তী চেষ্টা করতে পারেন:

এইচটিএমএল

<input type="text" name="one" class="two-digits"><br>
<input type="text" name="two" class="two-digits">​

jQuery এর

// apply the two-digits behaviour to elements with 'two-digits' as their class
$( function() {
    $('.two-digits').keyup(function(){
        if($(this).val().indexOf('.')!=-1){         
            if($(this).val().split(".")[1].length > 2){                
                if( isNaN( parseFloat( this.value ) ) ) return;
                this.value = parseFloat(this.value).toFixed(2);
            }  
         }            
         return this; //for chaining
    });
});

ডেমো অনলাইন:

http://jsfiddle.net/c4Wqn/

Comments

আমি এই অবদানটির প্রশংসা করতে পারি, যদিও আমি মনে করি যে মিশ্রনে DOM উপাদান এবং jQuery যুক্ত করা প্রশ্নের প্রশ্নের বাইরে নয়।

— ক্রিস মে

আপনার কী-আপ ইভেন্টটি শোনা উচিত নয়, কারণ এটি ভার্চুয়াল খারাপ দেখাচ্ছে এবং আপনি যখন স্ক্রিপ্টের সাথে কিছু যুক্ত করেন তখন সক্রিয় হয় না। আমি বরং শুনতে চাইinput ঘটনাটি । এটি ঝাঁকুনির প্রভাব তৈরি করে না এবং জেএসের সাথে আপনি যখন ক্ষেত্রটি অ্যাক্সেস করেন তখন তা জ্বলে ওঠে

— ঝাঁকুনির

Answer 9

ভাসমান পয়েন্টের মানগুলির সমস্যা হ'ল তারা নির্ধারিত পরিমাণে বিট সহ অসীম পরিমাণ (অবিচ্ছিন্ন) মান উপস্থাপনের চেষ্টা করছেন। সুতরাং স্বাভাবিকভাবেই, খেলায় কিছু লোকসান হতে হবে এবং আপনাকে কয়েকটি মান দিয়ে দংশিত হতে চলেছে।

যখন কোনও কম্পিউটার 1.275 কে একটি ভাসমান পয়েন্টের মান হিসাবে সঞ্চয় করে, এটি আসলে মনে করবে না এটি 1.275 বা 1.27499999999999993, এমনকি 1.27500000000000002 ছিল কিনা whether এই মানগুলি দুটি দশমিকের বৃত্তাকার পরে বিভিন্ন ফলাফল দেয়, তবে তারা তা করবে না, যেহেতু কম্পিউটারের জন্য তারা ভাসমান পয়েন্টের মান হিসাবে সংরক্ষণ করার পরে ঠিক একই রকম দেখায় এবং হারিয়ে যাওয়া ডেটা পুনরুদ্ধারের কোনও উপায় নেই। পরবর্তী কোনও গণনা কেবল এই জাতীয় অসম্পূর্ণতা জমা করবে।

সুতরাং, যদি নির্ভুলতার বিষয়টি বিবেচনা করে তবে আপনাকে শুরু থেকেই ভাসমান পয়েন্টের মানগুলি এড়াতে হবে। সহজ বিকল্পগুলি হল

• একটি উত্সর্গীকৃত গ্রন্থাগার ব্যবহার করুন
• মানগুলি সংরক্ষণ এবং পাস করার জন্য স্ট্রিংগুলি ব্যবহার করুন (স্ট্রিং অপারেশন সহ)
• পূর্ণসংখ্যা ব্যবহার করুন (উদাহরণস্বরূপ আপনি আপনার আসল মূল্যের শততম পরিমাণের কাছাকাছি যেতে পারেন, যেমন ডলারের পরিবর্তে সেন্টে পরিমাণ)

উদাহরণস্বরূপ, শততম সংখ্যা সঞ্চয় করতে পূর্ণসংখ্যার ব্যবহার করার সময়, আসল মান সন্ধানের জন্য ফাংশনটি বেশ সহজ:

function descale(num, decimals) {
    var hasMinus = num < 0;
    var numString = Math.abs(num).toString();
    var precedingZeroes = '';
    for (var i = numString.length; i <= decimals; i++) {
        precedingZeroes += '0';
    }
    numString = precedingZeroes + numString;
    return (hasMinus ? '-' : '') 
        + numString.substr(0, numString.length-decimals) 
        + '.' 
        + numString.substr(numString.length-decimals);
}

alert(descale(127, 2));

স্ট্রিংগুলির সাথে আপনার গোলাকার প্রয়োজন, তবে এটি এখনও পরিচালনাযোগ্য:

function precise_round(num, decimals) {
    var parts = num.split('.');
    var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-';
    var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]);
    var decimalPart = parts.length > 1 ? parts[1] : '';
    if (decimalPart.length > decimals) {
        var roundOffNumber = decimalPart.charAt(decimals);
        decimalPart = decimalPart.substr(0, decimals);
        if ('56789'.indexOf(roundOffNumber) > -1) {
            var numbers = integralPart + decimalPart;
            var i = numbers.length;
            var trailingZeroes = '';
            var justOneAndTrailingZeroes = true;
            do {
                i--;
                var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i)));
                if (roundedNumber === '0') {
                    trailingZeroes += '0';
                } else {
                    numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes;
                    justOneAndTrailingZeroes = false;
                    break;
                }
            } while (i > 0);
            if (justOneAndTrailingZeroes) {
                numbers = '1' + trailingZeroes;
            }
            integralPart = numbers.substr(0, numbers.length - decimals);
            decimalPart = numbers.substr(numbers.length - decimals);
        }
    } else {
        for (var i = decimalPart.length; i < decimals; i++) {
            decimalPart += '0';
        }
    }
    return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : '');
}

alert(precise_round('1.275', 2));
alert(precise_round('1.27499999999999993', 2));

নোট করুন যে এই ফাংশনটি কাছাকাছি অবস্থিত, শূন্য থেকে দূরে সম্পর্কযুক্ত , যখন আইইইই 754 কাছাকাছি গোলাকার প্রস্তাব দেয় এমনকি ভাসমান পয়েন্ট অপারেশনগুলির জন্য ডিফল্ট আচরণ হিসাবেও সম্পর্কযুক্ত । এই জাতীয় পরিবর্তনগুলি পাঠকের অনুশীলন হিসাবে ছেড়ে গেছে :)

Answer 10

এখানে একটি সহজ

function roundFloat(num,dec){
    var d = 1;
    for (var i=0; i<dec; i++){
        d += "0";
    }
    return Math.round(num * d) / d;
}

মত ব্যবহার করুন alert(roundFloat(1.79209243929,4));

Jsfiddle

Answer 11

আপনার দশমিক মানটিকে গোল করুন, তারপরে toFixed(x)আপনার প্রত্যাশিত অঙ্কের জন্য ব্যবহার করুন।

function parseDecimalRoundAndFixed(num,dec){
  var d =  Math.pow(10,dec);
  return (Math.round(num * d) / d).toFixed(dec);
}

---

কল

পার্সডিসিমালআরউন্ডএন্ডফিক্সড (10.800243929,4) => 10.80 পার্সডিসিমাল রাউন্ডএন্ডফিক্সড (10.807243929,2) => 10.81

Answer 12

নিচে সুসম্পন্ন

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

বৃত্তাকার

function round_up(value, decPlaces) {
    return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

কাছাকাছি গোল

function round_nearest(value, decPlaces) {
    return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

Https://stackoverflow.com/a/7641824/1889449 এবং https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm মার্জ করা তাদের ধন্যবাদ।

Answer 13

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num + c) * p) / p;
}

// testing some +ve edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

// testing some -ve edge cases
console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

Answer 14

এখানে আমার 1-লাইন সমাধান: Number((yourNumericValueHere).toFixed(2));

যা ঘটে তা এখানে:

1) প্রথমে, আপনি .toFixed(2)যে দশকের দশমিক স্থানগুলি বন্ধ করতে চান তার উপর প্রয়োগ করুন । নোট করুন যে এটি মান থেকে একটি স্ট্রিংয়ে রূপান্তর করবে। সুতরাং আপনি যদি টাইপস্ক্রিপ্ট ব্যবহার করছেন তবে এটি এর মতো একটি ত্রুটি ছুঁড়ে দেবে:

"টাইপ 'স্ট্রিং' 'নম্বর' টাইপ করার জন্য যোগ্য নয়

2) সংখ্যার মানটি ফিরে পেতে বা স্ট্রিংটিকে সংখ্যাসূচক মানতে রূপান্তর করতে, কেবলমাত্র প্রয়োগ করুন Number() তথাকথিত 'স্ট্রিং' মানটিতে ফাংশনটি ।

স্পষ্টতার জন্য, নীচের উদাহরণটি দেখুন:

উদাহরণ: আমার একটি দশমিক স্থানে 5 অঙ্কের পরিমাণ রয়েছে এবং আমি এটি 2 টি দশমিক স্থানে সংক্ষিপ্ত করতে চাই। আমি এটি এর মতো করি:

var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);

Answer 15

নিম্নলিখিত কিছু বিশ্বব্যাপী সুযোগে রাখুন :

Number.prototype.getDecimals = function ( decDigCount ) {
   return this.toFixed(decDigCount);
}

এবং তারপরে চেষ্টা করুন :

var a = 56.23232323;
a.getDecimals(2); // will return 56.23

হালনাগাদ

দ্রষ্টব্য যে toFixed()কেবলমাত্র দশমিকের মধ্যে কাজ করতে পারে 0-20অর্থাত্ a.getDecimals(25)একটি জাভাস্ক্রিপ্ট ত্রুটি তৈরি করতে পারে, তাই আপনি কিছু অতিরিক্ত চেক যুক্ত করতে পারেন যাতে সামঞ্জস্য করার জন্য

Number.prototype.getDecimals = function ( decDigCount ) {
   return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}

Answer 16

Number(((Math.random() * 100) + 1).toFixed(2))

এটি 1 থেকে 100 থেকে 2 দশমিক স্থানে গোল করে একটি এলোমেলো সংখ্যা ফিরে আসবে।

Answer 17

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

এটি আমার পক্ষে কাজ করেছে: জাভাস্ক্রিপ্টে দশমিক দশমিক

Answer 18

রেফারেন্স দ্বারা এই প্রতিক্রিয়াটি ব্যবহার করে: https://stackoverflow.com/a/21029698/454827

দশমিকের গতিশীল সংখ্যা পেতে আমি একটি ফাংশন তৈরি করি:

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

এখানে কাজের উদাহরণ: https://jsfiddle.net/wpxLduLc/

Answer 19

parse = function (data) {
       data = Math.round(data*Math.pow(10,2))/Math.pow(10,2);
       if (data != null) {
            var lastone = data.toString().split('').pop();
            if (lastone != '.') {
                 data = parseFloat(data);
            }
       }
       return data;
  };

$('#result').html(parse(200)); // output 200
$('#result1').html(parse(200.1)); // output 200.1
$('#result2').html(parse(200.10)); // output 200.1
$('#result3').html(parse(200.109)); // output 200.11

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"></script>
<div id="result"></div>
<div id="result1"></div>
<div id="result2"></div>
<div id="result3"></div>

Answer 20

এই উদাহরণগুলির সাহায্যে আপনি এখনও 1.005 নম্বরের গোল করার চেষ্টা করার পরে একটি ত্রুটি পাবেন তবে সমাধানটি হয় ম্যাথ.জেএস বা এই ফাংশনের মতো লাইব্রেরি ব্যবহার করা:

function round(value: number, decimals: number) {
    return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}

Answer 21

আমি কয়েক মাস আগে এই পোস্টটি থেকে কিছু ধারণা পেয়েছি, তবে এখানে কোনও উত্তর, বা অন্যান্য পোস্ট / ব্লগের উত্তরগুলি সমস্ত পরিস্থিতি পরিচালনা করতে পারে নি (যেমন নেতিবাচক সংখ্যা এবং কিছু "ভাগ্যবান সংখ্যা" আমাদের পরীক্ষককে পাওয়া গেছে)। শেষ পর্যন্ত, আমাদের পরীক্ষক নীচে এই পদ্ধতিতে কোনও সমস্যা খুঁজে পান নি। আমার কোডের একটি স্নিপেট আটকানো:

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

আমার কাছে কোড মন্তব্যও রয়েছে (দুঃখিত আমি ইতিমধ্যে সমস্ত বিবরণ ভুলে গিয়েছি) ... ভবিষ্যতের রেফারেন্সের জন্য আমি এখানে আমার উত্তর পোস্ট করছি:

9.995 * 100 = 999.4999999999999
Whereas 9.995e2 = 999.5
This discrepancy causes Math.round(9.995 * 100) = 999 instead of 1000.
Use e notation instead of multiplying /dividing by Math.Pow(10,precision).

Answer 22

আমি সমস্যাটি সংশোধনকারীকে ঠিক করেছি। সমর্থন 2 দশমিক।

$(function(){
  //input number only.
  convertNumberFloatZero(22); // output : 22.00
  convertNumberFloatZero(22.5); // output : 22.50
  convertNumberFloatZero(22.55); // output : 22.55
  convertNumberFloatZero(22.556); // output : 22.56
  convertNumberFloatZero(22.555); // output : 22.55
  convertNumberFloatZero(22.5541); // output : 22.54
  convertNumberFloatZero(22222.5541); // output : 22,222.54

  function convertNumberFloatZero(number){
	if(!$.isNumeric(number)){
		return 'NaN';
	}
	var numberFloat = number.toFixed(3);
	var splitNumber = numberFloat.split(".");
	var cNumberFloat = number.toFixed(2);
	var cNsplitNumber = cNumberFloat.split(".");
	var lastChar = splitNumber[1].substr(splitNumber[1].length - 1);
	if(lastChar > 0 && lastChar < 5){
		cNsplitNumber[1]--;
	}
	return Number(splitNumber[0]).toLocaleString('en').concat('.').concat(cNsplitNumber[1]);
  };
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

Answer 23

(Math.round((10.2)*100)/100).toFixed(2)

এটি পাওয়া উচিত: 10.20

(Math.round((.05)*100)/100).toFixed(2)

এটি পাওয়া উচিত: 0.05

(Math.round((4.04)*100)/100).toFixed(2)

এটি পাওয়া উচিত: 4.04

প্রভৃতি

Answer 24

/*Due to all told stuff. You may do 2 things for different purposes:
When showing/printing stuff use this in your alert/innerHtml= contents:
YourRebelNumber.toFixed(2)*/

var aNumber=9242.16;
var YourRebelNumber=aNumber-9000;
alert(YourRebelNumber);
alert(YourRebelNumber.toFixed(2));

/*and when comparing use:
Number(YourRebelNumber.toFixed(2))*/

if(YourRebelNumber==242.16)alert("Not Rounded");
if(Number(YourRebelNumber.toFixed(2))==242.16)alert("Rounded");

/*Number will behave as you want in that moment. After that, it'll return to its defiance.
*/

Answer 25

এটি খুব সহজ এবং অন্য যে কোনওটির মতোই কাজ করে:

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

যেহেতু টু ফিক্সড () কেবলমাত্র সংখ্যায় কল করা যেতে পারে এবং দুর্ভাগ্যক্রমে একটি স্ট্রিং প্রদান করে, এটি উভয় দিক থেকে আপনার জন্য সমস্ত বিশ্লেষণ করে। আপনি একটি স্ট্রিং বা একটি নম্বর পাস করতে পারেন, এবং আপনি প্রতিবার একটি নম্বর ফিরে পাবেন! পার্সনম্বার (1.49) কল করা আপনাকে 1 দিবে, এবং পার্সনম্বার (1.49,2) আপনাকে 1.50 দেবে। 'এম এর সেরা মত!

Answer 26

আপনি .toPrecision()পদ্ধতিটি এবং কিছু কাস্টম কোডও ব্যবহার করতে পারেন এবং সর্বদা অংশের দৈর্ঘ্য নির্বিশেষে নবম দশমিক অঙ্ক পর্যন্ত গোল করতে পারেন।

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

আপনি এটি আরও ভাল ব্যবহারের জন্য একটি প্লাগইন তৈরি করতে পারেন।

Answer 27

এই হিসাবে সহজ।

var rounded_value=Math.round(value * 100) / 100;

Comments

ভুল। 1.015 ব্যবহার করুন

— মার্কো

Answer 28

আমি একটি খুব সহজ উপায় খুঁজে পেয়েছি যা আমার জন্য এই সমস্যাটি সমাধান করেছে এবং এটি ব্যবহার বা অভিযোজিত হতে পারে:

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

Answer 29

100% কাজ !!! চেষ্টা করে দেখুন

<html>
     <head>
      <script>
      function replacePonto(){
        var input = document.getElementById('qtd');
        var ponto = input.value.split('.').length;
        var slash = input.value.split('-').length;
        if (ponto > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        if(slash > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        input.value=input.value.replace(/[^0-9.-]/,'');

        if (ponto ==2)
	input.value=input.value.substr(0,(input.value.indexOf('.')+3));

if(input.value == '.')
	input.value = "";
              }
      </script>
      </head>
      <body>
         <input type="text" id="qtd" maxlength="10" style="width:140px" onkeyup="return replacePonto()">
      </body>
    </html>

Comments

তাই আপনাকে স্বাগতম। দয়া করে কীভাবে উত্তর দিন তা পড়ুন এবং উত্তর দেওয়ার জন্য গাইডলাইনটি অনুসরণ করুন।

— ওয়েওওয়েওয়ের