En JavaScript, lors de la conversion d'un flottant en une chaîne, comment puis-je obtenir seulement 2 chiffres après la virgule décimale? Par exemple, 0,34 au lieu de 0,3445434.
En JavaScript, lors de la conversion d'un flottant en une chaîne, comment puis-je obtenir seulement 2 chiffres après la virgule décimale? Par exemple, 0,34 au lieu de 0,3445434.
Réponses:
var result = Math.round(original*100)/100;
Les détails , au cas où le code ne serait pas explicite.
modifier: ... ou tout simplement utiliser toFixed
, comme proposé par Tim Büthe . Oublié celui-là, merci (et un vote positif) pour rappel :)
toFixed()
imitera ce que fait quelque chose printf()
en C. Cependant, toFixed()
et Math.round()
gérera l'arrondi différemment. Dans ce cas, toFixed()
aura le même type d'effet Math.floor()
(à condition de multiplier l'original par 10 ^ n au préalable et d'appeler toFixed()
avec n chiffres). La «justesse» de la réponse dépend beaucoup de ce que le PO souhaite ici, et les deux sont «correctes» à leur manière.
Il existe des fonctions pour arrondir les nombres. Par exemple:
var x = 5.0364342423;
print(x.toFixed(2));
imprimera 5.04.
EDIT: Fiddle
var x = 5.036432346; var y = x.toFixed(2) + 100;
y
sera égale"5.03100"
(0.335).toFixed(2) == 0.34 == (0.345).toFixed(2)
…
Soyez prudent lorsque vous utilisez toFixed()
:
Tout d'abord, l'arrondi du nombre est effectué à l'aide de la représentation binaire du nombre, ce qui peut entraîner un comportement inattendu. Par exemple
(0.595).toFixed(2) === '0.59'
au lieu de '0.6'
.
Deuxièmement, il y a un bogue IE avec toFixed()
. Dans IE (au moins jusqu'à la version 7, n'a pas vérifié IE8), ce qui suit est vrai:
(0.9).toFixed(0) === '0'
Il peut être judicieux de suivre la suggestion de kkyy ou d'utiliser une toFixed()
fonction personnalisée , par exemple
function toFixed(value, precision) {
var power = Math.pow(10, precision || 0);
return String(Math.round(value * power) / power);
}
.toFixed()
méthode native dans la valeur de retour, ce qui ajoutera la précision requise, par exemple: return (Math.round(value * power) / power).toFixed(precision);
et renverra également la valeur sous forme de chaîne. Sinon, la précision de 20 est ignorée pour les décimales plus petites
toFixed
: notez que l'augmentation de la précision peut donner des résultats inattendus:, (1.2).toFixed(16) === "1.2000000000000000"
tandis que (1.2).toFixed(17) === "1.19999999999999996"
(dans Firefox / Chrome; dans IE8, ce dernier ne tient pas en raison de la précision inférieure qu'IE8 peut offrir en interne).
(0.598).toFixed(2)
ne produit pas 0.6
. Il produit 0.60
:)
(0.335).toFixed(2) == 0.34 == (0.345).toFixed(2)
.
Un autre problème à prendre en compte est qu'il toFixed()
peut produire des zéros inutiles à la fin du nombre. Par exemple:
var x=(23-7.37)
x
15.629999999999999
x.toFixed(6)
"15.630000"
L'idée est de nettoyer la sortie en utilisant RegExp
:
function humanize(x){
return x.toFixed(6).replace(/\.?0*$/,'');
}
Le RegExp
correspond aux zéros de fin (et éventuellement le point décimal) pour s'assurer qu'il semble également bon pour les entiers.
humanize(23-7.37)
"15.63"
humanize(1200)
"1200"
humanize(1200.03)
"1200.03"
humanize(3/4)
"0.75"
humanize(4/3)
"1.333333"
var x = 0.3445434
x = Math.round (x*100) / 100 // this will make nice rounding
Il y a un problème avec toutes ces solutions flottant à l'aide de multiplicateurs. Malheureusement, les solutions de Kkyy et de Christoph sont fausses.
Veuillez tester votre code pour le numéro 551.175 avec 2 décimales - il arrondira à 551.17 alors qu'il devrait être 551.18 ! Mais si vous testez par ex. 451.175 ce sera ok - 451.18. Il est donc difficile de repérer cette erreur à première vue.
Le problème est avec la multiplication: essayez 551.175 * 100 = 55117.49999999999 (ups!)
Donc mon idée est de le traiter avec toFixed () avant d'utiliser Math.round ();
function roundFix(number, precision)
{
var multi = Math.pow(10, precision);
return Math.round( (number * multi).toFixed(precision + 1) ) / multi;
}
toFixed
est également affecté - (0.335).toFixed(2) == 0.34 == (0.345).toFixed(2)
… Quelle que soit la méthode utilisée, il vaut mieux ajouter un epsilon avant l'arrondi.
La clé ici, je suppose, consiste à arrondir correctement d'abord, puis vous pouvez le convertir en chaîne.
function roundOf(n, p) {
const n1 = n * Math.pow(10, p + 1);
const n2 = Math.floor(n1 / 10);
if (n1 >= (n2 * 10 + 5)) {
return (n2 + 1) / Math.pow(10, p);
}
return n2 / Math.pow(10, p);
}
// All edge cases listed in this thread
roundOf(95.345, 2); // 95.35
roundOf(95.344, 2); // 95.34
roundOf(5.0364342423, 2); // 5.04
roundOf(0.595, 2); // 0.60
roundOf(0.335, 2); // 0.34
roundOf(0.345, 2); // 0.35
roundOf(551.175, 2); // 551.18
roundOf(0.3445434, 2); // 0.34
Vous pouvez maintenant formater cette valeur en toute sécurité avec toFixed (p). Donc, avec votre cas spécifique:
roundOf(0.3445434, 2).toFixed(2); // 0.34
Si vous voulez la chaîne sans rond, vous pouvez utiliser ce RegEx (ce n'est peut-être pas le moyen le plus efficace ... mais c'est vraiment facile)
(2.34567778).toString().match(/\d+\.\d{2}/)[0]
// '2.34'
function trimNumber(num, len) {
const modulu_one = 1;
const start_numbers_float=2;
var int_part = Math.trunc(num);
var float_part = String(num % modulu_one);
float_part = float_part.slice(start_numbers_float, start_numbers_float+len);
return int_part+'.'+float_part;
}
return float_part ? int_part+'.'+float_part : int_part;
sinon , si vous avez passé entier, il est revenu avec un nombre de points à la fin (entrée exemple: 2100
, sortie: 2100.
)
Peut-être voudrez-vous également un séparateur décimal? Voici une fonction que je viens de faire:
function formatFloat(num,casasDec,sepDecimal,sepMilhar) {
if (num < 0)
{
num = -num;
sinal = -1;
} else
sinal = 1;
var resposta = "";
var part = "";
if (num != Math.floor(num)) // decimal values present
{
part = Math.round((num-Math.floor(num))*Math.pow(10,casasDec)).toString(); // transforms decimal part into integer (rounded)
while (part.length < casasDec)
part = '0'+part;
if (casasDec > 0)
{
resposta = sepDecimal+part;
num = Math.floor(num);
} else
num = Math.round(num);
} // end of decimal part
while (num > 0) // integer part
{
part = (num - Math.floor(num/1000)*1000).toString(); // part = three less significant digits
num = Math.floor(num/1000);
if (num > 0)
while (part.length < 3) // 123.023.123 if sepMilhar = '.'
part = '0'+part; // 023
resposta = part+resposta;
if (num > 0)
resposta = sepMilhar+resposta;
}
if (sinal < 0)
resposta = '-'+resposta;
return resposta;
}
Il n'y a aucun moyen d'éviter l'arrondissement incohérent des prix avec x.xx5 comme valeur réelle en utilisant soit la multiplication soit la division. Si vous devez calculer les prix corrects côté client, vous devez conserver tous les montants en cents. Cela est dû à la nature de la représentation interne des valeurs numériques en JavaScript. Notez qu'Excel souffre des mêmes problèmes afin que la plupart des gens ne remarquent pas les petites erreurs causées par ce phénomène. Cependant, des erreurs peuvent s'accumuler chaque fois que vous additionnez un grand nombre de valeurs calculées, il existe toute une théorie à ce sujet impliquant l'ordre des calculs et d'autres méthodes pour minimiser l'erreur dans le résultat final. Pour souligner les problèmes avec les valeurs décimales, veuillez noter que 0,1 + 0,2 n'est pas exactement égal à 0,3 en JavaScript, tandis que 1 + 2 est égal à 3.
/** don't spend 5 minutes, use my code **/
function prettyFloat(x,nbDec) {
if (!nbDec) nbDec = 100;
var a = Math.abs(x);
var e = Math.floor(a);
var d = Math.round((a-e)*nbDec); if (d == nbDec) { d=0; e++; }
var signStr = (x<0) ? "-" : " ";
var decStr = d.toString(); var tmp = 10; while(tmp<nbDec && d*tmp < nbDec) {decStr = "0"+decStr; tmp*=10;}
var eStr = e.toString();
return signStr+eStr+"."+decStr;
}
prettyFloat(0); // "0.00"
prettyFloat(-1); // "-1.00"
prettyFloat(-0.999); // "-1.00"
prettyFloat(0.5); // "0.50"
J'utilise ce code pour formater les flottants. Il est basé sur toPrecision()
mais il supprime les zéros inutiles. Je serais heureux de recevoir des suggestions sur la façon de simplifier l'expression rationnelle.
function round(x, n) {
var exp = Math.pow(10, n);
return Math.floor(x*exp + 0.5)/exp;
}
Exemple d'utilisation:
function test(x, n, d) {
var rounded = rnd(x, d);
var result = rounded.toPrecision(n);
result = result.replace(/\.?0*$/, '');
result = result.replace(/\.?0*e/, 'e');
result = result.replace('e+', 'e');
return result;
}
document.write(test(1.2000e45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2000e+45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2340e45, 3, 2) + '=' + '1.23e45' + '<br>');
document.write(test(1.2350e45, 3, 2) + '=' + '1.24e45' + '<br>');
document.write(test(1.0000, 3, 2) + '=' + '1' + '<br>');
document.write(test(1.0100, 3, 2) + '=' + '1.01' + '<br>');
document.write(test(1.2340, 4, 2) + '=' + '1.23' + '<br>');
document.write(test(1.2350, 4, 2) + '=' + '1.24' + '<br>');