Eh bien, j'utilise une solution basée sur le fait que si vous multipliez un nombre à virgule flottante par la bonne puissance de 10, vous obtenez un entier.

Par exemple, si vous multipliez 3.14 * 10 ^ 2, vous obtenez 314 (un entier). L'exposant représente alors le nombre de décimales du nombre à virgule flottante a.

Donc, j'ai pensé que si je multiplie progressivement un virgule flottante en augmentant des puissances de 10, vous finirez par arriver à la solution.

let decimalPlaces = function () {
   function isInt(n) {
      return typeof n === 'number' && 
             parseFloat(n) == parseInt(n, 10) && !isNaN(n);
   }
   return function (n) {
      const a = Math.abs(n);
      let c = a, count = 1;
      while (!isInt(c) && isFinite(c)) {
         c = a * Math.pow(10, count++);
      }
      return count - 1;
   };
}();

for (const x of [
  0.0028, 0.0029, 0.0408,
  0, 1.0, 1.00, 0.123, 1e-3,
  3.14, 2.e-3, 2.e-14, -3.14e-21,
  5555.0, 5555, 555.5, 555.50, 0.0000005, 5e-7, 0.00000055, 5e-8,
  0.000006, 0.0000007,
  0.123, 0.121, 0.1215
]) console.log(x, '->', decimalPlaces(x));

Cela fonctionne pour les nombres inférieurs à e-17:

function decimalPlaces(n){
    var a;
    return (a=(n.toString().charAt(0)=='-'?n-1:n+1).toString().replace(/^-?[0-9]+\.?([0-9]+)$/,'$1').length)>=1?a:0;
}

Mise à jour 2017

Voici une version simplifiée basée sur la réponse D'Edwin. Il a une suite de tests et renvoie le nombre correct de décimales pour les cas de coin, y compris Nan, Infinity, notations d'exposant, et les nombres avec des représentations problématiques de leurs fractions successives, telles que 0.0029 ou 0.0408. Cela couvre la grande majorité des applications financières, où 0.0408 ayant 4 décimales (pas 6) est plus important que 3.14 e-21 ayant 23.

function decimalPlaces(n) {
  function hasFraction(n) {
    return Math.abs(Math.round(n) - n) > 1e-10;
  }

  let count = 0;
  // multiply by increasing powers of 10 until the fractional part is ~ 0
  while (hasFraction(n * (10 ** count)) && isFinite(10 ** count))
    count++;
  return count;
}

for (const x of [
  0.0028, 0.0029, 0.0408, 0.1584, 4.3573, // corner cases against Edwin's answer
  11.6894,
  0, 1.0, 1.00, 0.123, 1e-3, -1e2, -1e-2, -0.1,
  NaN, 1E500, Infinity, Math.PI, 1/3,
  3.14, 2.e-3, 2.e-14,
  1e-9,  // 9
  1e-10,  // should be 10, but is below the precision limit
  -3.14e-13,  // 15
  3.e-13,  // 13
  3.e-14,  // should be 14, but is below the precision limit
  123.12345678901234567890,  // 14, the precision limit
  5555.0, 5555, 555.5, 555.50, 0.0000005, 5e-7, 0.00000055, 5e-8,
  0.000006, 0.0000007,
  0.123, 0.121, 0.1215
]) console.log(x, '->', decimalPlaces(x));

Le le compromis est que la méthode est limitée à un maximum de 10 décimales garanties. Il peut renvoyer plus de décimales correctement, mais ne comptez pas sur cela. Les nombres inférieurs à 1e-10 peuvent être considérés comme zéro, et la fonction retournera 0. Cette valeur particulière a été choisie pour résoudre correctement le cas de coin 11.6894, pour lequel la méthode simple de multiplier par des puissances de 10 échoue (elle renvoie 5 au lieu de 4).

Cependant, c'est le 5ème cas de coin que j'ai découvert, après 0.0029, 0.0408, 0.1584 et 4.3573. Après chaque, j'ai dû réduire la précision d'une décimale. Je ne sais pas s'il y a d'autres nombres avec moins de 10 décimales pour lesquels cette fonction peut renvoyer un nombre incorrect de décimales. Pour être du bon côté, recherchez une bibliothèque de précision arbitraire .

Notez que la conversion en chaîne et le fractionnement par . n'est qu'une solution pour un maximum de 7 décimales. String(0.0000007) === "7e-7". Ou peut-être même moins? La représentation en virgule flottante n'est pas intuitive.

non seulement les nombres sont quantifiés avant le stockage; de plus, certains nombres stockés en binaire ont des représentations décimales déraisonnablement longues, de sorte que leurs représentations décimales sont tronquées.

JavaScript représente des nombres en utilisant IEEE-754 format double précision (64 bits). Si je comprends bien, cela vous donne une précision de 53 bits, ou quinze à seize chiffres décimaux.

Donc, pour tout nombre avec plus de chiffres, vous obtenez juste une approximation. Il y a quelques bibliothèques autour de gérer de grands nombres avec plus de précision, y compris ceux mentionnés dans Ce thread.

Basé sur la réponse gion_13, je suis venu avec ceci:

function decimalPlaces(n){
let result= /^-?[0-9]+\.([0-9]+)$/.exec(n);
return result === null ? 0 : result[1].length;
}

for (const x of [
  0, 1.0, 1.00, 0.123, 1e-3, 3.14, 2.e-3, -3.14e-21,
  5555.0, 5555, 555.5, 555.50, 0.0000005, 5e-7, 0.00000055, 5e-8,
  0.000006, 0.0000007,
  0.123, 0.121, 0.1215
]) console.log(x, '->', decimalPlaces(x));

Il corrige le retour 1 quand il n'y a pas de décimales. Pour autant que je sache, cela fonctionne sans erreurs.