Formatting a number with exactly two decimals in JavaScript

Question

I have this line of code which rounds my numbers to two decimal places  But I get numbers like this  10 8  2 4  etc  These are not my idea of two decimal places so how I can improve the following   Math round price Math pow 10 2   Math pow 10 2     I want numbers like 10 80  2 40  etc  Use of jQuery is fine with me

User · Answer

Number   Math random     100    1  toFixed 2     this will return a random number from 1 to 100 rounded to 2 decimal places

User · Answer

x000D   x000D    Due to all told stuff  You may do 2 things for different purposes  x000D  When showing printing stuff use this in your alert innerHtml  contents  x000D  YourRebelNumber toFixed 2    x000D   x000D  var aNumber 9242 16  x000D  var YourRebelNumber aNumber-9000  x000D  alert YourRebelNumber   x000D  alert YourRebelNumber toFixed 2    x000D   x000D    and when comparing use  x000D  Number YourRebelNumber toFixed 2     x000D   x000D  if YourRebelNumber  242 16 alert  Not Rounded    x000D  if Number YourRebelNumber toFixed 2    242 16 alert  Rounded    x000D   x000D    Number will behave as you want in that moment  After that  it ll return to its defiance  x000D     x000D   x000D   x000D

User · Answer

I got some ideas from this post a few months back  but none of the answers here  nor answers from other posts blogs could handle all the scenarios  e g  negative numbers and some  lucky numbers  our tester found   In the end  our tester did not find any problem with this method below  Pasting a snippet of my code   fixPrecision  function  value        var me   this          nan   isNaN value           precision   me decimalPrecision       if  nan     value            return nan        value        else if   me allowDecimals    precision  lt   0            precision   0                1        return parseFloat Ext Number toFixed parseFloat value   precision        precision   precision    0      var negMultiplier   value  lt  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         I also have code comments  sorry i forgot all the details already    I m posting my answer here for future reference   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

User · Answer

This is an old topic but still top-ranked Google results and the solutions offered share the same floating point decimals issue  Here is the  very generic  function I use  thanks to 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   amp  amp  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        As we can see  we don t get these issues   round 1 275  2        Returns 1 28 round 1 27499  2      Returns 1 27   This genericity also provides some cool stuff   round 1234 5678  -2        Returns 1200 round 1 2345678e 2  2      Returns 123 46 round  123 45              Returns 123     Now  to answer the OP s question  one has to type   round 10 8034  2  toFixed 2      Returns  10 80  round 10 8  2  toFixed 2         Returns  10 80      Or  for a more concise  less generic function   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       You can call it with   round2Fixed 10 8034      Returns  10 80  round2Fixed 10 8         Returns  10 80      Various examples and tests  thanks to  t-j-crowder      x000D   x000D  function round value  exp    x000D    if  typeof exp      undefined      exp     0  x000D      return Math round value   x000D   x000D    value    value  x000D    exp    exp  x000D   x000D    if  isNaN value       typeof exp      number   amp  amp  exp   1     0   x000D      return NaN  x000D   x000D       Shift x000D    value   value toString   split  e    x000D    value   Math round   value 0     e     value 1      value 1    exp    exp     x000D   x000D       Shift back x000D    value   value toString   split  e    x000D    return   value 0     e     value 1      value 1  - exp    -exp    x000D    x000D  function naive value  exp    x000D    if   exp    x000D      return Math round value   x000D      x000D    var pow   Math pow 10  exp   x000D    return Math round value   pow    pow  x000D    x000D  function test val  places    x000D    subtest val  places   x000D    val   typeof val      string     -    val   -val  x000D    subtest val  places   x000D    x000D  function subtest val  places    x000D    var placesOrZero   places    0  x000D    var naiveResult   naive val  places   x000D    var roundResult   round val  places   x000D    if  placesOrZero  gt   0    x000D      naiveResult   naiveResult toFixed placesOrZero   x000D      roundResult   roundResult toFixed placesOrZero   x000D      else   x000D      naiveResult   naiveResult toString    x000D      roundResult   roundResult toString    x000D      x000D        lt tr gt    x000D       append     lt td gt    text JSON stringify val    x000D       append     lt td gt    text placesOrZero   x000D       append     lt td gt    text naiveResult   x000D       append     lt td gt    text roundResult   x000D       appendTo   results    x000D    x000D  test 0 565  2   x000D  test 0 575  2   x000D  test 0 585  2   x000D  test 1 275  2   x000D  test 1 27499  2   x000D  test 1234 5678  -2   x000D  test 1 2345678e 2  2   x000D  test  123 45    x000D  test 10 8034  2   x000D  test 10 8  2   x000D  test 1 005  2   x000D  test 1 0005  2   x000D  table   x000D    border-collapse  collapse  x000D    x000D  table  td  th   x000D    border  1px solid  ddd  x000D    x000D  td  th   x000D    padding  4px  x000D    x000D  th   x000D    font-weight  normal  x000D    font-family  sans-serif  x000D    x000D  td   x000D    font-family  monospace  x000D    x000D   lt table gt  x000D     lt thead gt  x000D       lt tr gt  x000D         lt th gt Input lt  th gt  x000D         lt th gt Places lt  th gt  x000D         lt th gt Naive lt  th gt  x000D         lt th gt Thorough lt  th gt  x000D       lt  tr gt  x000D     lt  thead gt  x000D     lt tbody id  results  gt  x000D     lt  tbody gt  x000D   lt  table gt  x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

Round down  function round down value  decPlaces        return Math floor value   Math pow 10  decPlaces     Math pow 10  decPlaces       Round up  function round up value  decPlaces        return Math ceil value   Math pow 10  decPlaces     Math pow 10  decPlaces       Round nearest  function round nearest value  decPlaces        return Math round value   Math pow 10  decPlaces     Math pow 10  decPlaces          Merged https   stackoverflow com a 7641824 1889449 and   https   www kirupa com html5 rounding numbers in javascript htm Thanks   them

User · Answer

100  working    Try it   x000D   x000D   lt html gt  x000D        lt head gt  x000D         lt script gt  x000D        function replacePonto    x000D          var input   document getElementById  qtd    x000D          var ponto   input value split      length  x000D          var slash   input value split  -   length  x000D          if  ponto  gt  2  x000D                  input value input value substr 0  input value length -1   x000D   x000D          if slash  gt  2  x000D                  input value input value substr 0  input value length -1   x000D   x000D          input value input value replace    0-9 -        x000D   x000D          if  ponto   2  x000D   input value input value substr 0  input value indexOf      3    x000D   x000D  if input value         x000D   input value       x000D                  x000D         lt  script gt  x000D         lt  head gt  x000D         lt body gt  x000D            lt input type  text  id  qtd  maxlength  10  style  width 140px  onkeyup  return replacePonto    gt  x000D         lt  body gt  x000D       lt  html gt  x000D   x000D   x000D

User · Answer

Here s a TypeScript implementation of https   stackoverflow com a 21323330 916734  It also dries things up with functions  and allows for a optional digit offset   export function round rawValue  number   string  precision   0  fractionDigitOffset   0   number   string     const value   Number rawValue     if  isNaN value   return rawValue     precision   Number precision     if  precision   1     0  return NaN     let   stringValue  exponent     scientificNotationToParts value      let shiftExponent   exponentForPrecision exponent  precision  Shift Right     const enlargedValue   toScientificNotation stringValue  shiftExponent     const roundedValue   Math round enlargedValue        stringValue  exponent     scientificNotationToParts roundedValue     const precisionWithOffset   precision   fractionDigitOffset    shiftExponent   exponentForPrecision exponent  precisionWithOffset  Shift Left      return toScientificNotation stringValue  shiftExponent      enum Shift     Left   -1    Right   1     function scientificNotationToParts value  number   Array lt string gt      const   stringValue  exponent     value toString   split  e      return   stringValue  exponent       function exponentForPrecision exponent  string  precision  number  shift  Shift   number     precision   shift   precision    return exponent    Number exponent    precision    precision     function toScientificNotation value  string  exponent  number   number     return Number    value e  exponent

User · Answer

This is very simple and works just as well as any of the others   function parseNumber val  decimalPlaces        if  decimalPlaces    null  decimalPlaces   0     var ret   Number val  toFixed decimalPlaces      return Number ret      Since toFixed   can only be called on numbers  and unfortunately returns a string  this does all the parsing for you in both directions   You can pass a string or a number  and you get a number back every time   Calling parseNumber 1 49  will give you 1  and parseNumber 1 49 2  will give you 1 50   Just like the best of  em

User · Answer

One way to be 100  sure that you get a number with 2 decimals     Math round num 100  100  toFixed 2    If this causes rounding errors  you can use the following as James has explained in his comment    Math round  num   1000  10  100  toFixed 2

User · Answer

Put the following in some global scope   Number prototype getDecimals   function   decDigCount        return this toFixed decDigCount       and then try   var a   56 23232323  a getDecimals 2      will return 56 23   Update  Note that toFixed   can only work for the number of decimals between 0-20 i e  a getDecimals 25  may generate a javascript error  so to accomodate that you may add some additional check i e   Number prototype getDecimals   function   decDigCount        return   decDigCount  gt  20     this   this toFixed decDigCount

User · Answer

I found a very simple way that solved this problem for me and can be used or adapted   td row  innerHTML   price toPrecision price toFixed decimals  length

User · Answer

You could also use the   toPrecision   method and some custom code  and always round up to the nth decimal digit regardless the length of int part   function glbfrmt  number  decimals  seperator        return typeof number      number    number   number toPrecision  number toString   split seperator  0  length   decimals       You could also make it a plugin for a better use

User · Answer

toFixed n  provides n length after the decimal point  toPrecision x    provides x total length    Use this method below     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   AND if you want the number to be fixed use  result   num toFixed 2

User · Answer

In general  decimal rounding is done by scaling  round num   p    p Naive implementation Using the following function with halfway numbers  you will get either the upper rounded value as expected  or the lower rounded value sometimes depending on the input  This inconsistency in rounding may introduce hard to detect bugs in the client code   x000D   x000D  function naiveRound num  decimalPlaces        var p   Math pow 10  decimalPlaces       return Math round num   p    p     console log  naiveRound 1 245  2         1 25 correct  rounded as expected  console log  naiveRound 1 255  2         1 25 incorrect  should be 1 26  x000D   x000D   x000D   Better implementations By converting the number to a string in the exponential notation  positive numbers are rounded as expected  But  be aware that negative numbers round differently than positive numbers  In fact  it performs what is basically equivalent to  quot round half up quot  as the rule  you will see that round -1 005  2  evaluates to -1 even though round 1 005  2  evaluates to 1 01  The lodash   round method uses this technique   x000D   x000D         Round half up   round half towards positive infinity      Uses exponential notation to avoid floating-point issues     Negative numbers round differently than positive numbers      function round num  decimalPlaces        num   Math round num    e    decimalPlaces       return Number num    e    -decimalPlaces         test rounding of half console log  round 0 5  0         1 console log  round -0 5  0        0     testing edge cases console log  round 1 005  2          1 01 console log  round 2 175  2          2 18 console log  round 5 015  2          5 02  console log  round -1 005  2         -1 console log  round -2 175  2         -2 17 console log  round -5 015  2         -5 01 x000D   x000D   x000D   If you want the usual behavior when rounding negative numbers  you would need to convert negative numbers to positive before calling Math round    and then convert them back to negative numbers before returning     Round half away from zero function round num  decimalPlaces        num   Math round Math abs num     quot e quot    decimalPlaces    Math sign num       return Number num    quot e quot    -decimalPlaces      There is a different purely mathematical technique to perform round-to-nearest  using  quot round half away from zero quot    in which epsilon correction is applied before calling the rounding function  Simply  we add the smallest possible float value    1 0 ulp  unit in the last place  to the number before rounding  This moves to the next representable value after the number  away from zero   x000D   x000D         Round half away from zero   commercial  rounding     Uses correction to offset floating-point inaccuracies     Works symmetrically for positive and negative numbers      function round num  decimalPlaces        var p   Math pow 10  decimalPlaces       var e   Number EPSILON   num   p      return Math round  num   p    e    p        test rounding of half console log  round 0 5  0         1 console log  round -0 5  0        -1     testing edge cases console log  round 1 005  2         1 01 console log  round 2 175  2         2 18 console log  round 5 015  2         5 02  console log  round -1 005  2        -1 01 console log  round -2 175  2        -2 18 console log  round -5 015  2        -5 02 x000D   x000D   x000D   This is needed to offset the implicit round-off error that may occur during encoding of decimal numbers  particularly those  having  quot 5 quot  in the last decimal position  like 1 005  2 675 and 16 235  Actually  1 005 in decimal system is encoded to 1 0049999999999999 in 64-bit binary float  while  1234567 005 in decimal system is encoded to 1234567 0049999998882413 in 64-bit binary float  It is worth noting that the maximum binary round-off error is dependent upon  1  the magnitude of the number and  2  the relative machine epsilon  2 -52

User · Answer

I don t know why can t I add a comment to a previous answer  maybe I m hopelessly blind  I don t know   but I came up with a solution using  Miguel s answer  function precise round num decimals       return Math round num Math pow 10  decimals     Math pow 10  decimals      And its two comments  from  bighostkim and  Imre    Problem with precise round 1 275 2  not returning 1 28 Problem with precise round 6 2  not returning 6 00  as he wanted    My final solution is as follows  function precise round num decimals        var sign   num  gt   0   1   -1      return  Math round  num Math pow 10 decimals      sign 0 001     Math pow 10 decimals   toFixed decimals      As you can see I had to add a little bit of  quot correction quot   it s not what it is  but since Math round is lossy - you can check it on jsfiddle net - this is the only way I knew how to  quot fix quot  it   It adds 0 001 to the already padded number  so it is adding a 1 three 0s to the right of the decimal value  So it should be safe to use  After that I added  toFixed decimal  to always output the number in the correct format  with the right amount of decimals   So that s pretty much it  Use it well    EDIT  added functionality to the  quot correction quot  of negative numbers

User · Answer

Round your decimal value  then use toFixed x  for your expected digit s    function parseDecimalRoundAndFixed num dec     var d    Math pow 10 dec     return  Math round num   d    d  toFixed dec         Call  parseDecimalRoundAndFixed 10 800243929 4       10 80 parseDecimalRoundAndFixed 10 807243929 2       10 81

User · Answer

heridev and I created a small function in jQuery   You can try next   HTML   lt input type  text  name  one  class  two-digits  gt  lt br gt   lt input type  text  name  two  class  two-digits  gt     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  gt  2                                   if  isNaN  parseFloat  this value       return                  this value   parseFloat this value  toFixed 2                                                   return this    for chaining                 DEMO ONLINE   http   jsfiddle net c4Wqn

User · Answer

I didn t find an accurate solution for this problem  so I created my own   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   gt  -342 06     if fraction    -0 5  fraction   -0 6       val   Math round parseInt val    fraction    Math pow 10  decPlaces       return val      Examples    x000D   x000D  function inprecise round value  decPlaces    x000D    return Math round value   Math pow 10  decPlaces     Math pow 10  decPlaces   x000D    x000D   x000D  function precise round value  decPlaces    x000D    var val   value   Math pow 10  decPlaces   x000D    var fraction    Math round  val - parseInt val     10    10   x000D   x000D      this line is for consistency with  NET Decimal Round behavior x000D       -342 055   gt  -342 06 x000D    if  fraction    -0 5  fraction   -0 6  x000D   x000D    val   Math round parseInt val    fraction    Math pow 10  decPlaces   x000D    return val  x000D    x000D   x000D     This may produce different results depending on the browser environment x000D  console log  342 055 toFixed 2              342 055 toFixed 2       342 06 on Chrome  amp  IE10 x000D   x000D  console log  inprecise round 342 055  2     inprecise round 342 055  2       342 05 x000D  console log  precise round 342 055  2       precise round 342 055  2         342 06 x000D  console log  precise round -342 055  2      precise round -342 055  2        -342 06 x000D   x000D  console log  inprecise round 0 565  2       inprecise round 0 565  2         0 56 x000D  console log  precise round 0 565  2         precise round 0 565  2           0 57 x000D   x000D   x000D

User · Answer

I usually add this to my personal library  and after some suggestions and using the  TIMINeutron solution too  and making it adaptable for decimal length then  this one fits best    function precise round num  decimals       var t   Math pow 10  decimals         return  Math round  num   t     decimals gt 0 1 0   Math sign num     10   Math pow 100  decimals       t  toFixed decimals       will work for the exceptions reported

User · Answer

Math round  10 2  100  100  toFixed 2    That should yield  10 20   Math round   05  100  100  toFixed 2    That should yield  0 05   Math round  4 04  100  100  toFixed 2    That should yield  4 04  etc

User · Answer

The trouble with floating point values is that they are trying to represent an infinite amount of  continuous  values with a fixed amount of bits  So naturally  there must be some loss in play  and you re going to be bitten with some values   When a computer stores 1 275 as a floating point value  it won t actually remember whether it was 1 275 or 1 27499999999999993  or even 1 27500000000000002  These values should give different results after rounding to two decimals  but they won t  since for computer they look exactly the same after storing as floating point values  and there s no way to restore the lost data  Any further calculations will only accumulate such imprecision   So  if precision matters  you have to avoid floating point values from the start  The simplest options are to   use a devoted library use strings for storing and passing around the values  accompanied by string operations  use integers  e g  you could be passing around the amount of hundredths of your actual value  e g  amount in cents instead of amount in dollars    For example  when using integers to store the number of hundredths  the function for finding the actual value is quite simple   function descale num  decimals        var hasMinus   num  lt  0      var numString   Math abs num  toString        var precedingZeroes           for  var i   numString length  i  lt   decimals  i              precedingZeroes     0             numString   precedingZeroes   numString      return  hasMinus    -                   numString substr 0  numString length-decimals                            numString substr numString length-decimals      alert descale 127  2      With strings  you ll need rounding  but it s still manageable   function precise round num  decimals        var parts   num split           var hasMinus   parts length  gt  0  amp  amp  parts 0  length  gt  0  amp  amp  parts 0  charAt 0      -       var integralPart   parts length    0    0     hasMinus   parts 0  substr 1    parts 0        var decimalPart   parts length  gt  1   parts 1            if  decimalPart length  gt  decimals            var roundOffNumber   decimalPart charAt decimals           decimalPart   decimalPart substr 0  decimals           if   56789  indexOf roundOffNumber   gt  -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  gt  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  lt  decimals  i                  decimalPart     0                       return  hasMinus    -          integralPart    decimals  gt  0         decimalPart           alert precise round  1 275   2    alert precise round  1 27499999999999993   2      Note that this function rounds to nearest  ties away from zero  while IEEE 754 recommends rounding to nearest  ties to even as the default behavior for floating point operations  Such modifications are left as an exercise for the reader

User · Answer

Number Math round 1 005  e2    e-2       1 01   This worked for me  Rounding Decimals in JavaScript

User · Answer

Here is my 1-line solution  Number  yourNumericValueHere  toFixed 2     Here s what happens   1  First  you apply  toFixed 2  onto the number that you want to round off the decimal places of  Note that this will convert the value to a string from number  So if you are using Typescript  it will throw an error like this     Type  string  is not assignable to type  number    2  To get back the numeric value or to convert the string to numeric value  simply apply the Number   function on that so-called  string  value   For clarification  look at the example below   EXAMPLE  I have an amount that has upto 5 digits in the decimal places and I would like to shorten it to upto 2 decimal places  I do it like so    x000D   x000D  var price   0 26453  x000D  var priceRounded   Number  price  toFixed 2    x000D  console log  Original Price      price   x000D  console log  Price Rounded      priceRounded   x000D   x000D   x000D

User · Answer

Here s a simple one  function roundFloat num dec       var d   1      for  var i 0  i lt dec  i             d     0             return Math round num   d    d      Use like alert roundFloat 1 79209243929 4     Jsfiddle

User · Answer

Using this response by reference  https   stackoverflow com a 21029698 454827  I build a function to get dynamic numbers of decimals   function toDec num  dec            if typeof dec   undefined     dec lt 0                  dec   2           var tmp   dec   1          for var i 1  i lt  tmp  i                    num   num   10           num   num   10          num   Math round num           for var i 1  i lt  dec  i                    num   num   10           num   num toFixed dec            return num      here working example  https   jsfiddle net wpxLduLc

User · Answer

FAST AND EASY parseFloat number toFixed 2    Example let number   2 55435930  let roundedString   number toFixed 2         quot 2 55 quot   let twoDecimalsNumber   parseFloat roundedString        2 55  let directly   parseFloat number toFixed 2         2 55

User · Answer

With these examples you will still get an error when trying to round the number 1 005 the solution is to either use a library like Math js or this function   function round value  number  decimals  number        return Number Math round value    e    decimals     e-    decimals

User · Answer

x000D   x000D  parse   function  data    x000D         data   Math round data Math pow 10 2   Math pow 10 2   x000D         if  data    null    x000D              var lastone   data toString   split     pop    x000D              if  lastone           x000D                   data   parseFloat data   x000D                x000D           x000D         return data  x000D       x000D   x000D      result   html parse 200       output 200 x000D      result1   html parse 200 1       output 200 1 x000D      result2   html parse 200 10       output 200 1 x000D      result3   html parse 200 109       output 200 11 x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 0 0 jquery min js  gt  lt  script gt  x000D   lt div id  result  gt  lt  div gt  x000D   lt div id  result1  gt  lt  div gt  x000D   lt div id  result2  gt  lt  div gt  x000D   lt div id  result3  gt  lt  div gt  x000D   x000D   x000D

User · Answer

I m fix the problem the modifier  Support 2 decimal only    x000D   x000D    function    x000D      input number only  x000D    convertNumberFloatZero 22      output   22 00 x000D    convertNumberFloatZero 22 5      output   22 50 x000D    convertNumberFloatZero 22 55      output   22 55 x000D    convertNumberFloatZero 22 556      output   22 56 x000D    convertNumberFloatZero 22 555      output   22 55 x000D    convertNumberFloatZero 22 5541      output   22 54 x000D    convertNumberFloatZero 22222 5541      output   22 222 54 x000D   x000D    function convertNumberFloatZero number   x000D   if    isNumeric number    x000D    return  NaN   x000D     x000D   var numberFloat   number toFixed 3   x000D   var splitNumber   numberFloat split       x000D   var cNumberFloat   number toFixed 2   x000D   var cNsplitNumber   cNumberFloat split       x000D   var lastChar   splitNumber 1  substr splitNumber 1  length - 1   x000D   if lastChar  gt  0  amp  amp  lastChar  lt  5   x000D    cNsplitNumber 1 --  x000D     x000D   return Number splitNumber 0   toLocaleString  en   concat      concat cNsplitNumber 1    x000D       x000D      x000D   lt script src  https   ajax googleapis com ajax libs jquery 1 9 1 jquery min js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

To format a number using fixed-point notation  you can simply use the toFixed method   10 8  toFixed 2       quot 10 80 quot   var num   2 4  alert num toFixed 2        quot 2 40 quot   Note that toFixed   returns a string  IMPORTANT  Note that toFixed does not round 90  of the time  it will return the rounded value  but for many cases  it doesn t work  For instance  2 005 toFixed 2       quot 2 00 quot  UPDATE  Nowadays  you can use the Intl NumberFormat constructor  It s part of the ECMAScript Internationalization API Specification  ECMA402   It has pretty good browser support  including even IE11  and it is fully supported in Node js   x000D   x000D  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  x000D   x000D   x000D   You can alternatively use the toLocaleString method  which internally will use the Intl API   x000D   x000D  const format    num  decimals    gt  num toLocaleString  en-US        minimumFractionDigits  2           maximumFractionDigits  2        console log format 2 005        2 01  console log format 1 345        1 35  x000D   x000D   x000D   This API also provides you a wide variety of options to format  like thousand separators  currency symbols  etc

[javascript] Formatting a number with exactly two decimals in JavaScript

Examples related to javascript

Examples related to rounding

Examples related to decimal-point