Hoe rond je af op 1 decimaal in Javascript?

Kun je een getal in javascript afronden op 1 teken achter de komma (goed afgerond)?

Ik heb de *10, round, /10 geprobeerd, maar er blijven twee decimalen achter aan het einde van de int.

Antwoord 1, autoriteit 100%

Math.round(num * 10) / 10werkt, hier is een voorbeeld…

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

als je wilt dat het één cijfer achter de komma heeft, zelfs als dat een 0 zou zijn, voeg dan toe…

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!
// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros
// So, just make sure it is the last step before output,
// and use a number format during calculations!

EDIT: Ronde toevoegen met precisiefunctie…

Met dit principe als referentie, is hier een handige kleine ronde functie die precisie vereist…

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

… gebruik …

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

… wordt standaard afgerond op het dichtstbijzijnde gehele getal (precisie 0) …

round(12345.6789) // 12346

… en kan worden gebruikt om af te ronden naar de dichtstbijzijnde 10 of 100 enz…

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

… en correct omgaan met negatieve getallen …

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

… en kan worden gecombineerd met toFixed om consistent op te maken als string …

round(456.7, 2).toFixed(2) // "456.70"

Antwoord 2, autoriteit 13%

var number = 123.456;
console.log(number.toFixed(1)); // should round to 123.5

Antwoord 3, autoriteit 4%

Als u Math.round(5.01)gebruikt, krijgt u 5in plaats van 5.0.

Als je toFixedgebruikt, kom je afrondingproblemen.

Als je het beste van twee werelden wilt, combineer dan de twee:

(Math.round(5.01 * 10) / 10).toFixed(1)

Misschien wil je hiervoor een functie maken:

function roundedToFixed(input, digits){
  var rounded = Math.pow(10, digits);
  return (Math.round(input * rounded) / rounded).toFixed(digits);
}

Antwoord 4, autoriteit 3%

lodashheeft een roundmethode:

_.round(4.006);
// => 4
_.round(4.006, 2);
// => 4.01
_.round(4060, -2);
// => 4100

Documenten.

Bron.

Antwoord 5

Ik stem voor toFixed(), maar voor de goede orde, hier is een andere manier die bitverschuiving gebruikt om het getal naar een int te casten. Het rondt dus altijd af naar nul (naar beneden voor positieve getallen, naar boven voor negatieven).

var rounded = ((num * 10) << 0) * 0.1;

Maar goed, aangezien er geen functie-aanroepen zijn, is het erg snel. 🙂

En hier is er een die string-matching gebruikt:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

Ik raad het gebruik van de tekenreeksvariant niet aan, zeg het maar.

Antwoord 6

Probeer dit:

var original=28.453
// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45
// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5
// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

minder ingewikkeld en gemakkelijker te implementeren…

Hiermee kun je een functie maken om te doen:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

Antwoord 7

Waarom niet gewoon

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3

1. toFixed:
   geeft een tekenreeks terug die het gegeven getal vertegenwoordigt met gebruik van vaste-kommanotatie.
2. Unary plus (+): De unaire plus-operator gaat vooraf aan zijn operand en evalueert naar zijn operand, maar probeert deze om te zetten in een getal, als dat nog niet het geval is.

Antwoord 8

ToPrecision-methode gebruiken:

var a = 1.2345
a.toPrecision(2)
// result "1.2"

Antwoord 9

var num = 34.7654;
num = Math.round(num * 10) / 10;
console.log(num); // Logs: 34.8

Antwoord 10

Om het beste antwoord te voltooien:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

Het invoerparameternummer mag “niet” altijd een getal zijn, in dit geval bestaat .toFixed niet.

Antwoord 11

ES 6-versie van geaccepteerd antwoord:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

Antwoord 12

Over het algemeen wordt decimale afronding gedaan door te schalen: round(num * p) / p

Naïeve implementatie

Als u de volgende functie gebruikt met halve cijfers, krijgt u ofwel de bovenste afgeronde waarde zoals verwacht, of de lagere afgeronde waarde, soms afhankelijk van de invoer.

Deze inconsistencyin afronding kan leiden tot moeilijk te detecteren bugs in de klantcode.

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)

var value = Math.round(234.567*100)/100

var value = Math.round(234.567*10)/10

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

str.slice(0, -1)

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1
function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01

Math.round( mul/count * 10 ) / 10
Math.round(Math.sqrt(sqD/y) * 10 ) / 10

function rnd(v,n=2) {
    return Math.round((v+Number.EPSILON)*Math.pow(10,n))/Math.pow(10,n)
}

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10
roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

function roundWithMaxPrecision (n, precision) {
    let precisionWithPow10 = Math.pow(10, precision);
    return Math.round(n * precisionWithPow10) / precisionWithPow10;
}

public static ToFixedRounded(decimalNumber: number, fractionDigits: number): number {
    var rounded = Math.pow(10, fractionDigits);
    return (Math.round(decimalNumber * rounded) / rounded).toFixed(fractionDigits) as unknown as number;
}