Ik wil mijn getallen zo opmaken dat ze altijd 2 decimalen weergeven, met afronding indien van toepassing.

Voorbeelden:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

Ik heb dit gebruikt:

parseFloat(num).toFixed(2);

Maar het geeft 1weer als 1in plaats van 1.00.

Antwoord 1, autoriteit 100%

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

Livedemo

Antwoord 2, autoriteit 28%

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

Antwoord 3, autoriteit 9%

Dit antwoordmislukt als value = 1.005.

Als een betere oplossing kan het afrondingsprobleem worden vermeden door getallen te gebruiken die worden weergegeven in exponentiële notatie:

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

Schonere code zoals voorgesteld door @Kon en de oorspronkelijke auteur:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

U kunt aan het einde toFixed()toevoegen om de komma te behouden, bijvoorbeeld: 1.00maar houd er rekening mee dat het als tekenreeks zal terugkeren.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Tegoed: Decimalen afronden in JavaScript

Antwoord 4, autoriteit 4%

Gebruik voor moderne browsers toLocaleString:

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Geef een locale-tag op als eerste parameter om het decimaal scheidingstekente beheren. Gebruik voor een punt bijvoorbeeld de Engelse Amerikaanse landinstelling:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

wat geeft:

1.35

De meeste landen in Europa gebruiken een komma als decimaalteken, dus als je bijvoorbeeld Zweeds/Zweden gebruikt:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

het geeft:

1,35

Antwoord 5, autoriteit 2%

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

Antwoord 6, autoriteit 2%

Maak deze functie voor de meest nauwkeurige afronding:

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

en gebruik het om af te ronden op 2 decimalen:

console.log("seeked to " + round(1.005, 2));
> 1.01

Met dank aan Razu, ditartikel, en MDN’s Math.round-referentie.

Antwoord 7

Eenvoudigste antwoord:

var num = 1.2353453;
num.toFixed(2); // 1.24

Voorbeeld: http://jsfiddle.net/E2XU7/

Antwoord 8

Een veel algemenere oplossing voor het afronden naar N plaatsen

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}
console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))
Output
1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

Antwoord 9

var number = 123456.789;
console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/ docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Antwoord 10

Als je jQuery al gebruikt, kun je de gebruiken jQuery Number Formatplug-in.

De plug-in kan opgemaakte getallen retourneren als een tekenreeks, u kunt decimalen en scheidingstekens voor duizendtallen instellen en u kunt het aantal decimalen kiezen dat u wilt weergeven.

$.number( 123, 2 ); // Returns '123.00'

Je kunt ook jQuery Number Format van GitHubkrijgen.

Antwoord 11

Is dit wat je bedoelt?

[bewerk 20200530] Het antwoord @razu mitsis de beste imho. Dus hier is een enigszins aangepaste versie.

De code van het fragment retourneert nog steeds niet de juiste waarde voor iets als showAsFloat(2.3346)(resultaat 2.33, maar zou 2.34 moeten zijn). Dus zie ook.

const showAsFloat = (input, decimals = 2, asString = false) => {
  if (input === null || input.constructor === Boolean || isNaN(+input)) {
    return input;
  }
  const converted = +( `${Math.round( parseFloat( `${input}e${decimals}` )  )}e-${decimals}` );
  return asString ? converted.toFixed(decimals) : converted
};
document.querySelector('#result').textContent = [
  'command                      | result',
  '-----------------------------------------------',
  'showAsFloat(1);              | ' + showAsFloat(1),
  'showAsFloat(1.314);          | ' + showAsFloat(1.314),
  'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
  'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
  'showAsFloat(2456198, 5, true)| ' + showAsFloat('24568', 5, true),
  'showAsFloat(2456198, 5)      | ' + showAsFloat('24568', 5),
  'showAsFloat(0, 2, true);     | ' + showAsFloat(0, 2, true),
  'showAsFloat(1.345);          | ' + showAsFloat(1.345),
  'showAsFloat(0.005);          | ' + showAsFloat(0.005),
  'showAsFloat(null);           | ' + showAsFloat(null),
].join('\n');

<pre id="result"></pre>

var num = 5.56789;
var n = num.toFixed(2);

5.57

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

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}
console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

function numberFormat(val, decimalPlaces) {
    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

function number_format(string,decimals=2,decimal=',',thousands='.',pre='R$ ',pos=' Reais'){
  var numbers = string.toString().match(/\d+/g).join([]);
  numbers = numbers.padStart(decimals+1, "0");
  var splitNumbers = numbers.split("").reverse();
  var mask = '';
  splitNumbers.forEach(function(d,i){
    if (i == decimals) { mask = decimal + mask; }
    if (i>(decimals+1) && ((i-2)%(decimals+1))==0) { mask = thousands + mask; }
    mask = d + mask;
  });
  return pre + mask + pos;
}
var element = document.getElementById("format");
var money= number_format("10987654321",2,',','.');
element.innerHTML = money;

#format{
display:inline-block;
padding:10px;
border:1px solid #ddd;
background:#f5f5f5;
}

<div id='format'>Test 123456789</div>

Math.floor(num* 100 )/100;

function numberWithCommas(number) { 
   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);
   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

alert(parseFloat(1).toFixed(2))
var num = 2
document.getElementById('spanId').innerHTML = (parseFloat(num).toFixed(2) - 1)

<span id="spanId"></span>

var quantity = 12;
var import1 = 12.55;
var total = quantity * import1;
var answer = parseFloat(total).toFixed(2);
document.write(answer);

<input type="number" class="dec-number" min="0" step="0.01" />

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

var num1 = "0.1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);
var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);
var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

let toFix2 = (n) => n.replace(/(-?)(\d+)\.(\d\d)(\d+)/, (_,s,i,d,r)=> {
  let k= (+r[0]>=5)+ +d - (r==5 && s=='-');
  return s + (+i+(k>99)) + "." + ((k>99)?"00":(k>9?k:"0"+k));
})
// TESTs
console.log(toFix2("1"));
console.log(toFix2("1.341"));
console.log(toFix2("1.345"));
console.log(toFix2("1.005"));

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });
console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

function formatValeurDecimal(valeurAFormate,longueurPartieEntier,longueurPartieDecimal){
valeurAFormate = valeurAFormate.replace(",",".")
valeurAFormate = parseFloat(valeurAFormate).toFixed(longueurPartieDecimal)
if(valeurAFormate == 'NaN'){
    return 0
}
//____________________valeurPartieEntier__________________________________
var valeurPartieEntier = valeurAFormate | 0
var strValeur = valeurPartieEntier.toString()
strValeur = strValeur.substring(0, longueurPartieEntier)
valeurPartieEntier = strValeur
//____________________valeurPartieDecimal__________________________________
strValeur = valeurAFormate
strValeur = strValeur.substring(strValeur.indexOf('.')+1)
var valeurPartieDecimal = strValeur
valeurAFormate = valeurPartieEntier +'.'+valeurPartieDecimal
if(valeurAFormate == null){
    valeurAFormate = 0
}
return valeurAFormate

   function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(numberOfDigits));
        } catch (error) {
            return 0;
        }
    }
    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44
    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.5556