6
votes

Erreur d'arrondi de Math.round

Je veux arrondi 1.006 code> strong> à deux décimales en attendant 1.01 comme sortie

quand j'ai fait p> xxx pré>

De même, P>

var num = 1.045;
alert(num.toFixed(2)); //Outputs 1.04
alert(Math.round(num*100)/100); //Outputs 1.05


 est-il sans danger d'utiliser toofixed () à chaque fois?  li>
 est TOFIXED () Plainte de navigateur croisée?  LI>
 ul>  s'il vous plaît me suggérer.  P> 
 PS: J'ai essayé de rechercher un débordement de pile pour des réponses similaires, mais je n'ai pas pu obtenir une réponse appropriée.  P> 
   EDIT :  code>  strong>  p> 
 pourquoi   1.015  code>  strong> renvoie 1.01 où comme   1.045  code>  Strong> Retours 1.05  P> 
var num =1.015;
alert(num.toFixed(2)); //Outputs 1.01
alert(Math.round(num*100)/100); //Outputs 1.01

javascript math rounding

6 commentaires

Math.Round Des tours sur l'entier le plus proche.


                                        
                                                                            @Jrod: Si vous vous référez  Ce violon  IT génère également des valeurs décimales également
                                        
                                                                            @nlsbshtr: Merci de le pointer, pouvez-vous vérifier mon édition et m'aider à la deuxième question
                                        
                                                                            @Ssudarshan Votre édition doit faire avec le fait que certains nombres décimaux ne peuvent pas être représentés à une précision parfaite. Spécifiquement dans votre cas,  1.015 * 100  vous donne  101.4999999999999999  au lieu de  101.5 , ce qui le faisait arrondir au lieu de monter au lieu de monter.

                                        
                                                                            @jbabey: Merci pour votre commentaire, cela a résolu mon problème.
                                        
                                                                            @Ssudarshan Lorsque vous êtes multiple par 100, vous changez de tout. 1.006 x 100 = 100.6. 100.6 arrondi à l'entier le plus proche est 101. 101 divisé par 100 est de 1,01. La fonction ronde n'est pas émettant de décimales.



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Essayez quelque chose comme ...  xxx  
 de:  http://www.javascriptkit.com/javatus/round.shtml   
 (pour arrondi aucun nombre à x points décimaux)                                   

                                                                    
                                    
                                    
                                        7 commentaires
                                        
                                                                                            
                                                    Merci pour votre réponse, BTW Comment êtes-vous arrivé à 100 ans?                                                
                                                
                                                                                            
                                                    @Sudarshan 10 ^ x vous donne x points décimaux, 10 ^ 2 = 100 = 2 points décimaux.                                                
                                                
                                                                                            
                                                    @jbabey: Merci de votre réponse, pouvez-vous vérifier mon édition et m'expliquer quelle est la bonne approche pour l'arrondissement                                                
                                                
                                                                                            
                                                    @Ssudarshan au lieu de rond, vous pouvez utiliser le plafond ou le sol, le plafond pour se faire arrondir et le sol pour arrondi, c'est plus spécifique que rond                                                
                                                
                                                                                            
                                                    @Kark: Merci pour votre commentaire, il a fait le tour, merci beaucoup                                                
                                                
                                                                                            
                                                    @nlsbshtr: Cela semble être un problème avec  erreurs de point flottant .                                                
                                                
                                                                                            
                                                    Vous avez tort. Exemple: Math.Round (4.975 * 100) / 100 = 4.97 Quand il devrait être 4,98                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Je me rends compte que ce problème est plutôt vieux, mais je continue à courir même 5 ans après que la question a été posée. 
 Une solution de travail à ce problème d'arrondi, je connais consiste à convertir le numéro à une chaîne, à obtenir Le numéro de précision requis et l'arrondi de haut en bas à l'aide de règles mathématiques.  
 Un exemple où Math.Round fournit des arrondies inattendues et un exemple d'arrondi de cordes peut être trouvé dans le violon suivant:
 http://jsfiddle.net/shinigami84/vwx1yjnr/    xxx < /PREE >P>Math.Round ne fonctionne pas correctement ici car 0,145 multiplié par 100 est 14.4999999999999998, pas 14,5. Ainsi, Math.Round va arrondir comme s'il était 14.4. Si vous le convertissez en une chaîne et soustrayez le chiffre requis (5), alors arrondissez-le à l'aide de règles mathématiques standard, vous obtiendrez un résultat attendu de 0,15 (en réalité, 0,14 + 0,01 = 0,15000000000000002, utilisez «TOFIXED» pour obtenir un bon, rond résultat).                                  

                                                                    
                                    
                                    
                                        3 commentaires
                                        
                                                                                            
                                                    Je confirme que votre chemin fonctionne. Merci pour le partage. Cependant, je parie que ma solution est meilleure :)                                                
                                                
                                                                                            
                                                    Je suis désolé, mais votre solution ne fonctionne pas pour les nombres négatifs.                                                
                                                
                                                                                            
                                                    @Yevgeniyafanasyev a mis à jour le code pour travailler avec des nombres négatifs.                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Cette formule  math.Round (num * 100) / 100  code> n'est pas toujours bon. Exemple  XXX  PRE> 
 Ceci est faux, nous voulons que ce soit  0,15  code>  p> 
 
  Explication  forte>  P> 
 Le problème   strong> est que nous avons des flotteurs comme celui-là  p>  xxx  pré> 
  étape  fort>  p> 
 donc si Nous nous sommes arrondis, nous devons ajouter un peu à notre produit   code>.  p> 
 0,145 * 100 + 1e-14 = 14.500000000000009  p> 
 Je suppose que parfois le produit   code> peut être quelque chose comme  1.000000000000001  code>, mais Ce ne serait pas un problème si nous l'ajoutons, non?  p> 
  Étape deux  forte>  P> 
 Calculez combien devrions-nous ajouter?  P> 
 Nous savons que le float dans le script Java est de 17 chiffres.  p> 
let num = -0.145
let result = Math.round(num*100 + Math.sign(num)*0.1**(17-2-(Math.round(num*100)/100).toString().length))/100

                                

                                                                    
                                    
                                    
                                        0 commentaires