Comment puis-je vérifier qu'un nombre est flottant ou entier?
Comment trouver qu'un numéro est float ou integer ?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
30 réponses
vérifier s'il y a un reste lors de la division par 1:
function isInt(n) {
return n % 1 === 0;
}
si vous ne savez pas que l'argument est un nombre, vous avez besoin de deux tests:
function isInt(n){
return Number(n) === n && n % 1 === 0;
}
function isFloat(n){
return Number(n) === n && n % 1 !== 0;
}
essayez ces fonctions pour vérifier si une valeur est une valeur primitive de nombre qui n'a pas de partie fractionnaire et est dans les limites de taille de ce qui peut être représenté comme un entier exact.
function isFloat(n) {
return n === +n && n !== (n|0);
}
function isInteger(n) {
return n === +n && n === (n|0);
}
pourquoi pas quelque chose comme ça:
var isInt = function(n) { return parseInt(n) === n };
il existe une méthode appelée Number.isInteger() qui n'est actuellement implémentée que dans la dernière version de Firefox et qui fait toujours partie de la proposition EcmaScript 6. Cependant MDN fournit un polyfill pour les autres navigateurs, qui correspond à celui spécifié dans ECMA harmony:
if (!Number.isInteger) {
Number.isInteger = function isInteger (nVal) {
return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
};
}
vous pouvez utiliser une simple expression régulière:
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
Ou vous pouvez utiliser les fonctions ci-dessous, selon vos besoins. Ils sont développés par le projet PHPJS .
is_int() => vérifier si le type de variable est entier et si son contenu est entier
is_float() => vérifier si la variable type est float et si son contenu est float
ctype_digit() => vérifier si le type de variable est une chaîne de caractères et si son contenu n'a que des chiffres décimaux
"1519230920 mise à jour" Update 1
maintenant il vérifie les nombres négatifs aussi, merci pour @ ChrisBartley commentaire !
Voici des fonctions efficaces qui vérifient si la valeur est un nombre ou peut être converti en toute sécurité en un nombre:
function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}
et pour les entiers (retournerait false si la valeur est un float):
function isInteger(value) {
if ((undefined === value) || (null === value)) {
return false;
}
return value % 1 == 0;
}
l'efficacité ici est que parseInt (ou parseNumber) sont évités lorsque la valeur est déjà un nombre. Les deux fonctions de parsing toujours convertir en chaîne d'abord et ensuite essayer de analysez cette chaîne, qui serait un gaspillage si la valeur est déjà un nombre.
Merci aux autres postes ici pour fournir d'autres idées pour l'optimisation!
function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }
// give it a spin
isInteger(1.0); // true
isFloat(1.0); // false
isFloat(1.2); // true
isInteger(1.2); // false
isFloat(1); // false
isInteger(1); // true
isFloat(2e+2); // false
isInteger(2e+2); // true
isFloat('1'); // false
isInteger('1'); // false
isFloat(NaN); // false
isInteger(NaN); // false
isFloat(null); // false
isInteger(null); // false
isFloat(undefined); // false
isInteger(undefined); // false
function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
fonctionne pour tous les cas.
comme d'autres l'ont mentionné, vous n'avez que des doubles en JS. Alors, comment définissez-vous un nombre entier? Il suffit de vérifier si le nombre arrondi est égal à lui-même:
function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
voici ce que j'utilise pour les entiers:
Math.ceil(parseFloat(val)) === val
Bref, sympa :) Travaille tout le temps. C'est ce que David Flanagan suggère si Je ne me trompe pas.
tout nombre flottant avec une partie décimale zéro (par exemple 1.0, 12.00, 0.0) est implicitement moulé en nombre entier, il n'est donc pas possible de vérifier s'ils sont flottants ou non.
var isInt = function (n) { return n === (n | 0); };
N'ont pas eu un cas où cela n'a pas fait le travail.
Cela dépend vraiment de ce que vous voulez atteindre. Si vous voulez "émuler" langages fortement typés alors je vous suggère de ne pas essayer. Comme d'autres l'ont mentionné tous les nombres ont la même représentation (du même type).
utilisant quelque chose comme Claudiu fourni:
isInteger( 1.0 ) - > true
ce qui semble bien pour le bon sens, mais dans quelque chose comme C vous obtiendriez false
c'est aussi simple que:
if( n === parseInt(n) ) ...
essayez ceci dans la console:
x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously
// BUT!
x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!
cela trouble beaucoup de gens. Chaque fois que quelque chose est .0, ce n'est pas un flotteur plus. C'est un entier. Ou vous pouvez simplement l'appeler "numériques chose" car il n'y a pas de distinction stricte comme à l'époque en C. Bon vieux temps.
donc fondamentalement, tout ce que vous pouvez faire est de vérifier pour entier accepter le fait que 1.000 est un entier.
note Intéressante
il y avait un commentaire au sujet des nombres énormes. Les nombres énormes ne signifient aucun problème pour cette approche; chaque fois que parseInt est incapable de gérer le nombre (car il est trop grand) il retournera quelque chose d'autre que la valeur réelle ainsi le test retournera FALSE. C'est une bonne chose parce que si vous considérez quelque chose comme un "nombre", vous vous attendez normalement à ce que JS soit capable de calculer avec lui - donc, oui, les nombres sont limités et parseInt sera prendre cela en considération , pour le dire ainsi.
essayez ceci:
<script>
var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);
</script>
dans mon navigateur (IE8) ce retour" a est ok; B échoue " qui est exactement en raison du nombre énorme dans B. La limite peut varier mais je suppose que 20 chiffres "devrait être assez pour n'importe qui", pour citer un classique:)
C'EST LE CODE FINAL POUR LE CONTRÔLE À LA FOIS INT ET FLOAT
function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}
ou
function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}
function isInteger(n) {
return ((typeof n==='number')&&(n%1===0));
}
function isFloat(n) {
return ((typeof n==='number')&&(n%1!==0));
}
function isNumber(n) {
return (typeof n==='number');
}
j'ai écrit une fonction qui accepte les chaînes (si quelqu'un en a besoin)
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 ouptuts:
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
pour les entiers j'utilise ce
function integer_or_null(value) {
if ((undefined === value) || (null === value)) {
return null;
}
if(value % 1 != 0) {
return null;
}
return value;
}
ça ne doit pas être si compliqué. La valeur numérique des équivalents parseFloat() et parseInt() d'un entier sera la même. Ainsi vous pouvez faire ainsi:
function isInt(value){
return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}
puis
if (isInt(x)) // do work
cela permettra également de vérifier les chaînes de caractères et n'est donc pas strict. Si vous voulez une solution de type fort (aka, wont work with strings):
function is_int(value){ return !isNaN(parseInt(value * 1) }
en écriture java tous les numéros sont internally 64 bit floating point , identique au double en java.
Il n'y a pas de types différents dans javascript, Tous sont représentés par le type number . Par conséquent, vous ne serez pas en mesure de faire un instanceof vérifier. Cependant u peut utiliser les solutions ci-dessus pour en savoir si c'est un nombre fractionnaire. les concepteurs de Java script ressenti avec un seul type, ils peuvent éviter de nombreuses erreurs de type moulé.
ce n'est peut-être pas aussi performant que le % de réponse, ce qui vous empêche d'avoir à convertir en chaîne d'abord, mais je n'ai vu personne le poster encore, donc voici une autre option qui devrait fonctionner très bien:
function isInteger(num) {
return num.toString().indexOf('.') === -1;
}
pour les curieux, avec Benchmark.js j'ai testé le plus voté réponses (et celui posté aujourd'hui) sur ce post, voici mes résultats:
var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
// kennebec
.add('0', function() {
return n % 1 == 0;
})
// kennebec
.add('1', function() {
return typeof n === 'number' && n % 1 == 0;
})
// kennebec
.add('2', function() {
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
})
// Axle
.add('3', function() {
return n.toString().indexOf('.') === -1;
})
// Dagg Nabbit
.add('4', function() {
return n === +n && n === (n|0);
})
// warfares
.add('5', function() {
return parseInt(n) === n;
})
// Marcio Simao
.add('6', function() {
return /^-?[0-9]+$/.test(n.toString());
})
// Tal Liron
.add('7', function() {
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
});
// Define logs and Run
suite.on('cycle', function(event) {
console.log(String(event.target));
}).on('complete', function() {
console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });
0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)
Fastest is 7 Tal Liron
Voici mon code. Il vérifie pour s'assurer qu'il n'est pas une chaîne vide (qui autrement passera) et le convertit au format numérique. Maintenant, selon que vous voulez que " 1.1 " soit égal à 1.1, cela peut être ou non ce que vous recherchez.
var isFloat = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseFloat(n));
};
var isInteger = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseInt(n));
};
var isNumeric = function(n){
if(isInteger(n) || isFloat(n)){
return true;
}
return false;
};
j'aime cette petite fonction, qui retournera vrai pour les entiers positifs et négatifs:
function isInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}
cela fonctionne parce que 1 ou" 1 "devient" 1.0", qui isNaN() retourne false on (que nous nions alors et retournons), mais 1.0 ou" 1.0 "devient" 1.0.0", tandis que" string "devient" string.0", qui ne sont pas des nombres, ainsi isNaN () retourne false (et, encore une fois, est nié).
si vous voulez seulement des entiers positifs, il y a cette variante:
function isPositiveInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}
ou, pour les entiers négatifs:
function isNegativeInt(val) {
return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}
isPositiveInt () fonctionne en déplaçant la chaîne numérique concaténée en avant de la valeur à tester. Par exemple, isPositiveInt(1) aboutit à isNaN() évaluant "01", qui évalue false. Entre-temps, isPositiveInt(-1) donne à isNaN() une évaluation de "0-1", qui évalue true. Nous nions la valeur de retour et cela nous donne ce que nous voulons. isNegativeInt () fonctionne de la même manière, mais sans nier la valeur de retour de la fonction isNaN().
Edit:
mon implémentation originale retournerait aussi true sur les tableaux et les chaînes vides. Cette mise en œuvre ne présente pas ce défaut. Il a également l'avantage de revient tôt si val n'est pas une chaîne ou un nombre, ou si c'est une chaîne vide, le rendant plus rapide dans ces cas. Vous pouvez encore le modifier en remplaçant les deux premières clauses par
typeof(val) != "number"
si vous voulez seulement correspondre à literal les nombres (et non pas des chaînes de caractères)
Edit:
Je ne peux pas encore poster de commentaires, donc j'ajoute ceci à ma réponse. Le benchmark affiché par @Asok est très instructif; cependant, la fonction la plus rapide ne répond pas aux exigences, car il retourne également vrai pour les flotteurs, les tableaux, les booléens, et les chaînes vides.
j'ai créé la suite de test suivante pour tester chacune des fonctions, en ajoutant ma réponse à la liste, ainsi (Fonction 8, qui analyse les chaînes, et la fonction 9, qui n'est pas):
funcs = [
function(n) {
return n % 1 == 0;
},
function(n) {
return typeof n === 'number' && n % 1 == 0;
},
function(n) {
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
},
function(n) {
return n.toString().indexOf('.') === -1;
},
function(n) {
return n === +n && n === (n|0);
},
function(n) {
return parseInt(n) === n;
},
function(n) {
return /^-?[0-9]+$/.test(n.toString());
},
function(n) {
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
},
function(n) {
return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
}
];
vals = [
[1,true],
[-1,true],
[1.1,false],
[-1.1,false],
[[],false],
[{},false],
[true,false],
[false,false],
[null,false],
["",false],
["a",false],
["1",null],
["-1",null],
["1.1",null],
["-1.1",null]
];
for (var i in funcs) {
var pass = true;
console.log("Testing function "+i);
for (var ii in vals) {
var n = vals[ii][0];
var ns;
if (n === null) {
ns = n+"";
} else {
switch (typeof(n)) {
case "string":
ns = "'" + n + "'";
break;
case "object":
ns = Object.prototype.toString.call(n);
break;
default:
ns = n;
}
ns = "("+typeof(n)+") "+ns;
}
var x = vals[ii][1];
var xs;
if (x === null) {
xs = "(ANY)";
} else {
switch (typeof(x)) {
case "string":
xs = "'" + n + "'";
break;
case "object":
xs = Object.prototype.toString.call(x);
break;
default:
xs = x;
}
xs = "("+typeof(x)+") "+xs;
}
var rms;
try {
var r = funcs[i](n);
var rs;
if (r === null) {
rs = r+"";
} else {
switch (typeof(r)) {
case "string":
rs = "'" + r + "'";
break;
case "object":
rs = Object.prototype.toString.call(r);
break;
default:
rs = r;
}
rs = "("+typeof(r)+") "+rs;
}
var m;
var ms;
if (x === null) {
m = true;
ms = "N/A";
} else if (typeof(x) == 'object') {
m = (xs === rs);
ms = m;
} else {
m = (x === r);
ms = m;
}
if (!m) {
pass = false;
}
rms = "Result: "+rs+", Match: "+ms;
} catch (e) {
rms = "Test skipped; function threw exception!"
}
console.log(" Value: "+ns+", Expect: "+xs+", "+rms);
}
console.log(pass ? "PASS!" : "FAIL!");
}
j'ai aussi réutilisé le benchmark avec la fonction #8 ajoutée à la liste. Je ne posterai pas le résultat, car ils sont un peu embarrassants (par exemple, cette fonction N'est pas rapide)...
(abrégée -- j'ai enlevé des essais réussis, car la sortie est assez long), les résultats sont comme suit:
Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!
Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!
Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!
Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
j'ai laissé dans les échecs de sorte que vous pouvez voir où chaque fonction échoue, et le (string) '#' tests ainsi vous pouvez voir comment chaque fonction gère les valeurs entières et flottantes dans les chaînes, comme certains peuvent vouloir ces parsed comme des nombres et certains peuvent ne pas.
sur les 10 fonctions testées, celles qui répondent réellement aux exigences de L'OP sont [1,3,5,6,8,9]
Condtion flottants pour la validation :
if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
Condtion de validation Entier :
if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
J'espère que cela pourrait être utile.
function int(a) {
return a - a === 0 && a.toString(32).indexOf('.') === -1
}
function float(a) {
return a - a === 0 && a.toString(32).indexOf('.') !== -1
}
vous pouvez ajouter typeof a === 'number' si vous voulez exclure les chaînes.
YourJS fournit les deux fonctions suivantes qui fonctionnent pour tous les numéros, y compris le renvoi false pour -Infinity et Infinity :
function isFloat(x) {
return typeOf(x, 'Number') && !!(x % 1);
}
function isInt(x) {
return typeOf(x, 'Number') && x % 1 == 0;
}
en raison du fait que typeOf() est une fonction interne de YourJS, si vous voulez utiliser ces définitions, vous pouvez télécharger la version pour juste ces fonctions ici: http://yourjs.com/snippets/build/34
parfois nombre objets ne vous permettent pas d'utiliser direct l'opérateur mod (%), si vous faites face à ce cas, vous pouvez utiliser cette solution.
if(object instanceof Number ){
if( ((Number) object).doubleValue() % 1 == 0 ){
//your object is an integer
}
else{
//your object is a double
}
}
Cette solution a fonctionné pour moi.
<html>
<body>
<form method="post" action="#">
<input type="text" id="number_id"/>
<input type="submit" value="send"/>
</form>
<p id="message"></p>
<script>
var flt=document.getElementById("number_id").value;
if(isNaN(flt)==false && Number.isInteger(flt)==false)
{
document.getElementById("message").innerHTML="the number_id is a float ";
}
else
{
document.getElementById("message").innerHTML="the number_id is a Integer";
}
</script>
</body>
</html>