Comment arrondissez-vous à 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, rond, / 10 mais ça laisse deux décimales à la fin de l'int.

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 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: Ajouter un rond avec une fonction de précision ...

En utilisant ce principe, pour référence, voici une petite fonction ronde 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 au 10 ou 100 le plus proche, etc. ...

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

... et 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 sous forme de chaîne ...

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

var number = 123.456;

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

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

Si vous utilisez, toFixedvous rencontrez des problèmes d' arrondi .

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 rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}

lodasha une roundméthode:

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

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

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

Docs .

Source .

Je vote pour toFixed(), mais, pour mémoire, voici une autre façon qui utilise le décalage de bits pour convertir le nombre en entier. Donc, il arrondit toujours vers zéro (vers le bas pour les nombres positifs, vers le 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 méchant vite. :)

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

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

Je ne recommande pas d'utiliser la variante de chaîne, disons simplement.

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 pour 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 ce Comment arrondir à l'aide de ROUND HALF UP. Mode d'arrondi que la plupart d'entre nous ont appris à l'école primaire

x = nombre, n = décimales:

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

Pourquoi pas

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

1. toFixed : retourne une chaîne représentant le nombre donné en utilisant une notation à virgule fixe.
2. Unaire plus (+) : l'opérateur unaire plus précède son opérande et évalue son opérande mais tente de le convertir en nombre, s'il ne l'est pas déjà.

var num = 34.7654;

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

console.log(num); // Logs: 34.8

Pour compléter la meilleure réponse:

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

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

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

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

Utilisation de la méthode toPrecision:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

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

Cependant, vous pouvez accomplir la tâche d'arrondi comme suit:

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

Vous donnera 234,56

De même

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

Donnera 234,5

De cette façon, vous pouvez utiliser une variable à la place de la constante comme utilisé ci-dessus.

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

:)

En général, l'arrondi se fait par mise à l'échelle: round(num / p) * p

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

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, est également une fonction que j'ai écrite pour effectuer l'arrondi arithmétique, vous pouvez le 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

Cela semble fonctionner de manière fiable sur tout ce que je lui 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));
}

Il arrondit, vous devrez donc peut-être le modifier en fonction du cas d'utilisation. Cela devrait fonctionner:

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

Si vous vous souciez d'arrondir correctement, alors:

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

Sinon, si vous ne l'avez pas, vous avez déjà une réponse des messages précédents

str.slice(0, -1)

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

Par exemple, 1455581777.8-145558160.4vous donne 1310023617.3999999.

Alors n'utilisez que num.toFixed(1)

J'en ai fait un qui renvoie le type de nombre et place également des décimales uniquement si nécessaire (pas de remplissage 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);
}

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

Math.round( mul/count * 10 ) / 10

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

Merci