تنسيق رقم يتكون من رقمين عشريين بالضبط في JavaScript

Question

لدي هذا السطر من التعليمات البرمجية الذي يقوم بتقريب أرقامي إلى منزلتين عشريتين.لكني أحصل على أرقام مثل هذا:10.8، 2.4، إلخ.هذه ليست فكرتي عن منزلتين عشريتين، فكيف يمكنني تحسين ما يلي؟

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

أريد أرقامًا مثل 10.80 و2.40 وما إلى ذلك.استخدام jQuery جيد بالنسبة لي.

Answer 1

لتهيئة رقم باستخدام تدوين النقاط الثابتة، يمكنك ببساطة استخدام للتصليح طريقة:

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

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

لاحظ أن toFixed() إرجاع سلسلة.

الأهمية: لاحظ أن Tofixed لا يعمل في الواقع، 90٪ من الوقت، وسوف يعيد القيمة المدورة ولكن بالنسبة للعديد من الحالات لا يعمل بالفعل. جرب هذا في وحدة التحكم الخاصة بك:

2.005.toFixed(2)

سوف تحصل على إجابة خاطئة

لا توجد طريقة طبيعية للحصول على تقريب عشري في جافا سكريبت، وسوف تحتاج إلى مكتبة polyfl أو استخدامها. يمكنك أن تنظر إلى Polyfly's Mozilla لهذا https:/developer.mozilla.org/en-us/docs/web/javascript/Reference/global_Objects/math/round.

Answer 2

هذا موضوع قديم ولكن لا يزال أعلى نتائج Google في المرتبة الأعلى والحلول المقدمة مشاركة نفس إصدار العشرات العشرية. هنا هي وظيفة (عامة للغاية) التي أستخدمها، بفضل MDN.:

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

---

الآن، للإجابة على سؤال OP، على المرء أن يكتب:

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"

---

أمثلة مختلفة واختبارات (بفضل @ TJ-Crackder!):

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>

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);
}

سوف تعمل من أجل الاستثناءات المبلغ عنها.

Answer 4

لا أعرف لماذا لا يمكنني إضافة تعليق إلى إجابة سابقة (ربما أعمى بشكل يائس، دونو)، لكنني توصلت إلى حل باستخدام إجابة @ Miguel:

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

واثنين من التعليقات (من bighostkim ويمري):

• مشكلة مع 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);
}

كما ترون كان علي أن أضيف قليلا من "التصحيح" (الأمر ليس ما هو عليه، ولكن منذ Math.Round هو Lossy - يمكنك التحقق من ذلك على JSfiddle.net - هذه هي الطريقة الوحيدة التي عرفتها كيف "إصلاح " هو - هي). يضيف 0.001 إلى الرقم المبطن بالفعل، لذلك يضيف 1 ثلاثة 0S إلى يمين القيمة العشرية. لذلك يجب أن تكون آمنة للاستخدام.

بعد ذلك أضيفت .toFixed(decimal) لإخراج الرقم دائما بالتنسيق الصحيح (مع الكمية المناسبة من الكسور العشرية).

هذا إلى حد كبير. استخدمه جيدا ؛)

تحرير: وظيفة إضافية إلى "تصحيح" الأرقام السالبة.

Answer 5

طريقة واحدة لتكون متأكدا 100٪ أن تحصل على رقم مع 2 عشرات:

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

إذا كان هذا يؤدي أخطاء التقريب، فيمكنك استخدام ما يلي كما أوضح جيمس في تعليقه:

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

Answer 6

TOFIXED (N) يوفر طول N بعد النقطة العشرية؛ Toprecision (X) يوفر طول 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);

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

Answer 8

لقد قمت أنا وheridev بإنشاء وظيفة صغيرة في jQuery.

يمكنك تجربة التالي:

لغة البرمجة

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

مسج

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

Answer 9

إليك واحدة بسيطة

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 10

المشكلة مع قيم النقطة العائمة هي أنهم يحاولون تمثيل كمية لا حصر لها من القيم (المستمرة) مع كمية ثابتة من البتات. بطبيعة الحال، يجب أن يكون هناك بعض الخسارة في اللعب، وسوف تتعرض للعض مع بعض القيم.

عندما يقوم جهاز كمبيوتر بمخازن 1.275 كقيمة نقطة عائمة، لن يتذكر ذلك فعليا ما إذا كان 1.275 أو 1.2749999999999999999999999999993، أو حتى 1.27500000000000002. يجب أن تعطي هذه القيم نتائج مختلفة بعد التقريب إلى عشريتين، لكنها لن تكون، منذ أن تبدو الكمبيوتر بالضبط نفس الشيء بعد التخزين كقيم نقطة عائمة، وليس هناك طريقة لاستعادة البيانات المفقودة. لن تتراكم أي حسابات أخرى هذه غير دقيقة.

لذلك، إذا أمور الدقة، عليك تجنب قيم النقطة العائمة من البداية. أبسط الخيارات هي

• إستخدم مكتبة مخصصة
• استخدام سلاسل التخزين والتمرير حول القيم (مصحوبة بعمليات السلسلة)
• استخدام الأعداد الصحيحة (على سبيل المثال، يمكن أن تمر بمقدار مائة مئات من قيمتك الفعلية، مثل المبلغ في سنتات بدلا من المبلغ بالدولار)

على سبيل المثال، عند استخدام الأعداد الصحيحة لتخزين عدد المئات، فإن وظيفة العثور على القيمة الفعلية بسيطة للغاية:

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));

لاحظ أن هذه الوظيفة تولد إلى الأقرب، العلاقات بعيدا عن الصفر, ، في حين IEEE 754. يوصي تقريب إلى الأقرب، العلاقات حتى كسلوك افتراضي لعمليات النقطة العائمة. تترك هذه التعديلات بمثابة تمرين للقارئ :)

Answer 11

جولة القيمة العشرية الخاصة بك، ثم استخدام toFixed(x) من أجل رقم (ق) المتوقع.

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

---

يتصل

parsedechimalroundandafixed (10.800243929،4) => 10.80.80 parsedecimalroundandfixed (10.807243929،2) => 10.81

Answer 12

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

هنا هو الحل 1 خطي: Number((yourNumericValueHere).toFixed(2));

إليك ما يحدث:

1) أولا، تطبق .toFixed(2) على الرقم الذي تريد تقريبه من الأماكن العشرية. لاحظ أن هذا سيؤدي إلى تحويل القيمة إلى سلسلة من الرقم. لذلك إذا كنت تستخدم Disscript، فسيتم إلقاء خطأ مثل هذا:

"نوع" السلسلة "غير قابلة للتسوية لكتابة" عدد ""

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 14

وضع ما يلي في بعض النطاق العالمي:

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) قد تولد خطأ JavaScript، لذلك لاستيعاب أنك قد تضيف بعض الاختيار الإضافي IE

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

Answer 15

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

سيعود هذا عددا عشوائيا من 1 إلى 100 تقريب إلى 2 منازل عشرية.

Answer 16

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

هذا عملت بالنسبة لي: تقريب الكسور العشرية في جافا سكريبت

Answer 17

باستخدام هذا الاستجابة حسب المرجع: 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 18

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 19

المستدير لأسفل

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 20

مع هذه الأمثلة، ما زلت تحصل على خطأ عند محاولة جولة الرقم 1.005، الحل هو إما استخدام مكتبة مثل Math.js أو هذه الوظيفة:

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)
}

نظرا لأن TOFIXED () لا يمكن استدعاؤه إلا بالأرقام، وللأسف إرجاع سلسلة، فهذا يقوم بهذا التحليل لك في كلا الاتجاهين. يمكنك اجتياز سلسلة أو رقم، وحصلت على رقم مرة أخرى في كل مرة! سيعطيك الاتصال بموجب المقارنة (1.49) 1، وسوف تعطيك المقرنات (1.49،2) 1.50. تماما مثل أفضل ما!

Answer 26

يمكنك أيضا استخدام .toPrecision() الطريقة وبعض التعليمات البرمجية المخصصة، وقرولة دائما إلى الرقم العشري Nth بغض النظر عن طول الجزء الدولي.

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;

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>