Comment puis-je obtenir les décimales d'un nombre à virgule flottante en Javascript?

Ce que j'aimerais avoir, c'est presque à l'opposé de Nombre.le prototype.toPrecision(), ce qui signifie que quand j'ai le nombre, combien de décimales? E. g.

(12.3456).getDecimals() //4

15 - Math.ceil(Math.log(x) / Math.log(10))
possible dup: stackoverflow.com/questions/1458633/...
x = 12.3456; var precision = String(x).replace('.', '').length - x.toFixed().length;
Mais la précision de ce nombre est de 6.
@Theonlygusti points, ce n'est pas "de précision". C'est "l'échelle", ou "décimales". La précision est d'environ un nombre important (1234 = 4 prec, l. 1.234 = 4 prec)

OriginalL'auteur JussiR | 2012-03-04

34

Pour quiconque de se demander comment faire cela plus rapidement (sans avoir à les convertir à la chaîne), voici une solution:
```
function precision(a) {
  var e = 1;
  while (Math.round(a * e) / e !== a) e *= 10;
  return Math.log(e) / Math.LN10;
}
```
Edit: une solution plus complète à bord des cas couverts:
```
function precision(a) {
  if (!isFinite(a)) return 0;
  var e = 1, p = 0;
  while (Math.round(a * e) / e !== a) { e *= 10; p++; }
  return p;
}
```
Difficile de nier que c'est la plus bonne réponse
Si vous passer NaN, il va aller dans une boucle infinie.
C'est une bonne réponse, mais je vous recommande de vérifier pour les cas limites, comme le NaN ou les Infinités, pour éviter la boucle infinie. Aussi, il peut être préférable si vous retourné Math.round(Math.log(e) / Math.LN10) à la place.
Juste pour le plaisir, mettez ceci dans un jsperf par rapport à la chaîne de réponse ci-dessus. Il est environ 8 fois plus vite: jsperf.com/getting-numerical-precision/2
Veuillez noter que la version en vigueur provoque encore une boucle sans fin si l'entrée n'est pas valide (par exemple, une chaîne vide).

OriginalL'auteur Mourner
20

Une solution possible (dépend de l'application):
```
var precision = (12.3456 + "").split(".")[1].length;
```
(1.0 + "").split(".")[1].length; donne une erreur parce que split retourne un caractère, de sorte que nous ne pouvons pas accéder à la deuxième ([1]) de l'élément.
Quelque chose comme ceci devrait fonctionner: fonction getPrecision(nombre) { var n = nombre.toString().split("."); de retour n.longueur > 1 ? n[1].longueur : 0; }
Cette "accepté" la réponse est incorrecte pour le cas général, comme Piotr mentionnés ci-dessus. Aussi, cette question est une duplicate.
(12.3456 + '.').split('.')[1].length; fonctionne pour tous les cas dans l'obtention de la décimale comte.

OriginalL'auteur Manish
3

Si par "précision" tu veux dire "décimales", alors que c'est impossible parce que les flotteurs sont binaires. Ils n'ont pas ont décimales, et la plupart des valeurs qui ont un petit nombre de décimales de la récurrence de chiffres binaires, et quand ils sont traduites décimale qui n'est pas nécessairement le rendement de l'origine de nombre décimal.

Tout code qui fonctionne avec le "décimales" d'un flotteur, est susceptible de produire des résultats inattendus sur quelques chiffres.

Ok, bon à savoir. De toute façon, je suis seulement à faire avec la façon dont les nombres décimaux sont affichés, et de les changer de chaîne d'un fractionnement avec '.' semble être te répondre.

OriginalL'auteur Michael Borgwardt

Essayez ce qui suit

function countDecimalPlaces(number) { 
  var str = "" + number;
  var index = str.indexOf('.');
  if (index >= 0) {
    return str.length - index - 1;
  } else {
    return 0;
  }
}

OriginalL'auteur JaredPar

1

Il n'y a pas de fonction native pour déterminer le nombre de décimales. Ce que vous pouvez faire est de convertir le numéro de chaîne, puis de compter le décalage off le séparateur de décimales .:
```
Number.prototype.getPrecision = function() {
    var s = this + "",
        d = s.indexOf('.') + 1;

    return !d ? 0 : s.length - d;
};

(123).getPrecision() === 0;
(123.0).getPrecision() === 0;
(123.12345).getPrecision() === 5;
(1e3).getPrecision() === 0;
(1e-3).getPrecision() === 3;
```
Mais c'est dans la nature de chars de vous tromper. 1 peut tout aussi bien être représenté par 0.00000000989 ou quelque chose. Je ne suis pas sûr de savoir comment bien le ci-dessus effectue réellement dans la vraie vie des applications.

OriginalL'auteur rodneyrehm

En se basant sur @blackpla9ue commentaire et compte tenu de nombre de format exponentiel:

function getPrecision (num) {
  var numAsStr = num.toFixed(10); //number can be presented in exponential format, avoid it
  numAsStr = numAsStr.replace(/0+$/g, '');

  var precision = String(numAsStr).replace('.', '').length - num.toFixed().length;
  return precision;  
}

getPrecision(12.3456);         //4
getPrecision(120.30003300000); //6, trailing zeros are truncated
getPrecision(15);              //0
getPrecision(120.000))         //0
getPrecision(0.0000005);       //7
getPrecision(-0.01))           //2

OriginalL'auteur Boolean_Type

@Boolean_Type de la méthode de gestion des exposants, mais en évitant les regex:

function getPrecision (value) {
    if (!isFinite(value)) { return 0; }

    const [int, float = ''] = Number(value).toFixed(12).split('.');

    let precision = float.length;
    while (float[precision - 1] === '0' && precision >= 0) precision--;

    return precision;
}

OriginalL'auteur Sc0ttyD

L'une des approches suivantes de travail?

var num = 12.3456
console.log(num - Math.floor(num))

console.log(num - parseInt(num))

OriginalL'auteur Enayat Rajabi

Voici quelques exemples, qui utilise une bibliothèque (BigNumber.js), et un autre qui n'utilise pas de bibliothèque. Supposons que vous voulez vérifier qu'un certain nombre d'entrée (inputNumber) a un montant de chiffres après la virgule est inférieur ou égal à un montant maximal de décimales (tokenDecimals).

Avec BigNumber.js

import BigNumber from 'bignumber.js'; //ES6
//const BigNumber = require('bignumber.js').default; //CommonJS

const tokenDecimals = 18;
const inputNumber = 0.000000000000000001;
//Convert to BigNumber
const inputNumberBn = new BigNumber(inputNumber);

//BigNumber.js API Docs: http://mikemcl.github.io/bignumber.js/#dp
console.log(`Invalid?: ${inputNumberBn.dp() > tokenDecimals}`);

Sans BigNumber.js

function getPrecision(numberAsString) {
  var n = numberAsString.toString().split('.');
  return n.length > 1
    ? n[1].length
    : 0;
}

const tokenDecimals = 18;
const inputNumber = 0.000000000000000001;

//Conversion of number to string returns scientific conversion
//So obtain the decimal places from the scientific notation value
const inputNumberDecimalPlaces = inputNumber.toString().split('-')[1];

//Use `toFixed` to convert the number to a string without it being
//in scientific notation and with the correct number decimal places
const inputNumberAsString = inputNumber.toFixed(inputNumberDecimalPlaces);

//Check if inputNumber is invalid due to having more decimal places
//than the permitted decimal places of the token
console.log(`Invalid?: ${getPrecision(inputNumberAsString) > tokenDecimals}`);

OriginalL'auteur Luke Schoen

Vous devez vous connecter pour publier un commentaire.