JavaScript: arrondi à un nombre de décimales, mais bande de zéros supplémentaires

Voici le scénario: je suis .9999999999999999 quand je devrais être en train de 1.0.

Je peux me permettre de perdre un nombre de décimales de précision, donc je suis en utilisant .toFixed(15), le type de travaux.

L'arrondi fonctionne, mais le problème est que je me suis donné 1.000000000000000.

Est-il un moyen pour arrondir à un nombre de décimales, mais la bande supplémentaire espaces?

Remarque: .toPrecision n'est pas ce que je veux; je veux seulement pour spécifier le nombre de chiffres après le point décimal.

Note 2: je ne peut pas utiliser de .toPrecision(1) parce que j'ai besoin de garder la haute précision pour les nombres qui ont réellement des données après le point décimal. Idéalement, il serait exactement autant de décimales que nécessaire (jusqu'à 15).

Le point étant que .toFixed retourne une Chaîne de caractères, donc il suffit d'aller-retour via un Numéro et ensuite revenir à une Chaîne de reconvertir sans les zéros de fin.
juste pour avoir des précisions. Voulez-vous simplement à supprimer les zéros à droite dans la chaîne de caractères que vous avez obtenu avec toFixed()?

InformationsquelleAutor Nathan | 2011-09-05

131
```
>>> parseFloat(0.9999999.toFixed(4));
1
>>> parseFloat(0.0009999999.toFixed(4));
0.001
>>> parseFloat(0.0000009999999.toFixed(4));
0
```
- N'oubliez pas de mettre entre parenthèses lorsque vous traitez les nombres négatifs: -2.34.toFixed(1) retourne -2.3 en raison de la la priorité de l'opérateur.
- À l'aide de l'unaire + opérateur doit être plus rapide que la parseFloat fonction: +number.toFixed(13) Cette expression peut également être utilisé pour supprimer le JavaScript nombre d'inexactitudes comme dans 1.0000000000000045.
InformationsquelleAutor Gus
32

Oui, il y a un moyen. Utilisation parseFloat().
```
parseFloat((1.005).toFixed(15)) //==> 1.005
parseFloat((1.000000000).toFixed(15)) //==> 1
```
Voir un exemple ici: http://jsfiddle.net/nayish/7JBJw/
- Ne fonctionne pas pour parseFloat("0.0000007"), qui donne "7e-7"
InformationsquelleAutor Nayish
18

Que je comprends, vous voulez supprimer les zéros à droite dans la chaîne de caractères que vous avez obtenu via toFixed(). C'est une pure opération de chaîne:
```
var x = 1.1230000;
var y = x.toFixed(15).replace(/0+$/, "");  //==> 1.123
```
- Vous êtes le seul qui a vraiment répondu à la question.. merci!
- Cela laisse le point sur les chiffres ronds ("100.00" => "100.")
- si vous ne voulez pas le point, vous pouvez l'inclure dans l'expression régulière pour être remplacé (...replace(/\.?0+$/, "");).
- Qui échoue sur 0 et -0, car 0 devient la chaîne vide "", et -0 devient -, ni de ce qui est prévu (au jugé). @zach-neige de votre solution proposée également échoue sur 0 et -0.
- quel était le problème avec Gus réponse?
- Je ne me souviens pas vraiment comme il l'était il y a deux ans. Mais juste pour l'exemple, de Gus réponse arrondie au nombre, et ce n'était pas l'opération demandée
- si je lis le droit de la question, en arrondissant ce nombre est exactement ce que l'OP voulait. Il voulait tour à un certain nombre de chiffres après la virgule, ce qui n'est pas possible avec les fonctions intégrées. Cette réponse fait la même chose.
- Je m'excuse, je n'essaie pas de bash vous ou quoi que ce soit, juste d'essayer de comprendre pourquoi vous avez pensé que c'était la seule réponse adéquate, quels sont les pièges, etc. vous avez trouvé dans les autres. Si vous vous souvenez, je vous serais reconnaissant, mais si non, c'est pas une grosse affaire.
- href="https://stackoverflow.com/a/7312534/1899424">Gus réponse produit d'un nombre à virgule flottante. L'OP a demandé une chaîne de caractères, qui cette réponse produit.
InformationsquelleAutor Jiri Kriz
9

Number(n.toFixed(15)) or +(n.toFixed(15)) vous permet de convertir le 15, place une chaîne décimale d'un nombre, la suppression des zéros à la fin.
- Je pensais que je serais le montrer, +(n.toFixed(...)) est beaucoup plus efficace que parseFloat. Je ne sais pas pourquoi, mais il est également plus efficace que le Nombre de Chrome.
InformationsquelleAutor kennebec
6

Si vous lancez la valeur de retour pour un certain nombre, ceux des zéros à la fin sera abandonné. C'est également la moins bavarde que parseFloat() est.
```
+(4.55555).toFixed(2);
//-> 4.56

+(4).toFixed(2);
//-> 4
```
Il utilise le unaire + opérateur, donc si vous utilisez ce dans le cadre d'une opération de chaîne, vous devez avoir un infixe + avant: var n=0.9999999999999999; console.log('output ' + +n.toFixed(2));. Pour info unaire + en face d'une chaîne de caractères convertit en Nombre. De MDN: Unaire + peut:

convertir des représentations de chaîne de nombres entiers et décimaux, ainsi
comme le non-chaîne de valeurs true, false et null. Entiers dans les deux
décimal et hexadécimal ("0x"préfixe) formats pris en charge.
Les nombres négatifs sont pris en charge (mais pas pour hex). Si elle ne peut pas
analyser une valeur particulière, il va évaluer à NaN.
- Je viens de faire une vérification simple; +(4.1).toFixed(4) est 4.1 dans Chrome 60.
- Je n'ai pas l'obtenir. Quelle était la raison pourquoi cette réponse a obtenu downvoted?
- Vous aviez raison j'ai donc supprimé mon commentaire précédent et ajouté à la réponse (je pense que j'ai été en utilisant infix + avec une chaîne de caractères sur la gauche, plutôt que d'utiliser correctement unaire +. Habituellement, je suis plus prudent! Cheers)
- Cette réponse travaille toujours avec NaN, l'Infini, l'Infini, 3e30, et 0. Certains autres réponses échouer dans certains cas particuliers.
- (4).toFixed(2) -> "4.00" dans Chrome 60.0.3112.113
- vous avez besoin d'utiliser +(4).toFixed(2). Unaire opérateur + est critique car il supprime les zéros de fin (tout en restant le traitement de Numéro de coin-cas correctement). Par exemple au niveau de la console d'essayer: console.log('answer:' + +(4).toFixed(2)); imprime answer:4.
- C'est une ressource fantastique sur le Nombre de conversion et les différents cas de coin, à jour et très détaillé.
InformationsquelleAutor C. J.

Mmmm, un peu différent de réponse, pour la croix-navigateur internet:

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

InformationsquelleAutor super

1

Aucun de ces m'a vraiment fait ce que je cherchais, basé sur la question du titre, qui a été, par exemple, pour 5.00 de 5 et 5.10 être 5.1. Ma solution a été comme suit:
```
num.toFixed(places).replace(/\.?0+$/, '')

'5.00'.replace(/\.?0+$/, '') //5
'5.10'.replace(/\.?0+$/, '') //5.1
'5.0000001'.replace(/\.?0+$/, '') //5.0000001
'5.0001000'.replace(/\.?0+$/, '') //5.0001
```
Remarque: La regex ne fonctionne que si places > 0

P. S. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed
- Échoue sur 5e30 (changements de nombre de 5e3). Le coin des cas sont diaboliques!
InformationsquelleAutor Jenna Zeigen
0

Il y a une meilleure méthode qui permet de conserver une précision et aussi des bandes de zéros. Cela prend un nombre d'entrée et par le biais de la magie de casting va lâcher tout les zéros à droite. J'ai trouvé 16 à la précision de la limite pour moi, ce qui est assez bon si vous n'êtes pas à mettre un satellite de pluton.
```
function convertToFixed(inputnum)
{

      var mynum = inputnum.toPrecision(16);
//If you have a string already ignore this first line and change mynum.toString to the inputnum

      var mynumstr = mynum.toString();
    return parseFloat(mynumstr);
    }
    alert(convertToFixed(6.6/6));
```
InformationsquelleAutor Kevrone

Vous devez vous connecter pour publier un commentaire.