Ну, я использую решение, основанное на том, что если вы умножите число с плавающей запятой на правильную степень 10, вы получите целое число.

например, если вы умножите 3.14 * 10 ^ 2, вы получите 314 (целое число). Показатель представляет собой число десятичных знаков, которое имеет число с плавающей запятой.

Итак, я подумал, что если я постепенно умножу плавающую точку на увеличение степеней 10, вы в конечном итоге придете к решение.

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));

это работает для чисел меньше e-17 :

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

2017 обновления

вот упрощенная версия, основанная на ответе Эдвина. Он имеет набор тестов и возвращает правильное количество десятичных дробей для угловых случаев, включая NaN, бесконечность, экспоненциальные обозначения и числа с проблемными представлениями их последовательных дробей, таких как 0.0029 или 0.0408. Это охватывает подавляющее большинство финансовых приложений, где 0.0408 наличие 4 десятичных знаков (не 6) более важно, чем 3.14 e-21, имеющий 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));

компромисс заключается в том, что метод не более 10 гарантированных дроби. Он может вернуть больше десятичных знаков правильно, но не полагайтесь на это. Числа меньше 1e-10 можно считать нулевыми, и функция будет возвращать 0. Это конкретное значение было выбрано для правильного решения углового случая 11.6894, для которого простой метод умножения на степени 10 терпит неудачу (он возвращает 5 вместо 4).

однако, это 5-й угловой случай, который я обнаружил, после 0.0029, 0.0408, 0.1584 и 4.3573. После каждого я должен был уменьшить точность на один десятичный знак. Я не знаю, есть ли другие числа с менее чем 10 десятичными знаками, для которых эта функция может возвращать неправильное число десятичных знаков. Чтобы быть в безопасности, ищите произвольной точности библиотека.

обратите внимание, что преобразование в строку и разделение на . - это только решение для до 7 десятичных знаков. String(0.0000007) === "7e-7". Или даже меньше? Представление с плавающей запятой не интуитивно.

не только числа квантуются перед хранением; кроме того, некоторые числа, хранящиеся в двоичном формате, имеют неоправданно длинные десятичные представления, поэтому их десятичные представления усекаются.

JavaScript представляет числа с помощью IEEE-754 формат двойн-точности (64 бита). Насколько я понимаю, это дает вам точность 53 бита или пятнадцать-шестнадцать десятичных цифр.

поэтому для любого числа с большим количеством цифр вы просто получаете приближение. Есть некоторые библиотеки, чтобы обрабатывать большие числа с большей точностью, в том числе упомянутые в этой теме.

на основе ответа gion_13 я придумал следующее:

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));

Он исправляет возвращаемый 1, когда нет десятичных знаков. Насколько я могу судить, это работает без ошибок.