Javascript: Comment récupérer le nombre de décimales d'un *string* nombre?
j'ai un ensemble de numéros de chaîne ayant des décimales, par exemple: 23.456 , 9.450 , 123.01 ... Je dois récupérer le nombre de décimales pour chaque nombre, sachant qu'ils ont au moins 1 décimale.
en d'autres termes, la méthode retr_dec() doit retourner ce qui suit:
retr_dec("23.456") -> 3
retr_dec("9.450") -> 3
retr_dec("123.01") -> 2
les zéros de queue comptent effectivement comme une décimale dans ce cas, contrairement à la question connexe .
y a-t-il une méthode facile / livrable pour réaliser ceci en Javascript ou dois-je calculer la position décimale et calculer la différence avec la longueur de chaîne? Merci
11 réponses
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));
}
Le supplément de complexité est de gérer la notation scientifique si
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;
}
Puisqu'il n'y a pas déjà une réponse basée sur regex:
/\d*$/.exec(strNum)[0].length
notez que cela" échoue " pour les entiers, mais selon la spécification du problème ils ne se produiront jamais.
, Vous pouvez obtenir la longueur de la partie décimale de votre numéro de cette façon:
var value = 192.123123;
stringValue = value.toString();
length = stringValue.split('.')[1].length;
il fait le nombre une chaîne, divise la chaîne en deux (au point décimal) et renvoie la longueur du deuxième élément du tableau retourné par l'opération de division et le stocke dans la variable 'length'.
une légère modification de la réponse actuellement acceptée, cela ajoute au prototype Number , permettant ainsi à toutes les variables numériques d'exécuter cette méthode:
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));
}
}
il peut être utilisé comme ainsi:
// 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.");
en utilisant notre code existant, le second cas pourrait aussi être facilement ajouté au String prototype like so:
if (!String.prototype.getDecimals) {
String.prototype.getDecimals = function() {
return parseFloat(this).getDecimals();
}
}
utiliser comme suit:
console.debug("45.2342".getDecimals());
un peu Un hybride des deux autres ici, mais cela a fonctionné pour moi. Les cas extérieurs dans mon code n'ont pas été traités par d'autres ici. Cependant, j'avais enlevé le scientifique décimale compteur. Ce que j'aurais aimé à la fac!
numberOfDecimalPlaces: function (number) {
var match = ('' + number).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
if (!match || match[0] == 0) {
return 0;
}
return match[0].length;
}
Essayez d'utiliser String.prototype.match() avec RegExp /\..*/ , le retour .length de la chaîne trouvée -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"
)j'ai dû traiter avec des nombres très petits donc j'ai créé une version qui peut traiter des nombres comme 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>");basé sur la réponse de Liam Middleton, voici ce que j'ai fait (sans notation scientifique):
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];
}