Comment vérifier si une chaîne est un flotteur?

Comme ça:

 if (!isNaN(value) && value.toString().indexOf('.') != -1) { alert('this is a numberic value and I\'m sure it is a float.'); }​ 

Vous pouvez utiliser la fonction parseFloat.

Si la valeur passée est un flotteur, la fonction renvoie la valeur, sinon elle renverra NaN.

Quelque chose comme:

 val = parseFloat(val); if(isNaN(val)) alert("not a float!"); 

Les fonctions suivantes vérifient également le format. Par exemple, les fonctions parseInt et parseFloat native de JavaScript parseInt également les chaînes contenant des caractères non numériques, et les fonctions ci-dessus ont des conséquences.

 // For example, following code will work var n = parseInt('123asd'); n == 123 

Ces fonctions renverront false pour une telle chaîne.

 function isFloat(val) { var floatRegex = /^-?\d+(?:[.,]\d*?)?$/; if (!floatRegex.test(val)) return false; val = parseFloat(val); if (isNaN(val)) return false; return true; } function isInt(val) { var intRegex = /^-?\d+$/; if (!intRegex.test(val)) return false; var intVal = parseInt(val, 10); return parseFloat(val) == intVal && !isNaN(intVal); } 

 Number.prototype.isFloat = function() { return (this % 1 != 0); } 

Ensuite vous pouvez

 var floatValue = parseFloat("2.13"); var nonFloatValue = parseFloat("11"); console.log(floatValue.isFloat()); // will output true console.log(nonFloatValue.isFloat()); // will output false 

Des valeurs comme 2.00 ne peuvent pas vraiment être considérées comme flottantes dans JS, ou plutôt chaque numéro est un flottant dans JS .

EDIT: J'ai oublié de mentionner que l'extension des prototypes de types intégrés est considérée comme un mauvais parctice (pour une bonne raison) et son utilisation est découragée dans les environnements de production. Vous pouvez toujours implémenter cette vérification comme une fonction simple

Pour vérifier si une chaîne est un entier ou un flotteur

 function isFloat(n) { return parseFloat(n.match(/^-?\d*(\.\d+)?$/))>0; } //alert(isFloat("3.444")); 

Pour vérifier si une chaîne est un flotteur (éviter les valeurs int)

 function isFloat(n) { if( n.match(/^-?\d*(\.\d+)?$/) && !isNaN(parseFloat(n)) && (n%1!=0) ) return true; return false; } var nonfloat = isFloat('12'); //will return false var nonfloat = isFloat('12.34abc'); //will return false var float = isFloat('12.34'); //will return true 

J'ai écrit des fonctions qui acceptent des chaînes, des entiers et des flotteurs

 function isInt(x) { return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length } function isFloat(x) { return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0 } 

Exemple d'exemple:

 console.log(isFloat('0.2')) // true console.log(isFloat(0.2)) // true console.log(isFloat('.2')) // true console.log(isFloat('-.2')) // true console.log(isFloat(-'.2')) // true console.log(isFloat(-.2)) // true console.log(isFloat('u.2')) // false console.log(isFloat('2')) // false console.log(isFloat('0.2u')) // false console.log(isInt('187')) // true console.log(isInt(187)) // true console.log(isInt('1.2')) // false console.log(isInt('-2')) // true console.log(isInt(-'1')) // true console.log(isInt('10e1')) // true console.log(isInt(10e1)) // true 

simple:

 if (parseFloat(value).toString() === value.toString()) { ... } 

Si vous devez vérifier si la valeur est int ou flotter:

 function isFloatOrInt(n) { return !isNaN(n) && n.toString().match(/^-?\d*(\.\d+)?$/); } 

Dans mon cas, une regex très simple a fait l'affaire.

J'avais besoin de valider l'entrée d'un utilisateur si l'entrée est une valeur monétaire valide. J'ai simplement utilisé …

 /^[0-9]+(\.)?[0-9]*$/.test(number) 

Tout entre // est l'expression régulière.

/^ Signifie que la correspondance commence à partir du début du mot et $/ signifie que la correspondance se termine par le mot. Si vous pensez que le mot ne peut pas commencer par la lettre 0 alors l'expression serait comme [1-9][0-9]*

[0-9]+ signifie que le mot doit commencer avec au moins un nombre.

Note: * signifie zéro ou plus, + signifie un ou plusieurs et ? Signifie un ou aucun.

Jusqu'à présent, l'expression est /^[1-9][0-9]*$/ et cela ne valerait que les nombres entiers.

Pour tester une période (.) Dans le nombre, nous devons utiliser \. Avec l'expression. . Est un caractère spécial qui correspond à tout, \. Ne correspond qu'à la période.

Enfin, une autre classe de caractères [0-9]* correspondrait à zéro ou plus de chiffres.

Étuis de test

 /^[0-9]+(\.)?[0-9]$/.test("21.38a") // ==> false /^[0-9]+(\.)?[0-9]$/.test("21.38") // ==> true /^[0-9]+(\.)?[0-9]$/.test("y2781.68") // ==> false /^[0-9]+(\.)?[0-9]$/.test("2781r.68") // ==> false 

Utilisez ceci:

 var isNumber = /^\d+\.\d+$/.test(value); 

Seulement si la value est transmise en tant que chaîne, nous pouvons déterminer si elle utilise un point décimal ou non. Parce que 1.0 (en tant que nombre) entraîne 1 si "1.0" (en tant que chaîne), il en résulte "1.0" exactement le même. Et à partir de là, nous pouvons trouver si elle contient une virgule décimale,. . Nous devons donc passer la value de l'argument en tant que chaîne.

_{Le suivant fonctionnera si la value est une chaîne}

 if ( value.indexOf('.') > -1 ) { // value is a floating point } 

value.toString() ne tournera pas 1.0 à "1.0" (plutôt, il serait simplement le faire passer à 1 ). Passer par chaîne est la meilleure alternative car elle conserve tous ses caractères.

Si vous ne souhaitez pas utiliser une chaîne, il n'y a aucun moyen de capturer 1.0 comme valeur à virgule flottante. Utilisez ce qui suit si vous souhaitez tester un nombre est une valeur à virgule flottante:

_{Ce qui suit ne fonctionnera pas pour 1,0, 1,00, etc.}

 if ( value >>> 0 !== x ) { // value is a floating point } 

Remarque: Vous devriez également vérifier pour !isNaN(value) (j'ai laissé cela pour me concentrer sur les modifications).

Cette fonction renvoie la valeur numérique d'une chaîne indépendamment de l'int ou du flotteur

 function getNumericVal(str) { if(isNaN(str)) return; try {return parseFloat(str);} catch(e) {return parseInt(str);} } 

 function checkFloat(value) { let parsed = Number.parseFloat(value); return (!Number.isNaN(parsed)) && (!Number.isInteger(parsed)) }