Comment vérifier si une variable est un nombre entier en JavaScript?

Utilisez l'opérateur === comme ci-dessous

 if (data === parseInt(data, 10)) alert("data is integer") else alert("data is not an integer") 

Cela dépend, voulez-vous également jeter des chaînes en tant que nombres entiers potentiels?

Cela fera:

 function isInt(value) { return !isNaN(value) && parseInt(Number(value)) == value && !isNaN(parseInt(value, 10)); } 

Avec les opérations Bitwise

Analyse et vérification simples

 function isInt(value) { var x = parseFloat(value); return !isNaN(value) && (x | 0) === x; } 

Court-circuit et sauvegarde une opération d'analyse:

 function isInt(value) { if (isNaN(value)) { return false; } var x = parseFloat(value); return (x | 0) === x; } 

Ou peut-être les deux en un seul coup:

 function isInt(value) { return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value)) } 

Tests:

 isInt(42) // true isInt("42") // true isInt(4e2) // true isInt("4e2") // true isInt(" 1 ") // true isInt("") // false isInt(" ") // false isInt(42.1) // false isInt("1a") // false isInt("4e2a") // false isInt(null) // false isInt(undefined) // false isInt(NaN) // false 

Voici le violon: http://jsfiddle.net/opfyrqwp/28/

Voici le yolpo: http://www.yolpo.com/embed.html?gist=a3c46f837ea7bbb708ae&autoplay=2

Performance

Les tests révèlent que la solution de court-circuit a la meilleure performance (ops / sec).

 // Short-circuiting, and saving a parse operation function isInt(value) { var x; if (isNaN(value)) { return false; } x = parseFloat(value); return (x | 0) === x; } 

Voici une référence: http://jsben.ch/#/htLVw

Si vous voulez une forme plus courte et obtuse de court-circuit:

 function isInt(value) { var x; return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x); } 

Bien sûr, je suggère de laisser le minificateur prendre soin de ça.

En supposant que vous ne savez rien de la variable en question, vous devez adopter cette approche:

 if(typeof data === 'number') { var remainder = (data % 1); if(remainder === 0) { // yes, it is an integer } else if(isNaN(remainder)) { // no, data is either: NaN, Infinity, or -Infinity } else { // no, it is a float (still a number though) } } else { // no way, it is not even a number } 

Pour le dire simplement:

 if(typeof data==='number' && (data%1)===0) { // data is an integer } 

Vous pouvez vérifier si le numéro a un reste:

 var data = 22; if(data % 1 === 0){ // yes it's an integer. } 

Attention, si votre contribution pourrait également être du texte et que vous souhaitez vérifier d'abord, ce n'est pas le cas, vous pouvez d'abord vérifier le type:

 var data = 22; if(typeof data === 'number'){ // yes it is numeric if(data % 1 === 0){ // yes it's an integer. } } 

Number.isInteger() semble être le chemin à parcourir.

MDN a également fourni le polyfill suivant pour les navigateurs ne supportant pas Number.isInteger() , principalement toutes les versions d'IE.

Lien vers la page MDN

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

Faites attention lors de l'utilisation

Num% 1

La chaîne vide ('') ou booléenne (vraie ou fausse) revient en nombre entier. Vous pourriez ne pas vouloir faire cela

 false % 1 // true '' % 1 //true 

Number.isInteger (données)

 Number.isInteger(22); //true Number.isInteger(22.2); //false Number.isInteger('22'); //false 

Créer une fonction dans le navigateur. Dosnt prend en charge les navigateurs plus anciens

Alternatives:

 Math.round(num)=== num 

Cependant, Math.round () échouera également pour la chaîne vide et le boolean

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

 function isInt(value) { var er = /^-?[0-9]+$/; return er.test(value); } 

Tout d'abord, NaN est un "nombre" (oui, je sais qu'il est étrange, il suffit de rouler avec lui), et non une "fonction".

Vous devez vérifier les deux si le type de la variable est un nombre, et pour vérifier l'entier, j'utiliserai le module.

 alert(typeof data === 'number' && data%1 == 0); 

Pour vérifier si l'entier veut l'affiche:

 if (+data===parseInt(data)) {return true} else {return false} 

Note + en face de données (convertit la chaîne en nombre) et === pour l'exacte.

Voici des exemples:

 data=10 +data===parseInt(data) true data="10" +data===parseInt(data) true data="10.2" +data===parseInt(data) false 

 if(Number.isInteger(Number(data))){ //----- } 

Vous pouvez essayer Number.isInteger(Number(value)) si la value peut être un nombre entier en forme de chaîne, par exemple var value = "23" et vous souhaitez que cette valeur soit true . Évitez d'essayer Number.isInteger(parseInt(value)) car cela ne renverra pas toujours la valeur correcte. Par exemple, si var value = "23abc" et vous utilisez l'implémentation parseInt , elle renverrait toujours true.

Mais si vous voulez des valeurs strictement entières, probablement Number.isInteger(value) devrait faire l'affaire.

Vérifiez si la variable est égale à cette même variable arrondie à un nombre entier, comme ceci:

 if(Math.round(data) != data) { alert("Variable is not an integer!"); } 

La norme ECMA-262 6.0 (ES6) comprend la fonction Number.isInteger .

Afin d'ajouter un support pour un ancien navigateur, je recommande fortement d'utiliser une solution forte et compatible avec la communauté à partir de:

https://github.com/paulmillr/es6-shim

Qui est la bibliothèque de polyfills ES6 JS pure.

Notez que cette lib requiert es5-shim, il suffit de suivre README.md.

Number.isInteger() est la meilleure façon si votre navigateur le prend en charge, sinon, je pense qu'il existe tellement de façons d'aller:

 function isInt1(value){ return (value^0) === value } 

ou:

 function isInt2(value){ return (typeof value === 'number') && (value % 1 === 0); } 

ou:

 function isInt3(value){ return parseInt(value, 10) === value; } 

ou:

 function isInt4(value){ return Math.round(value) === value; } 

Maintenant nous pouvons tester les résultats:

 var value = 1 isInt1(value) // return true isInt2(value) // return true isInt3(value) // return true isInt4(value) // return true var value = 1.1 isInt1(value) // return false isInt2(value) // return false isInt3(value) // return false isInt4(value) // return false var value = 1000000000000000000 isInt1(value) // return false isInt2(value) // return true isInt3(value) // return false isInt4(value) // return true var value = undefined isInt1(value) // return false isInt2(value) // return false isInt3(value) // return false isInt4(value) // return false var value = '1' //number as string isInt1(value) // return false isInt2(value) // return false isInt3(value) // return false isInt4(value) // return false 

Donc, toutes ces méthodes sont des travaux, mais lorsque le nombre est très important, parseInt et ^ operator ne fonctionnera pas bien.

La solution pré-ECMAScript-6 la plus simple et la plus propre (qui est également suffisamment robuste pour renvoyer false même si une valeur non numérique telle qu'une chaîne ou un null est transmise à la fonction) serait la suivante:

 function isInteger(x) { return (x^0) === x; } 

La solution suivante fonctionnerait également, mais pas aussi élégante que celle ci-dessus:

 function isInteger(x) { return Math.round(x) === x; } 

Notez que Math.ceil () ou Math.floor () pourrait être utilisé également bien (au lieu de Math.round ()) dans la mise en œuvre ci-dessus.

Ou bien:

 function isInteger(x) { return (typeof x === 'number') && (x % 1 === 0); } 

Une solution incorrecte assez courante est la suivante:

 function isInteger(x) { return parseInt(x, 10) === x; } 

Bien que cette approche parseInt-based fonctionne bien pour de nombreuses valeurs de x, une fois que x devient assez large, il ne fonctionnera pas correctement. Le problème est que parseInt () contraint son premier paramètre à une chaîne avant d'analyser les chiffres. Par conséquent, une fois que le nombre devient suffisamment grand, sa représentation de chaîne sera présentée sous forme exponentielle (p. Ex., 1e + 21). En conséquence, parseInt () essayera ensuite d'analyser 1e + 21, mais cessera d'analyser quand il atteindra le caractère e et renverra donc une valeur de 1. Observez:

 > String(1000000000000000000000) '1e+21' > parseInt(1000000000000000000000, 10) 1 > parseInt(1000000000000000000000, 10) === 1000000000000000000000 false 

Vous pouvez utiliser regexp pour ceci:

 function isInteger(n) { return (typeof n == 'number' && /^-?\d+$/.test(n+'')); } 

En outre, Number.isInteger() . Peut-être Number.isSafeInteger() est une autre option ici en utilisant ES6-spécifié.

Pour polyfill Number.isSafeInteger(..) dans les navigateurs pré-ES6:

 Number.isSafeInteger = Number.isSafeInteger || function(num) { return typeof num === "number" && isFinite(num) && Math.floor(num) === num && Math.abs( num ) <= Number.MAX_SAFE_INTEGER; }; 

À partir de http://www.toptal.com/javascript/interview-questions :

 function isInteger(x) { return (x^0) === x; } 

On a trouvé que c'était la meilleure façon de le faire.

Utilisez le | opérateur:

 (5.3 | 0) === 5.3 // => false (5.0 | 0) === 5.0 // => true 

Ainsi, une fonction de test pourrait ressembler à ceci:

 var isInteger = function (value) { if (typeof value !== 'number') { return false; } if ((value | 0) !== value) { return false; } return true; }; 

Cela résoudra un autre scénario ( 121. ), un point à la fin

 function isInt(value) { var ind = value.indexOf("."); if (ind > -1) { return false; } if (isNaN(value)) { return false; } var x = parseFloat(value); return (x | 0) === x; } 

Pour des valeurs entières positives sans séparateurs:

 return ( data !== '' && data === data.replace(/\D/, '') ); 

Essais 1. sinon vide et 2. si la valeur est égale au résultat d'un remplacement d'un caractère non numérique dans sa valeur.

Vous pouvez utiliser cette fonction:

 function isInteger(value) { return (value == parseInt(value)); } 

Il renverra true même si la valeur est une chaîne contenant une valeur entière.
Donc, les résultats seront:

 alert(isInteger(1)); // true alert(isInteger(1.2)); // false alert(isInteger("1")); // true alert(isInteger("1.2")); // false alert(isInteger("abc")); // false 

J'ai dû vérifier si une variable (chaîne ou nombre) est un nombre entier et j'ai utilisé cette condition:

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

http://jsfiddle.net/e267369d/1/

Certaines des autres réponses ont une solution similaire (s'appuyer sur parseFloat combiné avec isNaN ), mais la mienne devrait être plus simple et explicite.

Edit: J'ai découvert que ma méthode échoue pour les chaînes contenant des virgules (comme "1,2") et j'ai également réalisé que dans mon cas particulier, je veux que la fonction échoue si une chaîne n'est pas un entier valide (devrait échouer sur un flotteur , Même 1,0). Voici donc ma fonction Mk II:

 function isInt(a){ return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1)); } 

http://jsfiddle.net/e267369d/3/

Bien sûr, dans le cas où vous avez réellement besoin de la fonction d'accepter des flotteurs entiers (1.0 choses), vous pouvez toujours supprimer la condition de point a.indexOf('.') == -1 .

 function isInteger(argument) { return argument == ~~argument; } 

Usage:

 isInteger(1); // true<br> isInteger(0.1); // false<br> isInteger("1"); // true<br> isInteger("0.1"); // false<br> 

ou:

 function isInteger(argument) { return argument == argument + 0 && argument == ~~argument; } 

Usage:

 isInteger(1); // true<br> isInteger(0.1); // false<br> isInteger("1"); // false<br> isInteger("0.1"); // false<br> 

Lodash https://lodash.com/docs#isInteger (depuis 4.0.0) a la fonction de vérifier si la variable est un nombre entier:

 _.isInteger(3); // → true _.isInteger(Number.MIN_VALUE); // → false _.isInteger(Infinity); // → false _.isInteger('3'); // → false 

Après quelques succès et échecs, j'ai trouvé cette solution:

 const isInt = (value) => { return String(parseInt(value, 10)) === String(value) } 

J'ai aimé l'idée ci-dessus de vérifier la valeur pour ne pas être NaN et utiliser parseFloat, mais lorsque je l'ai essayé dans React infrastructure, cela n'a pas fonctionné pour une raison quelconque.

Edit: J'ai trouvé un moyen plus agréable sans utiliser de chaînes:

 var isInt = function (str) { return str === '0' || !!~~str; } 

Je pense que c'est la réponse la plus courte. Peut-être même le plus efficace, mais je pourrais être corrigé. 🙂

 var x = 1.5; if(!isNaN(x)){ console.log('Number'); if(x % 1 == 0){ console.log('Integer'); } }else { console.log('not a number'); } 

Function isInteger (x) {return (x ^ 0) === x; } La solution suivante fonctionnerait également, mais pas aussi élégante que celle

au dessus:

Function isInteger (x) {return Math.round (x) === x; } Notez que Math.ceil () ou Math.floor () pourrait être utilisé également bien (au lieu de Math.round ()) dans la mise en œuvre ci-dessus.

Ou encore: function isInteger (x) {return (typeof x === 'number') && (x% 1 === 0); }

Une solution incorrecte assez courante est la suivante:

Function isInteger (x) {return parseInt (x, 10) === x; }

Bien que cette approche parseInt-based fonctionne bien pour de nombreuses valeurs de x, une fois que x devient assez large, il ne fonctionnera pas correctement. Le problème est que parseInt () contraint son premier paramètre à une chaîne avant d'analyser les chiffres. Par conséquent, une fois que le nombre devient suffisamment grand, sa représentation de chaîne sera présentée sous forme exponentielle (p. Ex., 1e + 21). En conséquence, parseInt () essayera ensuite d'analyser 1e + 21, mais cessera d'analyser quand il atteindra le caractère e et renverra donc une valeur de 1. Observez:

String (1000000000000000000000) '1e + 21'

ParseInt (1000000000000000000000, 10) 1

ParseInt (1000000000000000000000, 10) === 1000000000000000000000 false

Vous pouvez utiliser regexp pour effectuer ceci:

 function isInt(data){ if(typeof(data)=='number'){ var patt=/^[0-9e+]+$/; data=data+""; data=data.match(patt); if(data==null){return false;} else {return true;}} else{return false;} } 

Il renverra false si les données ne sont pas des nombres entiers, sinon sinon.

Il fonctionne pour moi … Essayez celui-ci ..

 $(document).on("input", ".numOnly", function(e) { this.value = this.value.replace(/[^0-9\$]/g,''); }); 

Vous pouvez utiliser la touche, la touche, la déviation, etc., au lieu d'entrer.