Javascript: How to retrieve the number of decimals of a *string* number?

I have a set of string numbers having decimals, for example: 23.456, 9.450, 123.01... I need to retrieve the number of decimals for each number, knowing that they have at least 1 decimal.

In other words, the retr_dec() method should return the following:

retr_dec("23.456") -> 3
retr_dec("9.450")  -> 3
retr_dec("123.01") -> 2

Trailing zeros do count as a decimal in this case, unlike in this related question.

Is there an easy/delivered method to achieve this in Javascript or should I compute the decimal point position and compute the difference with the string length? Thanks

function decimalPlaces(num) {
  var match = (''+num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
  if (!match) { return 0; }
  return Math.max(
       0,
       // Number of digits right of decimal point.
       (match[1] ? match[1].length : 0)
       // Adjust for scientific notation.
       - (match[2] ? +match[2] : 0));
}

The extra complexity is to handle scientific notation so

> decimalPlaces('.05') > 2 > decimalPlaces('.5') > 1 > decimalPlaces('1') > 0 > decimalPlaces('25e-100') > 100 > decimalPlaces('2.5e-99') > 100 > decimalPlaces('.5e1') > 0 > decimalPlaces('.25e1') > 1

function retr_dec(num) {
  return (num.split('.')[1] || []).length;
}

function retr_dec(numStr) {
	var pieces = numStr.split(".");
	return pieces[1].length;
}

Since there is not already a regex-based answer:

/\d*$/.exec(strNum)[0].length

Note that this "fails" for integers, but per the problem specification they will never occur.

You could get the length of the decimal part of your number this way:

var value = 192.123123;
stringValue = value.toString();
length = stringValue.split('.')[1].length;

It makes the number a string, splits the string in two (at the decimal point) and returns the length of the second element of the array returned by the split operation and stores it in the 'length' variable.

Try using String.prototype.match() with RegExp /\..*/ , return .length of matched string -1

function retr_decs(args) {
  return /\./.test(args) && args.match(/\..*/)[0].length - 1 || "no decimal found"
}

console.log(
  retr_decs("23.456") // 3
  , retr_decs("9.450") // 3
  , retr_decs("123.01") // 2
  , retr_decs("123") // "no decimal found"
)

I had to deal with very small numbers so I created a version that can handle numbers like 1e-7.

Number.prototype.getPrecision = function() {
  var v = this.valueOf();
  if (Math.floor(v) === v) return 0;
  var str = this.toString();
  var ep = str.split("e-");
  if (ep.length > 1) {
    var np = Number(ep[0]);
    return np.getPrecision() + Number(ep[1]);
  }
  var dp = str.split(".");
  if (dp.length > 1) {
    return dp[1].length;
  }
  return 0;
}
document.write("NaN => " + Number("NaN").getPrecision() + "<br>");
document.write("void => " + Number("").getPrecision() + "<br>");
document.write("12.1234 => " + Number("12.1234").getPrecision() + "<br>");
document.write("1212 => " + Number("1212").getPrecision() + "<br>");
document.write("0.0000001 => " + Number("0.0000001").getPrecision() + "<br>");
document.write("1.12e-23 => " + Number("1.12e-23").getPrecision() + "<br>");
document.write("1.12e8 => " + Number("1.12e8").getPrecision() + "<br>");

A slight modification of the currently accepted answer, this adds to the Number prototype, thereby allowing all number variables to execute this method:

if (!Number.prototype.getDecimals) {
	Number.prototype.getDecimals = function() {
		var num = this,
			match = ('' + num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
		if (!match)
			return 0;
		return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0));
	}
}

It can be used like so:

// Get a number's decimals.
var number = 1.235256;
console.debug(number + " has " + number.getDecimals() + " decimal places.");

// Get a number string's decimals.
var number = "634.2384023";
console.debug(number + " has " + parseFloat(number).getDecimals() + " decimal places.");

Utilizing our existing code, the second case could also be easily added to the String prototype like so:

if (!String.prototype.getDecimals) {
    String.prototype.getDecimals = function() {
        return parseFloat(this).getDecimals();
    }
}

Use this like:

console.debug("45.2342".getDecimals());

A bit of a hybrid of two others on here but this worked for me. Outside cases in my code weren't handled by others here. However, I had removed the scientific decimal place counter. Which I would have loved at uni!

numberOfDecimalPlaces: function (number) {
    var match = ('' + number).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
    if (!match || match[0] == 0) {
        return 0;
    }
     return match[0].length;
}

Based on Liam Middleton's answer, here's what I did (without scientific notation):

numberOfDecimalPlaces = (number) => {
            let match = (number + "").match(/(?:\.(\d+))?$/);
            if (!match || !match[1]) {
                return 0;
            }

            return match[1].length;
        };
        
alert(numberOfDecimalPlaces(42.21));

function decimalPlaces(n) {
  if (n === NaN || n === Infinity)
    return 0;
  n = ('' + n).split('.');
  if (n.length == 1) {
    if (Boolean(n[0].match(/e/g)))
      return ~~(n[0].split('e-'))[1];
    return 0;

  }
  n = n[1].split('e-');
  return n[0].length + ~~n[1];

}