web-dev-qa-db-fra.com

Comment arrondis-tu à 1 décimale en Javascript?

Pouvez-vous arrondir un nombre en javascript à 1 caractère après le point décimal (correctement arrondi)?

J'ai essayé le * 10, round,/10 mais il reste deux décimales à la fin de l'int.

javascriptrounding
282
Walker

Math.round( num * 10) / 10 fonctionne, voici un exemple ...

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

si vous voulez qu'il ait une décimale, même si ce serait un 0, alors ajoutez ...

var fixed = rounded.toFixed(1);
// fixed is always to 1dp
// BUT: returns string!

// to get it 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: ajouter un tour avec fonction de précision ...

En utilisant ce principe, à titre de référence, voici une petite fonction pratique qui prend de la précision ...

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

... utilisation ...

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

... par défaut, arrondir au nombre entier le plus proche (précision 0) ...

round(12345.6789) // 12346

... et peut être utilisé pour arrondir à 10 ou 100 près ...

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

... et le traitement correct des nombres négatifs ...

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

... et peut être combiné avec toFixed pour formater de manière cohérente une chaîne ...

round(456.7, 2).toFixed(2) // "456.70"
566
Billy Moon
var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5
73
Pablo Fernandez

lodash a une méthode round:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

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

Docs .

La source .

22
Kevin Leary

Si vous utilisez Math.round(5.01), vous obtiendrez 5 au lieu de 5.0.

Si vous utilisez toFixed, vous rencontrez arrondi _ { problèmes .

Si vous voulez le meilleur des deux mondes, combinez les deux:

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

Vous voudrez peut-être créer une fonction pour cela:

function roundedToFixed(_float, _digits){
  var rounder = Math.pow(10, _digits);
  return (Math.round(_float * rounder) / rounder).toFixed(_digits);
}
21
Jasper de Vries

Je vote pour toFixed(), mais, aux fins du compte rendu, voici une autre façon d'utiliser le transfert de bits pour convertir le nombre en int. Donc, il arrondit toujours vers zéro (bas pour les nombres positifs, haut pour les négatifs).

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

Mais bon, puisqu'il n'y a pas d'appels de fonction, c'est rapide. :)

Et voici celui qui utilise la correspondance de chaîne:

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

Je ne recommande pas d'utiliser la variante de chaîne, juste sayin.

11
jimbojw

Essayez avec ceci:

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

moins compliqué et plus facile à mettre en œuvre ...

avec cela, vous pouvez créer une fonction à faire:

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


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

EDIT: voir ceci Comment arrondir avec ROUND HALF UP. Mode d'arrondi que la plupart d'entre nous ont appris à l'école primaire

6
atiruz

x = nombre, n = décimales:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}
4
super

Pour compléter la meilleure réponse:

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

Le numéro de paramètre d'entrée peut "pas" toujours être un nombre, dans ce cas, le fichier .toFixed n'existe pas. 

3
klodoma
var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8
3
Joseph Silber

ES 6 Version de la réponse acceptée:

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

Si votre méthode ne fonctionne pas, veuillez poster votre code.

Cependant, vous pouvez effectuer la tâche d’arrondir de la manière suivante:

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

Je vais vous donner 234,56

De même

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

Donnera 234,5

De cette manière, vous pouvez utiliser une variable à la place de la constante, comme indiqué ci-dessus.

2
venomrld

Petit filtre angulaire si quelqu'un le veut:

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

utiliser si via:

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

:)

1
sidonaldson

En général, l’arrondi se fait en mettant à l’échelle: round(num / p) * p

L'utilisation de la notation exponentielle gère correctement l'arrondi des nombres + v .. . Cependant, cette méthode ne parvient pas à arrondir correctement les cas-bord Edge.

function round(num, precision = 2) {
	var scaled = Math.round(num + "e" + precision);
	return Number(scaled + "e" + -precision);
}

// testing some Edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

Ici aussi, une fonction que j’ai écrite pour arrondir l’arithmétique, vous pouvez la tester vous-même.

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

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

1
Amr Ali

Cela semble fonctionner de manière fiable dans tout ce que je lance:

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

Comme il est arrondi, vous devrez peut-être le modifier selon le cas d'utilisation. Cela devrait fonctionner:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1
0
Ege Özcan

Pourquoi pas juste

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3
  1. toFixed : retourne une chaîne représentant le nombre donné en utilisant la notation à virgule fixe.
  2. Unary plus (+) : L'opérateur unary plus précède son opérande et en évalue l'opérande, mais tente de le convertir en nombre, s'il ne l'est pas déjà.
0
goulashsoup

Math.round( num * 10) / 10 ne fonctionne pas.

Par exemple, 1455581777.8-145558160.4 vous donne 1310023617.3999999.

Donc, utilisez uniquement num.toFixed(1)

0
P.W

Si vous voulez bien arrondir, alors:

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

Sinon, vous avez déjà une réponse des messages précédents

str.slice(0, -1)
0
jsNovice

J'en ai créé un qui retourne un type de nombre et ne place des décimales que si nécessaire (pas de 0).

Exemples:

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

Le code:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}
0
Alberto

J'ai trouvé un moyen d'éviter les problèmes de précision:

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
0
Lucas Montenegro
Math.round( mul/count * 10 ) / 10

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

Merci

0
roy neo