如何在 JavaScript 中检查变量是否为整数，如果不是则抛出警报？我试过这个，但它不起作用：
<html>
<head>
<script type="text/javascript">
var data = 22;
alert(NaN(data));
</script>
</head>
</html>
问问题
675481 次
40 回答
559
这取决于，您是否也想将字符串转换为潜在整数？
这将做：
function isInt(value) {
return !isNaN(value) &&
parseInt(Number(value)) == value &&
!isNaN(parseInt(value, 10));
}
使用按位运算
简单的解析和检查
function isInt(value) {
var x = parseFloat(value);
return !isNaN(value) && (x | 0) === x;
}
短路并保存解析操作：
function isInt(value) {
if (isNaN(value)) {
return false;
}
var x = parseFloat(value);
return (x | 0) === x;
}
或者也许两者合二为一：
function isInt(value) {
return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}
测试：
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
这是小提琴：http: //jsfiddle.net/opfyrqwp/28/
表现
测试表明短路解决方案具有最佳性能 (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;
}
这是一个基准：http: //jsben.ch/#/htLVw
如果您喜欢更短、更钝的短路形式：
function isInt(value) {
var x;
return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}
当然，我建议让 minifier 来解决这个问题。
于 2013-02-10T02:28:15.830 回答
377
使用 === 运算符（严格相等），如下所示，
if (data === parseInt(data, 10))
alert("data is integer")
else
alert("data is not an integer")
于 2013-01-31T22:54:23.497 回答
129
Number.isInteger()似乎是要走的路。
MDN 还为不支持的浏览器提供了以下 polyfill Number.isInteger()，主要是所有版本的 IE。
Number.isInteger = Number.isInteger || function(value) {
return typeof value === "number" &&
isFinite(value) &&
Math.floor(value) === value;
};
于 2014-12-11T14:06:25.620 回答
128
假设您对所讨论的变量一无所知，您应该采用这种方法：
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
}
简而言之：
if(typeof data==='number' && (data%1)===0) {
// data is an integer
}
于 2013-01-31T23:00:42.970 回答
78
您可以检查该数字是否有余数：
var data = 22;
if(data % 1 === 0){
// yes it's an integer.
}
请注意，如果您的输入也可以是文本并且您想先检查它不是，那么您可以先检查类型：
var data = 22;
if(typeof data === 'number'){
// yes it is numeric
if(data % 1 === 0){
// yes it's an integer.
}
}
于 2013-01-31T22:53:17.473 回答
29
您可以使用一个简单的正则表达式：
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
于 2014-11-09T02:24:50.693 回答
22
在ES6中，为 Number Object 添加了 2 个新方法。
如果参数是整数，则Number.isInteger ()方法在其中返回 true ，否则返回 false。
重要提示：对于可以表示为整数的浮点数，该方法也将返回 true。例如： 5.0 （因为它完全等于 5 ）
示例用法：
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(99999999999999999999999); // true
Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false
Number.isInteger(NaN); // false
Number.isInteger(Infinity); // false
Number.isInteger(-Infinity); // false
Number.isInteger('10'); // false
Number.isInteger(true); // false
Number.isInteger(false); // false
Number.isInteger([1]); // false
Number.isInteger(5.0); // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true
于 2019-06-02T09:29:36.260 回答
19
首先，NaN 是一个“数字”（是的，我知道这很奇怪，随它去吧），而不是一个“函数”。
您需要检查变量的类型是否为数字，并检查整数我会使用模数。
alert(typeof data === 'number' && data%1 == 0);
于 2013-01-31T22:49:09.680 回答
14
使用时要小心
人数 % 1
空字符串 ('') 或布尔值（真或假）将作为整数返回。你可能不想这样做
false % 1 // true
'' % 1 //true
Number.isInteger(数据)
Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false
在浏览器中构建函数。Dosnt 支持旧版浏览器
备择方案：
Math.round(num)=== num
但是，对于空字符串和布尔值，Math.round() 也会失败
于 2014-05-18T12:43:48.580 回答
9
要检查像海报这样的整数是否需要：
if (+data===parseInt(data)) {return true} else {return false}
注意数据前面的+（将字符串转换为数字），=== 表示精确。
以下是示例：
data=10
+data===parseInt(data)
true
data="10"
+data===parseInt(data)
true
data="10.2"
+data===parseInt(data)
false
于 2014-07-29T13:10:21.463 回答
6
最简单和最干净的 pre-ECMAScript-6 解决方案（即使将字符串或 null 等非数字值传递给函数，它也足够强大以返回 false）如下：
function isInteger(x) { return (x^0) === x; }
以下解决方案也可以使用，尽管不如上面的解决方案那么优雅：
function isInteger(x) { return Math.round(x) === x; }
请注意，在上述实现中，Math.ceil() 或 Math.floor() 可以同样有效地使用（而不是 Math.round()）。
或者：
function isInteger(x) { return (typeof x === 'number') && (x % 1 === 0); }
一种相当常见的错误解决方案如下：
function isInteger(x) { return parseInt(x, 10) === x; }
虽然这种基于 parseInt 的方法适用于许多 x 值，但一旦 x 变得相当大，它将无法正常工作。问题是 parseInt() 在解析数字之前将其第一个参数强制转换为字符串。因此，一旦数字变得足够大，它的字符串表示就会以指数形式呈现（例如，1e+21）。因此，parseInt() 将尝试解析 1e+21，但在到达 e 字符时将停止解析，因此返回值 1。观察：
> String(1000000000000000000000)
'1e+21'
> parseInt(1000000000000000000000, 10)
1
> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false
于 2017-03-31T06:09:04.363 回答
6
为什么没有人提到Number.isInteger()？
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
对我来说非常有效，并解决了NaN以数字开头的问题。
于 2018-06-06T04:04:50.433 回答
5
if(Number.isInteger(Number(data))){
//-----
}
于 2016-10-14T14:41:20.563 回答
4
检查变量是否等于舍入为整数的同一个变量，如下所示：
if(Math.round(data) != data) {
alert("Variable is not an integer!");
}
于 2013-01-31T22:47:44.863 回答
4
ECMA-262 6.0 (ES6) 标准包括Number.isInteger函数。
为了增加对旧浏览器的支持，我强烈建议使用强大且社区支持的解决方案：
https://github.com/paulmillr/es6-shim
这是纯ES6 JS polyfills 库。
请注意，此库需要 es5-shim，只需遵循 README.md。
于 2015-10-23T12:36:48.740 回答
3
你可以使用这个功能：
function isInteger(value) {
return (value == parseInt(value));
}
即使该值是包含整数值的字符串，它也会返回 true。
因此，结果将是：
alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false
于 2014-02-26T19:02:05.683 回答
3
使用|运算符：
(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true
因此，测试函数可能如下所示：
var isInteger = function (value) {
if (typeof value !== 'number') {
return false;
}
if ((value | 0) !== value) {
return false;
}
return true;
};
于 2014-10-28T18:08:46.727 回答
3
您可以尝试Number.isInteger(Number(value))ifvalue可能是字符串形式的整数，例如var value = "23"，并且您希望它评估为true. 避免尝试Number.isInteger(parseInt(value))，因为这并不总是返回正确的值。例如，如果var value = "23abc"您使用该parseInt实现，它仍然会返回 true。
但是，如果您想要严格的整数值，那么可能Number.isInteger(value)应该做到这一点。
于 2016-10-27T03:59:30.010 回答
3
var x = 1.5;
if(!isNaN(x)){
console.log('Number');
if(x % 1 == 0){
console.log('Integer');
}
}else {
console.log('not a number');
}
于 2017-06-09T16:29:05.303 回答
3
我的做法：
a >= 1e+21→ 只通过非常大的数字。与本讨论中提供的其他解决方案不同，这肯定会涵盖所有情况。
a === (a|0)→ 如果给定函数的参数与按位转换后的值完全相同(===)，则表示参数是整数。
a|0→ 返回0任何不是数字的值a，如果确实是数字，它将去除小数点后的任何内容，因此将变为a1.00011
function isInteger(a){
return a >= 1e+21 ? true : a === (a|0)
}
/// tests ///////////////////////////
[
1, // true
1000000000000000000000, // true
4e2, // true
Infinity, // true
1.0, // true
1.0000000000001, // false
0.1, // false
"0", // false
"1", // false
"1.1", // false
NaN, // false
[], // false
{}, // false
true, // false
false, // false
null, // false
undefined // false
].forEach( a => console.log(typeof a, a, isInteger(a)) )于 2018-09-07T13:51:35.817 回答
3
大整数 ( bigint) 呢？
大多数这些答案在大整数（2 53和更大）上失败：按位测试（例如(x | 0) === x）、测试typeof x === 'number'、常规 int 函数（例如parseInt）、常规算术在大整数上失败。这可以通过使用来解决BigInt。
我已将几个答案编译成一个片段以显示结果。大多数大整数完全失败，而其他工作，除非通过类型BigInt（例如1n）。我没有包括重复的答案，也遗漏了任何允许小数或不尝试测试类型的答案）
// these all fail
n = 1000000000000000000000000000000
b = 1n
// These all fail on large integers
//https://stackoverflow.com/a/14636652/3600709
console.log('fail',1,n === parseInt(n, 10))
//https://stackoverflow.com/a/14794066/3600709
console.log('fail',2,!isNaN(n) && parseInt(Number(n)) == n && !isNaN(parseInt(n, 10)))
console.log('fail',2,!isNaN(n) && (parseFloat(n) | 0) === parseFloat(n))
console.log('fail',2,!isNaN(n) && (function(x) { return (x | 0) === x; })(parseFloat(n)))
//https://stackoverflow.com/a/21742529/3600709
console.log('fail',3,n == ~~n)
//https://stackoverflow.com/a/28211631/3600709
console.log('fail',4,!isNaN(n) && parseInt(n) == parseFloat(n))
//https://stackoverflow.com/a/41854178/3600709
console.log('fail',5,String(parseInt(n, 10)) === String(n))
// These ones work for integers, but not BigInt types (e.g. 1n)
//https://stackoverflow.com/a/14636725/3600709
console.log('partial',1,typeof n==='number' && (n%1)===0) // this one works
console.log('partial',1,typeof b==='number' && (b%1)===0) // this one fails
//https://stackoverflow.com/a/27424770/3600709
console.log('partial',2,Number.isInteger(n)) // this one works
console.log('partial',2,Number.isInteger(b)) // this one fails
//https://stackoverflow.com/a/14636638/3600709
console.log('partial',3,n % 1 === 0)
console.log('partial',3,b % 1 === 0) // gives uncaught type on BigInt检查类型
如果您确实想测试传入值的类型以确保它是整数，请改用：
function isInt(value) {
try {
BigInt(value)
return !['string','object','boolean'].includes(typeof value)
} catch(e) {
return false
}
}
function isInt(value) {
try {
BigInt(value)
return !['string','object','boolean'].includes(typeof value)
} catch(e) {
return false
}
}
console.log('--- should be false')
console.log(isInt(undefined))
console.log(isInt(''))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt([]))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(true))
console.log(isInt(NaN))
console.log(isInt('1'))
console.log(isInt(function(){}))
console.log(isInt(Infinity))
console.log('--- should be true')
console.log(isInt(10))
console.log(isInt(0x11))
console.log(isInt(0))
console.log(isInt(-10000))
console.log(isInt(100000000000000000000000000000000000000))
console.log(isInt(1n))不检查类型
如果您不关心传入的类型是否实际上是布尔值、字符串等转换为数字，那么只需使用以下内容：
function isInt(value) {
try {
BigInt(value)
return true
} catch(e) {
return false
}
}
function isInt(value) {
try {
BigInt(value)
return true
} catch(e) {
return false
}
}
console.log('--- should be false')
console.log(isInt(undefined))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(NaN))
console.log(isInt(function(){}))
console.log(isInt(Infinity))
console.log('--- should be true')
console.log(isInt(10))
console.log(isInt(0x11))
console.log(isInt(0))
console.log(isInt(-10000))
console.log(isInt(100000000000000000000000000000000000000))
console.log(isInt(1n))
// gets converted to number
console.log(isInt(''))
console.log(isInt([]))
console.log(isInt(true))
console.log(isInt('1'))于 2021-02-10T21:14:53.720 回答
2
此外，Number.isInteger(). 也许是使用 ES6 指定的另Number.isSafeInteger()一种选择。
在Number.isSafeInteger(..)ES6 之前的浏览器中进行 polyfill：
Number.isSafeInteger = Number.isSafeInteger || function(num) {
return typeof num === "number" &&
isFinite(num) &&
Math.floor(num) === num &&
Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
于 2015-12-25T08:17:33.520 回答
2
Number.isInteger()如果您的浏览器支持它是最好的方法，如果没有，我认为有很多方法可以去：
function isInt1(value){
return (value^0) === value
}
或者：
function isInt2(value){
return (typeof value === 'number') && (value % 1 === 0);
}
或者：
function isInt3(value){
return parseInt(value, 10) === value;
}
或者：
function isInt4(value){
return Math.round(value) === value;
}
现在我们可以测试结果：
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
因此，所有这些方法都是可行的，但是当数量很大时，parseInt 和 ^ 运算符就无法正常工作。
于 2016-01-18T05:49:55.113 回答
2
试试这个：
let number = 5;
if (Number.isInteger(number)) {
//do something
}
于 2019-11-18T17:33:50.297 回答
2
“接受”的答案是错误的（正如下面的一些评论指出的那样）。这种修改可以使它工作：
if (data.toString() === parseInt(data, 10).toString())
alert("data is a valid integer")
else
alert("data is not a valid integer")
于 2020-08-20T09:15:33.937 回答
1
您可以为此使用正则表达式：
function isInteger(n) {
return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
于 2014-02-11T12:13:10.200 回答
1
function isInteger(argument) { return argument == ~~argument; }
用法：
isInteger(1); // true<br>
isInteger(0.1); // false<br>
isInteger("1"); // true<br>
isInteger("0.1"); // false<br>
或者：
function isInteger(argument) { return argument == argument + 0 && argument == ~~argument; }
用法：
isInteger(1); // true<br>
isInteger(0.1); // false<br>
isInteger("1"); // false<br>
isInteger("0.1"); // false<br>
于 2014-02-12T23:53:36.227 回答
1
来自http://www.toptal.com/javascript/interview-questions：
function isInteger(x) { return (x^0) === x; }
发现这是最好的方法。
于 2014-10-02T12:20:54.607 回答
1
这将解决另一个场景（121.），最后一个点
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;
}
于 2015-06-09T09:48:39.380 回答
1
对于没有分隔符的正整数值：
return ( data !== '' && data === data.replace(/\D/, '') );
测试 1. 如果不为空和 2. 如果 value 等于在其 value 中替换 non-digit char 的结果。
于 2015-06-25T15:44:12.653 回答
1
你也可以这样试试
var data = 22;
if (Number.isInteger(data)) {
console.log("integer");
}else{
console.log("not an integer");
}
或者
if (data === parseInt(data, 10)){
console.log("integer");
}else{
console.log("not an integer");
}
于 2018-10-11T17:56:01.877 回答
1
接受的答案对我不起作用，因为我需要检查 int/float 和字母表。所以试试这个对 int/float 和字母检查都有效
function is_int(value){
if( (parseInt(value) % 1 === 0 )){
return true;
}else{
return false;
}
}
用法
is_int(44); // true
is_int("44"); // true
is_int(44.55); // true
is_int("44.55"); // true
is_int("aaa"); // false
于 2021-08-24T18:05:31.523 回答
0
我必须检查变量（字符串或数字）是否为整数，我使用了这个条件：
function isInt(a){
return !isNaN(a) && parseInt(a) == parseFloat(a);
}
http://jsfiddle.net/e267369d/1/
其他一些答案有类似的解决方案（依靠与parseFloat结合isNaN），但我的应该更直接和自我解释。
编辑：我发现我的方法对于包含逗号的字符串（如“1,2”）失败，我还意识到，在我的特殊情况下，如果字符串不是有效的整数，我希望函数失败（应该在任何浮点数上失败，甚至 1.0)。所以这是我的功能 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/
当然，如果您确实需要该函数来接受整数浮点数（1.0 的东西），您可以随时删除点条件a.indexOf('.') == -1。
于 2015-01-29T09:55:46.333 回答
0
Lodash https://lodash.com/docs#isInteger（自 4.0.0 起）具有检查变量是否为整数的功能：
_.isInteger(3);
// → true
_.isInteger(Number.MIN_VALUE);
// → false
_.isInteger(Infinity);
// → false
_.isInteger('3');
// → false
于 2016-03-30T20:02:59.500 回答
0
在几次成功和失败之后，我想出了这个解决方案：
const isInt = (value) => {
return String(parseInt(value, 10)) === String(value)
}
我喜欢上面检查值是否不是 NaN 并使用 parseFloat 的想法，但是当我在 React 基础架构中尝试它时，由于某种原因它不起作用。
编辑：我找到了一种不使用字符串的更好方法：
var isInt = function (str) {
return str === '0' || !!~~str;
}
我认为这是最短的答案。甚至可能是最有效的，但我可以得到纠正。:)
于 2017-01-25T14:32:00.047 回答
0
好的，减去了，原因没有描述我的例子，所以更多的例子:)：
我使用正则表达式和测试方法：
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);
于 2017-12-20T12:11:03.983 回答
0
答案中有很多选择。
isNaN对于纯整数可能很棘手，您仍然需要其他检查使其过时。
Number.isInteger()在 IE 中不受官方支持（大多数人不在乎，但那里有落后者）。
我最终自己写了一些东西：
function isInteger(valueToCheck) {
return typeof valueToCheck !== 'undefined'
&& (valueToCheck === parseInt(valueToCheck, 10));
}
测试
let undefinedValue;
const testValues = [
1,
'',
undefinedValue,
1.1,
'1',
'1.1',
'1-2',
'bob',
false,
[],
[1],
{},
{foo: 1}
];
testValues.forEach(value => {
console.log(`${value} - ${isInteger(value)}`);
})
结果：
1 - true
'' - false
undefined - false
1.1 - false
'1' - false
'1.1' - false
'1-2' - false
'bob' - false
false - false
[] - false
[1] - false
{} - false
{foo: 1} - false
一些测试值是多余的，但它们的存在清楚地表明没有任何东西可以通过。你可以省略函数中的未定义检查，但我发现未定义的东西在 JS 中可能很奇怪，所以感觉更安全。
于 2021-04-26T17:54:45.950 回答
-1
尝试以下功能：
function isInteger (num) {
return num == parseInt(+num,10) && !isNaN(parseInt(num));
}
console.log ( isInteger(42)); // true
console.log ( isInteger("42")); // true
console.log ( isInteger(4e2)); // true
console.log ( isInteger("4e2")); // true
console.log ( isInteger(" 1 ")); // true
console.log ( isInteger("")); // false
console.log ( isInteger(" ")); // false
console.log ( isInteger(42.1)); // false
console.log ( isInteger("1a")); // false
console.log ( isInteger("4e2a")); // false
console.log ( isInteger(null)); // false
console.log ( isInteger(undefined)); // false
console.log ( isInteger(NaN)); // false
console.log ( isInteger(false)); // false
console.log ( isInteger(true)); // false
console.log ( isInteger(Infinity)); // false
于 2016-12-19T16:05:42.247 回答
-2
您可以使用正则表达式来执行此操作：
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;}
}
false如果数据不是整数，它将返回，true否则。
于 2015-05-27T15:50:13.797 回答
-2
为文本框添加类 numOnly，
$(document).on("input", ".numOnly", function(e) {
this.value = this.value.replace(/[^0-9\$]/g,'');
if(this.value!=""){
alert('Integer Number.');
}else{
alert('Not an Integer Number.');
}
});
它对我有用..试试这个
您可以使用 keypres、keyup、keydown 等代替输入。
于 2016-01-07T07:20:25.847 回答