Ответ 1

Историческое примечание: нить комментария ниже может относиться к первой и второй реализациям. Я поменял порядок в сентябре 2017 года, так как внедрение с ошибкой реализации вызвало путаницу.

Если вам нужно что-то, что отображает "0.1e-100" в 101, вы можете попробовать что-то вроде

function decimalPlaces(n) {
  // Make sure it is a number and use the builtin number -> string.
  var s = "" + (+n);
  // Pull out the fraction and the exponent.
  var match = /(?:\.(\d+))?(?:[eE]([+\-]?\d+))?$/.exec(s);
  // NaN or Infinity or integer.
  // We arbitrarily decide that Infinity is integral.
  if (!match) { return 0; }
  // Count the number of digits in the fraction and subtract the
  // exponent to simulate moving the decimal point left by exponent places.
  // 1.234e+2 has 1 fraction digit and '234'.length -  2 == 1
  // 1.234e-2 has 5 fraction digit and '234'.length - -2 == 5
  return Math.max(
      0,  // lower limit.
      (match[1] == '0' ? 0 : (match[1] || '').length)  // fraction length
      - (match[2] || 0));  // exponent
}

Согласно спецификации, любое решение, основанное на встроенном преобразовании число- > строка, может быть точным только в 21 месте за пределами экспоненты.

9.8.1 ToString Применяется к типу номера

5. В противном случае пусть n, k и s - целые числа, такие, что k ≥ 1, 10k-1 ≤ s < 10k, числовое значение для s × 10n-k равно m, а k как можно меньше. Заметим, что k - это число цифр в десятичном представлении s, что s не делится на 10 и что наименее значимая цифра s не обязательно однозначно определяется этими критериями.
6. Если k ≤ n ≤ 21, верните String, состоящую из k цифр десятичного представления s (в порядке, без начальных нулей), а затем n-k вхождений символа '0.
7. Если 0 < n ≤ 21, верните String, состоящую из наиболее значимых n цифр десятичного представления s, за которым следует десятичная точка '., за которой следуют остальные k-n цифры десятичного представления s.
8. Если -6 < n ≤ 0, верните строку, состоящую из символа '0, за которым следует десятичная точка'., а затем -n вхождения символа '0, за которым следуют k цифр десятичного представления s.

Историческое примечание. Нижеприведенная реализация является проблематичной. Я оставляю его здесь как контекст для потока комментариев.

Основываясь на определении Number.prototype.toFixed, кажется, что следующее должно работать, но из-за представления двойных значений IEEE-754, определенные числа будут давать ложные результаты. Например, decimalPlaces(0.123) вернет 20.

function decimalPlaces(number) {
  // toFixed produces a fixed representation accurate to 20 decimal places
  // without an exponent.
  // The ^-?\d*\. strips off any sign, integer portion, and decimal point
  // leaving only the decimal fraction.
  // The 0+$ strips off any trailing zeroes.
  return ((+number).toFixed(20)).replace(/^-?\d*\.?|0+$/g, '').length;
}

// The OP examples:
console.log(decimalPlaces(5555.0));  // 0
console.log(decimalPlaces(5555));  // 0
console.log(decimalPlaces(555.5));  // 1
console.log(decimalPlaces(555.50));  // 1
console.log(decimalPlaces(0.0000005));  // 7
console.log(decimalPlaces(5e-7));  // 7
console.log(decimalPlaces(0.00000055));  // 8
console.log(decimalPlaces(5e-8));  // 8
console.log(decimalPlaces(0.123));  // 20 (!)

Ответ 2

Ну, я использую решение, основанное на том, что если вы умножаете число с плавающей запятой на правильную мощность 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));

Ответ 3

это работает для чисел, меньших 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;
}

Ответ 4

Обновление 2017

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

Ответ 5

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

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

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

Ответ 6

Это работает для меня

const decimalPlaces = value.substring(value.indexOf('.') + 1).length;

Этот метод ожидает, что значение будет стандартным числом.

Ответ 7

Основываясь на ответе 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));