Comment vérifier si une variable est un entier en JavaScript?
Comment vérifier si une variable est un entier en JavaScript et envoyer une alerte si ce n'est pas le cas? J'ai essayé ça, mais ça ne marche pas:
<html>
<head>
<script type="text/javascript">
var data = 22;
alert(NaN(data));
</script>
</head>
</html>
Utilisez l'opérateur === ( égalité stricte ) 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 convertir les chaînes en entiers potentiels?
Cela fera:
function isInt(value) {
return !isNaN(value) &&
parseInt(Number(value)) == value &&
!isNaN(parseInt(value, 10));
}
Avec des opérations binaires
Analyse et vérification simples
function isInt(value) {
var x = parseFloat(value);
return !isNaN(value) && (x | 0) === x;
}
Court-circuiter et sauvegarder 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 d'un 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/
Performance
Les tests révèlent que la solution de court-circuit offre les meilleures performances (op/s).
// 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 un repère: http://jsben.ch/#/htLVw
Si vous souhaitez une forme de court-circuit plus courte et obtuse:
function isInt(value) {
var x;
return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}
Bien sûr, je suggérerais de laisser le minificateur s'en occuper.
En supposant que vous ne sachiez rien de la variable en question, vous devriez 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
}
Number.isInteger() semble être la voie à suivre.
MDN a également fourni le polyfill suivant pour les navigateurs ne prenant pas en charge Number.isInteger(), principalement toutes les versions d’IE.
Number.isInteger = Number.isInteger || function(value) {
return typeof value === "number" &&
isFinite(value) &&
Math.floor(value) === value;
};
Vous pouvez vérifier si le nombre a un reste:
var data = 22;
if(data % 1 === 0){
// yes it's an integer.
}
Remarquez que si votre saisie peut également être du texte et que vous souhaitez vérifier en premier lieu, vous pouvez vérifier le type en premier:
var data = 22;
if(typeof data === 'number'){
// yes it is numeric
if(data % 1 === 0){
// yes it's an integer.
}
}
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 que c’est bizarre, roulez avec), et non une "fonction".
Vous devez vérifier à la fois si le type de la variable est un nombre, et pour vérifier le nombre entier, j'utiliserais le module.
alert(typeof data === 'number' && data%1 == 0);
Soyez prudent lorsque vous utilisez
num% 1
chaîne vide ('') ou booléen (vrai ou faux) retournera sous forme d'entier. Vous pourriez ne pas vouloir faire ça
false % 1 // true
'' % 1 //true
Number.isInteger (data)
Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false
fonction intégrée dans le navigateur. Dosnt supporte les anciens navigateurs
Alternatives:
Math.round(num)=== num
Cependant, Math.round () échouera également pour une chaîne vide et un booléen.
Pour vérifier si un entier comme l'affiche veut:
if (+data===parseInt(data)) {return true} else {return false}
notez + devant les données (convertit chaîne en nombre), et === pour exact.
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))){
//-----
}
Pourquoi personne n'a-t-il mentionné Number.isInteger()?
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
Fonctionne parfaitement pour moi et résout le problème avec la NaN commençant un nombre.
La solution la plus simple et la plus propre pré-ECMAScript-6 (qui est également suffisamment robuste pour renvoyer false même si une valeur non numérique telle qu'une chaîne ou une valeur null est transmise à la fonction) serait la suivante:
function isInteger(x) { return (x^0) === x; }
La solution suivante fonctionnerait également, bien que pas aussi élégante que celle ci-dessus:
function isInteger(x) { return Math.round(x) === x; }
Remarque que Math.ceil () ou Math.floor () pourraient être utilisés de la même manière (au lieu de Math.round ()) dans l’implémentation 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 basée sur parseInt fonctionne bien pour de nombreuses valeurs de x, une fois que x devient assez grand, 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 sous forme de chaîne sera présentée sous forme exponentielle (par exemple, 1e + 21). En conséquence, parseInt () essaiera alors d’analyser 1e + 21, mais cessera d’analyser dès qu’il atteindra le caractère e et renverra donc la valeur 1. Observez:
> String(1000000000000000000000)
'1e+21'
> parseInt(1000000000000000000000, 10)
1
> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false
La norme ECMA-262 6.0 (ES6) inclut Number.isInteger function.
Afin de prendre en charge l'ancien navigateur, je vous recommande vivement d'utiliser une solution solide et prise en charge par la communauté parmi:
https://github.com/paulmillr/es6-shim
qui est pure ES6 JS polyfills library.
Notez que cette bibliothèque nécessite es5-shim, suivez simplement README.md.
Vous pouvez essayer Number.isInteger(Number(value)) si value peut être un entier sous forme de chaîne, p.ex. var value = "23" et que vous souhaitez que cela soit évalué à true. Évitez d'essayer Number.isInteger(parseInt(value)) car cela ne renverra pas toujours la valeur correcte. Par exemple, si var value = "23abc" et que vous utilisez l'implémentation parseInt, il renverra quand même true.
Mais si vous voulez des valeurs strictement entières, alors probablement Number.isInteger(value) devrait faire l'affaire.
Vérifiez si la variable est égale à cette même variable arrondie à un entier, comme ceci:
if(Math.round(data) != data) {
alert("Variable is not an integer!");
}
Number.isInteger() est le meilleur moyen si votre navigateur le supporte, sinon, je pense qu'il y a tellement de façons de faire:
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
Toutes ces méthodes fonctionnent donc, mais lorsque le nombre est très grand, l'analyse syntaxique et l'opérateur ^ ne fonctionnent pas correctement.
var x = 1.5;
if(!isNaN(x)){
console.log('Number');
if(x % 1 == 0){
console.log('Integer');
}
}else {
console.log('not a number');
}
De plus, Number.isInteger(). Peut-être que Number.isSafeInteger() est une autre option ici en utilisant l’ES6 spécifié.
Pour polyfill Number.isSafeInteger(..) dans les navigateurs antérieurs à ES6:
Number.isSafeInteger = Number.isSafeInteger || function(num) {
return typeof num === "number" &&
isFinite(num) &&
Math.floor(num) === num &&
Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
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
Ok eu moins, la cause n'a pas décrit mon exemple, donc plus d'exemples :):
J'utilise une expression régulière et une méthode de test:
var isInteger = /^[0-9]\d*$/;
isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false
// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);
De http://www.toptal.com/javascript/interview-questions :
function isInteger(x) { return (x^0) === x; }
J'ai trouvé que c'était le meilleur moyen de le faire.
Pour les valeurs entières positives sans séparateurs:
return ( data !== '' && data === data.replace(/\D/, '') );
Tests 1. si pas vide et 2. si valeur est égale au résultat du remplacement d'un caractère non numérique dans sa valeur.
Utilisez l'opérateur |:
(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true
Donc, 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;
};
Vous pouvez utiliser regexp pour cela:
function isInteger(n) {
return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
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;
}
vous pouvez aussi l'essayer de cette façon
var data = 22;
if (Number.isInteger(data)) {
console.log("integer");
}else{
console.log("not an integer");
}
ou
if (data === parseInt(data, 10)){
console.log("integer");
}else{
console.log("not an integer");
}
Dans ES6, 2 nouvelles méthodes sont ajoutées pour Number Object.
La méthode Number.isInteger () renvoie true si l'argument est un entier.
Exemple d'utilisation:
Number.isInteger(10); // returns true
Number.isInteger(10.5); // returns false
Lodash https://lodash.com/docs#isInteger (depuis la version 4.0.0) permet de vérifier si la variable est un entier:
_.isInteger(3);
// → true
_.isInteger(Number.MIN_VALUE);
// → false
_.isInteger(Infinity);
// → false
_.isInteger('3');
// → false
Je devais vérifier si une variable (chaîne ou nombre) est un 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 (utilisez parseFloat combiné à isNaN), mais la mienne devrait être plus simple et plus explicite.
Edit: j'ai découvert que ma méthode échouait pour les chaînes contenant une virgule (comme "1,2") et que je réalisais également que dans mon cas particulier, je voulais que la fonction échoue si une chaîne n'était pas un entier valide , même 1,0). Alors voici 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, au cas où vous auriez besoin de la fonction pour accepter les nombres entiers flottants (éléments 1.0), 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>
Après quelques succès et échecs, j'ai proposé 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 d'utiliser parseFloat, mais lorsque je l'ai essayé dans l'infrastructure React, 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é. :)
Mon approche:
function isInteger(a){
return a >= 1e+21 ? true : a === (+a|0);
}
// tests
[
1,
1.0,
1.0000000000001,
0.1,
"0",
"1",
"1.1",
4e2,
1000000000000000000000,
NaN,
[],
{},
true,
false,
null,
undefined,
Infinity
].forEach( a => console.log(typeof a, a, isInteger(a)) );