web-dev-qa-db-fra.com

Comment puis-je vérifier si une chaîne est un flottant?

Je passe un paramètre appelé valeur. Je voudrais savoir si la valeur est un flottant. Jusqu'à présent, j'ai les éléments suivants:

if (!isNaN(value))
{
    alert('this is a numeric value but not sure if it is a float.');
}

Comment aller plus loin et convertir la chaîne en quelque chose qui peut être évalué en flottant?

javascriptparsing
36
Nate Pet

Comme ça:

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

Vous pouvez utiliser la fonction parseFloat.

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

Quelque chose comme:

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

Les fonctions suivantes vérifient également le format. Par exemple. Les fonctions JavaScript natives parseInt et parseFloat analysent é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);
}
8
Nikola Radosavljević

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

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

//alert(isFloat("3.444"));
7
Yasas Rangika
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 peut pas vraiment être considéré comme flottant dans JS, ou plutôt chaque nombre est un flottant dans JS.

6
Powerslave

Utilisez ceci:

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

Dans mon cas, une expression rationnelle 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 au début du mot et $/ signifie que le match se termine par la Parole. Si vous pensez que la Parole 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 par au moins un chiffre.

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

Jusqu'ici, l'expression est /^[1-9][0-9]*$/ et cela ne validerait 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 correspondra qu'à la période.

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

Cas 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
2
maksbd19

Pour vérifier si une chaîne est un flottant (é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
2
rodrigomelo
function checkFloat(value) {
    let parsed = Number.parseFloat(value);
    return (!Number.isNaN(parsed)) && (!Number.isInteger(parsed))
}
2
prmph

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

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

simple:

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

Cette fonction renvoie la valeur numérique d'une chaîne, qu'elle soit int ou float

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

utiliser ce code jquery

    <script>
    $(document).ready(function () {
        $(".allow_only_float").keypress(function (e) {

            if (e.which != 46 && e.which != 8 && e.which != 0 && (e.which < 48 || e.which > 57)) {
                e.preventDefault();//return false;
            }
            var avg = $('#<%=txtAverage.ClientID%>').val();
            var idx = avg.indexOf(".");
            if (idx > -1 && e.which == 46) {
                e.preventDefault();//return false;
            }
        });
    });
    </script>
<body>
    <input type='text' class='allow_only_float'>
</body>
0
reza akhlaghi

Ce n'est que si value est passé en tant que chaîne que nous pouvons déterminer complètement s'il utilise un point décimal ou non. Parce que 1.0 (Sous forme de nombre) donne 1 Bien que "1.0" (Sous forme de chaîne) donne "1.0" Exactement la même chose. Et à partir de là, nous pouvons trouver s'il contient un point décimal, .. Nous devons donc passer l'argument value sous forme de chaîne.

Ce qui suit fonctionnera si value est une chaîne

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

}

value.toString() ne transformera pas 1.0 en "1.0" (il le transformera simplement en 1) donc passer par chaîne est la meilleure alternative car il maintient tous ses personnages.

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

Les éléments suivants ne fonctionneront pas pour 1.0, 1.00, etc.

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

}

Remarque: Vous devez également vérifier !isNaN(value) (je l'ai laissé de côté pour me concentrer sur les modifications).

0
0x499602D2