Comment vérifier qu'un nombre est flottant ou entier?

Comment trouver qu'un nombre est floatou integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

vérifier 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;
}

Mise à jour 2019 5 ans après la rédaction de cette réponse, une solution a été normalisée dans ECMA Script 2015. Cette solution est couverte dans cette réponse .

Essayez ces fonctions pour tester si une valeur est une valeur primitive numérique qui n'a pas de partie fractionnaire et se situe 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 est actuellement implémentée dans tout sauf IE. MDN fournit également un polyfill pour les autres navigateurs:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

Cependant, pour la plupart des cas d'utilisation, il vaut mieux utiliser Number.isSafeInteger ce qui vérifie également si la valeur est si élevée / basse que les décimales auraient été perdues de toute façon. MDN a également un polyfil pour cela. (Vous avez également besoin du isIntegerpollyfill ci-dessus.)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

Vous pouvez utiliser une expression régulière simple:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

Ou vous pouvez également 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 le type de variable est float et si son contenu est float

ctype_digit() => Vérifier si le type de variable est une chaîne et si son contenu n'a que des chiffres décimaux

Mise à jour 1

Maintenant, il vérifie également les nombres négatifs, merci pour le commentaire @ChrisBartley !

Voici des fonctions efficaces qui vérifient si la valeur est un nombre ou peut être convertie en toute sécurité en 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 (renvoie false si la valeur est un flottant):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

L'efficacité ici est que parseInt (ou parseNumber) est évité lorsque la valeur est déjà un nombre. Les deux fonctions d'analyse se convertissent toujours en chaîne d'abord, puis tentent d'analyser cette chaîne, ce qui serait un gaspillage si la valeur est déjà un nombre.

Merci aux autres articles ici pour avoir fourni d'autres idées d'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 étant un entier? Vérifiez simplement 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); }

Celui-ci, ça va?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

Voici ce que j'utilise pour les entiers:

Math.ceil(parseFloat(val)) === val

Bref, sympa :) Fonctionne tout le temps. C'est ce que suggère David Flanagan si je ne me trompe pas.

Cela dépend vraiment de ce que vous voulez réaliser. Si vous voulez "émuler" des langues fortement typées, je vous suggère de ne pas essayer. Comme d'autres l'ont mentionné, tous les nombres ont la même représentation (le même type).

Utiliser quelque chose comme Claudiu a fourni:

isInteger( 1.0 ) -> vrai

qui semble bien pour le bon sens, mais dans quelque chose comme C, vous obtiendrez false

Tout nombre flottant avec une partie décimale nulle (par exemple 1.0, 12.00, 0.0) est implicitement converti en entier, il n'est donc pas possible de vérifier s'il est flottant ou non.

!!(24%1) // false
!!(24.2%1) // true

Ça n'a pas besoin d'être si compliqué. La valeur numérique des équivalents parseFloat () et parseInt () d'un entier sera la même. Ainsi, vous pouvez faire comme ça:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

alors

if (isInt(x)) // do work

Cela permettra également de vérifier les chaînes et n'est donc pas strict. Si vous voulez une solution de type fort (aka, ne fonctionnera pas avec des chaînes):

function is_int(value){ return !isNaN(parseInt(value * 1) }

var isInt = function (n) { return n === (n | 0); };

Je n'ai pas eu de cas où cela n'a pas fait l'affaire.

CECI EST LE CODE FINAL POUR LA VÉRIFICATION À LA FOIS INT ET FLOTTEUR

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');
}

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 déroute beaucoup de gens. Chaque fois que quelque chose est .0, ce n'est plus un flotteur. C'est un entier. Ou vous pouvez simplement l'appeler "une chose numérique" 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 l'entier en acceptant le fait que 1.000 est un entier.

Note de côté intéressante

Il y a eu un commentaire sur un nombre énorme. Des nombres énormes 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 autre chose que la valeur réelle, donc le test retournera FAUX. C'est une bonne chose car si vous considérez quelque chose comme un "nombre", vous vous attendez normalement à ce que JS puisse calculer avec lui - donc oui, les nombres sont limités et parseInt en tiendra compte , pour le dire de cette façon.

Essaye ça:

<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), cela renvoie "a est correct; b échoue", ce qui est exactement dû au nombre énorme de b. La limite peut varier mais je suppose que 20 chiffres "devraient suffire à tout le monde", pour citer un classique :)

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>

Pour les entiers, j'utilise ceci

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

Dans le script java, tous les nombres sont les internally 64 bit floating pointmêmes que le double en java. Il n'y a pas de types différents en javascript, tous sont représentés par type number. Vous ne pourrez donc pas faire de instanceofchèque. Cependant, vous pouvez utiliser les solutions ci-dessus pour savoir s'il s'agit d'un nombre fractionnaire. les concepteurs de script java ont ressenti avec un seul type qu'ils peuvent éviter de nombreuses erreurs de transtypage.

Parfois, les objets Number ne vous permettent pas d'utiliser directement l'opérateur mod (%), si vous êtes confronté à 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
   }
}

En essayant certaines des réponses ici, j'ai fini par écrire cette solution. Cela fonctionne également avec des nombres à l'intérieur d'une chaîne.

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

Ce n'est peut-être pas aussi performant que la réponse%, ce qui vous empêche d'avoir à convertir d'abord en chaîne, mais je n'ai encore vu personne la publier, alors voici une autre option qui devrait fonctionner correctement:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

Pour les curieux, en utilisant Benchmark.js, j'ai testé les réponses les plus votées (et celle publiée 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 que ce n'est pas une chaîne vide (qui passera autrement), puis la convertit au format numérique. Maintenant, selon que vous voulez que «1.1» soit égal à 1.1, cela peut ou non être 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 true 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", ce qui isNaN () renvoie false sur (que nous annulons ensuite et retournons), mais 1.0 ou "1.0" devient "1.0.0", tandis que "string" devient "string. 0 ", dont aucun n'est un nombre, donc isNaN () renvoie false (et, encore une fois, est annulé).

Si vous ne voulez que 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 avant la valeur à tester. Par exemple, isPositiveInt (1) a pour résultat que isNaN () évalue "01", ce qui est faux. Pendant ce temps, isPositiveInt (-1) a pour résultat que isNaN () évalue "0-1", ce qui est vrai. Nous nions la valeur de retour et cela nous donne ce que nous voulons. isNegativeInt () fonctionne de la même manière, mais sans annuler la valeur de retour de isNaN ().

Éditer:

Mon implémentation d'origine retournerait également true sur les tableaux et les chaînes vides. Cette implémentation n'a pas ce défaut. Il a également l'avantage de revenir plus tôt si val n'est pas une chaîne ou un nombre, ou s'il s'agit d'une chaîne vide, ce qui le rend plus rapide dans ces cas. Vous pouvez le modifier en remplaçant les deux premières clauses par

typeof(val) != "number"

si vous souhaitez uniquement faire correspondre les nombres littéraux (et non les chaînes)

Éditer:

Je ne peux pas encore poster de commentaires, alors j'ajoute ceci à ma réponse. L'indice de référence publié par @Asok est très informatif; cependant, la fonction la plus rapide ne correspond pas aux exigences, car elle renvoie également TRUE pour les flottants, les tableaux, les booléens et les chaînes vides.

J'ai créé la suite de tests suivante pour tester chacune des fonctions, en ajoutant également ma réponse à la liste (fonction 8, qui analyse les chaînes, et fonction 9, qui ne le fait 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 également relancé le benchmark avec la fonction # 8 ajoutée à la liste. Je ne publierai pas le résultat, car ils sont un peu gênants (par exemple, cette fonction n'est PAS rapide) ...

Les résultats (abrégés - j'ai supprimé les tests réussis, car la sortie est assez longue) sont les suivants:

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é des échecs pour que vous puissiez voir où chaque fonction échoue et les tests (chaîne) '#' pour que vous puissiez voir comment chaque fonction gère les valeurs entières et flottantes dans les chaînes, car certains peuvent vouloir que ces analyses soient analysées en tant que nombres et d'autres Peut-être pas.

Sur les 10 fonctions testées, celles qui correspondent réellement aux exigences de l'OP sont [1,3,5,6,8,9]

Condition de validation flottante:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Condition pour la validation entière:

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 souhaitez exclure des chaînes.