如何检查数字是浮点数还是整数？
Posted
技术标签:
【中文标题】如何检查数字是浮点数还是整数？【英文标题】：How do I check that a number is float or integer? 【发布时间】：2011-04-22 14:21:15 【问题描述】：如何找到一个号码是float或integer？
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
【问题讨论】：
我明白你在这里问什么，但要明确一点：<nit-pick> javascript 没有不同的整数和浮点数类型。 JavaScript 中的每个数字都只是一个Number。 </nit-pick>
就您而言，Infinity是整数还是非整数值？这里的答案在这个分数上分布得相当均匀。
@MikeSamuel 在数学上准确地说：由于无穷大不是实数，所有整数都是实数，Infinity 不能被视为整数。
@rvighne，我认为我们同意无穷大和 NaN 不是实数这一事实意味着 IEEE-754 浮点数不是实数的子集。所有基于 IEEE-754 的数值分析都必须处理这个事实。我不明白的是你认为这个事实如何决定 is_integral 应该如何表现 w.r.t.基数。就个人而言，我认为 ((x % 1) == 0) 是一个很好的代理，并且完全由 IEEE-754 指定，因此无需争论不同数行之间的对应关系。
你考虑1.0整数还是浮点数？
【参考方案1】：
除以 1 时检查余数：
function isInt(n)
return n % 1 === 0;
如果你不知道参数是一个数字，你需要两个测试：
function isInt(n)
return Number(n) === n && n % 1 === 0;
function isFloat(n)
return Number(n) === n && n % 1 !== 0;
2019 年更新 在编写此答案 5 年后，ECMA Script 2015 中标准化了一个解决方案。该解决方案已涵盖in this answer。
【讨论】：
小心，这对于空字符串也会返回true，表示整数的字符串，true，false，null，空数组，包含单个整数的数组, 一个包含表示整数的字符串的数组，可能更多。
不错的技巧，但不是正确的答案，因为它无法检查空字符串 "" 和 1.0 isInt(""); && isInt(1.0); 两者都导致 true 看到这个演示 jsbin.com/elohuq/1/edit跨度>
Ina，通常鼓励使用 === 而不是 ==，因为它会带来更多的类型安全性和更可预测的统一行为。正如之前的回答者所说，这个答案绝对是 100% 不正确的。值 null、空字符串、1.0 和许多其他值都会错误地注册为整数（即使使用 === 检查）。
问题是如何检查一个数字是否为整数，而不是如何检查任何值。
很多敌对的 cmets 关于它如何不验证字符串。这不是OP问题的一部分。如果我去 SO 询问有关检索数组的最后一个元素的问题并且有人用function last (array) return array[array.length - 1]; 回答，是“只是错误”还是“SO 上的最差答案”，因为它不检查参数是否是数组第一的？是的，检查参数的好习惯，但这是开发人员的责任。所以答案应该简短，并尽可能清楚地直接回答问题。【参考方案2】：
尝试使用这些函数来测试一个值是否是一个没有小数部分并且在可以表示为精确整数的大小限制内的数字原始值。
function isFloat(n)
return n === +n && n !== (n|0);
function isInteger(n)
return n === +n && n === (n|0);
【讨论】：
嘿，真棒漏洞利用，它几乎是我的（n===+n 用于检查数字，n|0 用于舍入），但具有内置运算符。时髦
@John Hartsock 字符串永远不会是数值。这是一个字符串。这个函数的目的是测试一个值是否是一个没有小数部分并且在可以表示为精确整数的大小限制内的 Javascript 数值。如果你想检查一个字符串，看看它是否包含代表数字的字符序列，你应该先调用parseFloat()。
@John Hartsock：除非传递了数字原语，否则它不会返回 true。考虑到函数的名称，我认为这是有道理的。如果正在编写此类函数，则其他任何内容都应该是 isString、isBoolean 等的候选对象。
@Pointy：双精度浮点数可以表示精确到 2^53 的整数值。因此，这取决于 OP 是在数学意义上（整数）还是在 32 位数据意义上询问整数。如果是后者，那么您的解决方案就是完美的。
在 javascript 中，像 | (OR) 这样的位运算符只对有符号的 32 位整数进行操作。 OP 没有说明目标是否是检查有符号的 int32 值。所以这不适用于超出范围的数字。 isInteger(5000000000) 将返回 false 这是错误的！【参考方案3】：
有一个名为Number.isInteger() 的方法目前在除 IE 之外的所有应用程序中实现。 MDN 还为其他浏览器提供了一个 polyfill：
Number.isInteger = Number.isInteger || function(value)
return typeof value === 'number' &&
isFinite(value) &&
Math.floor(value) === value;
;
但是，对于大多数用例，您最好使用Number.isSafeInteger，它还会检查值是否太高/太低以至于任何小数位都会丢失。 MDN 也有一个 polyfil。 （您还需要上面的isInteger pollyfill。）
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;
;
【讨论】：
在我看来是最好的解决方案。Number.isInteger(12.0) //true（Chrome，2017 年 2 月）
这与 polyfill 是最可靠和最简单的解决方案。
@SergeyPanfilov 12.0 ∈ ℤ.
我不知道自提供此答案以来规范是否发生了变化，但请注意，上述函数不是 Number.isInteger 的正确 polyfill。然而，它是 Number.isSafeInteger 的正确 polyfill。 Number.isInteger 不应该检查数字是否是“安全整数”。参见 MDN：isInteger 和 isSafeInteger。【参考方案4】：
为什么不这样：
var isInt = function(n) return parseInt(n) === n ;
【讨论】：
这对我来说实际上是一个好的解决方案的核心。我需要允许正整数并禁止浮点数、字符串和负整数。 这似乎是比该线程中的其他解决方案更好的解决方案。也许社区可以提出一些批评？ var y = 1.00; y === parseInt(y, 10); // 这对我来说返回 true，这并不是我们真正想要的。 @ekussberg：为什么要返回 false？ 1 是一个整数。第二个参数 02 被忽略。 −1 因为将数字转换为字符串，然后将其解析回数字只是为了检查是否会产生相同的值，这是一个荒谬的复杂性，而真正需要的是检查是否一个数字——已经是浮点形式！——是一个整数。【参考方案5】：你可以使用一个简单的正则表达式：
function isInt(value)
var er = /^-?[0-9]+$/;
return er.test(value);
或者您也可以根据需要使用以下功能。它们是由phpJS Project 开发的。
is_int() => 检查变量类型是否为整数，其内容是否为整数
is_float() => 检查变量类型是否为浮点数，其内容是否为浮点数
ctype_digit() => 检查变量类型是否为字符串，其内容是否只有十进制数字
更新 1
现在它也检查负数，感谢@ChrisBartley comment！
【讨论】：
非常适合测试简单的无符号整数。 一个班轮：/^[0-9]+$/.test(String(value))
较短且可读性稍差的单行：/^[0-9]+$/.test(''+value)
不处理负整数。您也不需要三元运算符，因为 test() 返回一个布尔值。应该这样做：return /^-?\d+$/.test(String(value));
@ChrisBartley，谢谢！我做了更新，包括你的学分。请检查现在是否一切正常。【参考方案6】：
以下是检查值是否为数字或是否可以安全地转换为数字的高效函数：
function isNumber(value)
if ((undefined === value) || (null === value))
return false;
if (typeof value == 'number')
return true;
return !isNaN(value - 0);
对于整数（如果值为浮点数，则返回 false）：
function isInteger(value)
if ((undefined === value) || (null === value))
return false;
return value % 1 == 0;
这里的效率是当值已经是数字时避免使用parseInt（或parseNumber）。两个解析函数总是先转换成字符串，然后再尝试解析那个字符串，如果值已经是一个数字，那就太浪费了。
感谢这里的其他帖子提供进一步的优化建议！
【讨论】：
此函数在空字符串上失败：isNumber('') 为真。【参考方案7】：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
【讨论】：
显然，以 .0 结尾的浮点数在 JavaScript 中会自动转换为 Int。 以1.2 失败。始终使用 0.1 0.2 0.3 测试数值函数
@LukasLiesis 不适合我。
这里不需要任何严格的相等运算符。
isFloat(1563457121531) 返回 false【参考方案8】：
function isInt(n)
return n != "" && !isNaN(n) && Math.round(n) == n;
function isFloat(n)
return n != "" && !isNaN(n) && Math.round(n) != n;
适用于所有情况。
【讨论】：
+1 这很好。isInt('1') 按预期返回true（至少对我而言）。不过，这很奇怪，这会将true 也返回到isInt([5])。对我来说没关系，但对你来说可能，所以，小心点。
isFloat(12.0) 为假【参考方案9】：
这个怎么样？
isFloat(num)
return typeof num === "number" && !Number.isInteger(num);
【讨论】：
试试console.log(isFloat(1.0)); 结果是假的。
isFloat(NaN) 和 isFloat(Infinity) 返回 true :/【参考方案10】：
正如其他人提到的，您在 JS 中只有双打。那么你如何定义一个数字是一个整数呢？只需检查四舍五入的数字是否等于自身：
function isInteger(f)
return typeof(f)==="number" && Math.round(f) == f;
function isFloat(f) return typeof(f)==="number" && !isInteger(f);
【讨论】：
可能要检查该值是否为数字...isFloat('abc') 返回true
isFloat(NaN) // true
@shime：很好。 NaN 从技术上讲是一个浮点数……这取决于我认为的用例。【参考方案11】：
这是我用于整数的：
Math.ceil(parseFloat(val)) === val
简短，不错 :) 一直有效。如果我没记错的话，这就是 David Flanagan 的建议。
【讨论】：
我喜欢这个，因为它是一个简短而简单的答案，不依赖于神秘的按位运算。 为什么是parseFloat？【参考方案12】：
!!(24%1) // false
!!(24.2%1) // true
【讨论】：
!!(24.0%1) 为假【参考方案13】：
var isInt = function (n) return n === (n | 0); ;
还没有出现过这种情况不起作用的情况。
【讨论】：
嘿抱歉为什么返回假？ console.log(isInt(7932938942839482938)); 因为它超过了 MaxInt。 但是你可以设置一个 Int 最大长度不是吗？如果我不知道返回的 int 长度怎么办？ @ekussberg 是的，因为2 是一个整数，23 被认为是函数的第二个参数。在 javascript 中，小数点是使用点作为分隔符编写的 - 所以它应该是 2.23。
或者这是学习按位运算的好机会。今后您将从中获益良多。【参考方案14】：
这真的取决于你想要实现什么。如果您想“模拟”强类型语言，那么我建议您不要尝试。正如其他人提到的，所有数字都具有相同的表示形式（相同的类型）。
使用类似 Claudiu 提供的东西：
isInteger( 1.0 ) -> 是的
这对于常识来说看起来不错，但在类似 C 的语言中你会得到 false
【讨论】：
【参考方案15】：任何小数部分为零的浮点数（例如 1.0、12.00、0.0）都会隐式转换为整数，因此无法检查它们是否为浮点数。
【讨论】：
【参考方案16】：在这里尝试了一些答案，我最终编写了这个解决方案。 这也适用于字符串中的数字。
function isInt(number)
if(!/^["|']0,1[-]0,1\d0,(\.0,1\d+)["|']0,1$/.test(number)) return false;
return !(number - parseInt(number));
function isFloat(number)
if(!/^["|']0,1[-]0,1\d0,(\.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\d0,(\.0,1\d+)["|']0,1$/.test(number)) return false;
return !(number - parseInt(number));
function isFloat(number)
if(!/^["|']0,1[-]0,1\d0,(\.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);【讨论】：
【参考方案17】：简单整数测试：
if( n === parseInt(n) ) ...
有道理：如果 JavaScript 可以将某些东西转换为整数，并且通过转换它变成完全相同的东西，那么您的操作数就是整数。
控制台测试用例：
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!
这让很多人感到困惑。每当某物为 .0 时，它就不再是浮点数了。它是一个整数。或者您可以将其称为“数字事物”，因为没有像当时 C 中那样严格的区别。美好的旧时光。
所以基本上，您所能做的就是检查整数，接受 1.000 是整数这一事实。
有趣的旁注
有一条关于巨大数字的评论。巨大的数字意味着这种方法没有问题；每当 parseInt 无法处理该数字（因为它太大）时，它将返回实际值以外的其他值，因此测试将返回 FALSE。看：
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);
我在 2014 年在 IE8 上对此进行了测试，然后在 2021 年在 Chrome 上进行了测试，两者都返回“a 正常；b 失败”，这意味着如果一个数字太大，它就不能再是整数了。
20 位数字应该足以让任何人引用经典。
【讨论】：
如果您只需要检查整数（来自数学 POV），这很好，但如果您想确保它们实际上像整数一样工作（来自计算POV）对于大量数字来说将是不正确的。见this comment。 嗯嗯嗯......你为什么这么认为？我的意思是，如果 parseInt 返回一些东西并且它似乎等于变量本身，那么您可以确定您的 n 确实可以作为整数工作。我发现 99999999999999999999（即“9”的 20 倍）是一个数字，而再添加一个“9”会使 parseInt 失败（返回 1）。它可能取决于浏览器；但是，是的，有一个限制，否，无论超出该限制，上述检查都不会返回 true。 我的意思是按位运算符（将数字视为 32 位整数）不会对不能表示为 32 位整数的数字给出预期结果，因此这些数字不应该被标识为整数。这与提议的Number.isInteger 的工作方式一致。
某些东西可以是一个真正的整数，而无需以一种特定的方式存储。我明白你的意思，但整数是整数，因为它们没有小数部分，可以任意加/减而不会得到类似浮点的结果。如果您将数字视为位域，那么您假设它们是如何存储的——在我看来——这是一种实际可行但不是 100% 可靠的方式。如果您正在寻找“以某种方式存储的整数”，那么我不确定是否有可以在所有平台上安全使用的单行测试。
可以表示为 32 位整数的数字确实可以 100% 可靠地使用按位运算符。您不是“假设它们是如何存储的；”根据规范，这些数字被转换为有符号的 32 位大端二进制补码整数。不能以这种格式表示的数字不应被视为整数。同样，这与Number.isInteger 的工作方式一致。单行测试是n === (n | 0)，如另一个答案所示。【参考方案18】：
其实没必要这么复杂。整数的 parseFloat() 和 parseInt() 等效项的数值将相同。因此你可以这样做：
function isInt(value)
return (parseFloat(value) == parseInt(value)) && !isNaN(value);
然后
if (isInt(x)) // do work
这也将允许进行字符串检查，因此并不严格。如果想要一个强类型的解决方案（又名，不能使用字符串）：
function is_int(value) return !isNaN(parseInt(value * 1)
【讨论】：
isInteger(12.0) 为真【参考方案19】：我们可以通过isInteger函数检查。
即数字将返回真，浮点数返回假
console.log(Number.isInteger(2)),<BR>会返回真
console.log(Number.isInteger(2.5))会返回假
【讨论】：
【参考方案20】：这是检查整数和浮点数的最终代码
function isInt(n)
if(typeof n == 'number' && Math.Round(n) % 1 == 0)
return true;
else
return false;
或
function isInt(n)
return typeof n == 'number' && Math.Round(n) % 1 == 0;
【讨论】：
这仅在 n 恰好是数字时测试浮点数【参考方案21】：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');
【讨论】：
整数不是浮点数？给我的消息。【参考方案22】：这个解决方案对我有用。
<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>
【讨论】：
【参考方案23】：对于整数我使用这个
function integer_or_null(value)
if ((undefined === value) || (null === value))
return null;
if(value % 1 != 0)
return null;
return value;
【讨论】：
【参考方案24】：在java脚本中所有的数字都是internally 64 bit floating point，和java中的double一样。
javascript 中没有不同的类型，都由类型number 表示。因此，您将无法进行instanceof 检查。但是，您可以使用上述给出的解决方案来确定它是否是小数。 Java 脚本的设计者认为使用单一类型可以避免大量类型转换错误。
【讨论】：
【参考方案25】：对于那些好奇的人，我使用 Benchmark.js 在这篇文章中测试了投票率最高的答案（以及今天发布的答案），这是我的结果：
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
【讨论】：
【参考方案26】：我喜欢这个小函数，它对正整数和负整数都返回 true：
function isInt(val)
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
这是有效的，因为 1 或“1”变为“1.0”，isNaN() 返回 false（然后我们取反并返回），但 1.0 或“1.0”变为“1.0.0”，而“string”变为“string.0”，两者都不是数字，所以 isNaN() 返回 false（并且再次被否定）。
如果你只想要正整数，有这个变体：
function isPositiveInt(val)
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
或者，对于负整数：
function isNegativeInt(val)
return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
isPositiveInt() 通过将连接的数字字符串移动到要测试的值之前来工作。例如，isPositiveInt(1) 导致 isNaN() 评估“01”，其评估结果为 false。同时， isPositiveInt(-1) 导致 isNaN() 评估“0-1”，其评估结果为真。我们否定返回值，这给了我们想要的东西。 isNegativeInt() 的工作原理类似，但不否定 isNaN() 的返回值。
编辑：
我最初的实现也会在数组和空字符串上返回 true。这个实现没有那个缺陷。如果 val 不是字符串或数字，或者如果它是空字符串，它还具有提前返回的好处，从而在这些情况下更快。您可以通过将前两个子句替换为
来进一步修改它typeof(val) != "number"
如果你只想匹配文字数字（而不是字符串）
编辑：
我还不能发布 cmets，所以我将其添加到我的答案中。 @Asok 发布的基准非常有用；但是，最快的函数不符合要求，因为它也为浮点数、数组、布尔值和空字符串返回 TRUE。
我创建了以下测试套件来测试每个函数，并将我的答案添加到列表中（函数 8，解析字符串，函数 9，不解析）：
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!");
我还重新运行了基准测试，将函数 #8 添加到列表中。我不会发布结果，因为它们有点尴尬（例如，该功能不快）...
（删减--我删除了成功的测试，因为输出很长）结果如下：
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!
我留下了失败，所以你可以看到每个函数失败的地方，并且（字符串）'#'测试，所以你可以看到每个函数如何处理字符串中的整数和浮点值，因为有些人可能希望将它们解析为数字，有些可能没有。
在测试的10个函数中，真正符合OP要求的是[1,3,5,6,8,9]
【讨论】：
【参考方案27】：function int(a)
return a - a === 0 && a.toString(32).indexOf('.') === -1
function float(a)
return a - a === 0 && a.toString(32).indexOf('.') !== -1
如果要排除字符串，可以添加typeof a === 'number'。
【讨论】：
【参考方案28】：YourJS 提供以下两个函数，适用于所有数字，包括为 -Infinity 和 Infinity 返回 false：
function isFloat(x)
return typeOf(x, 'Number') && !!(x % 1);
function isInt(x)
return typeOf(x, 'Number') && x % 1 == 0;
由于typeOf() 是一个YourJS 内部函数，如果你想使用这些定义，你可以在这里下载这些函数的版本：http://yourjs.com/snippets/build/34
【讨论】：
【参考方案29】：有时 Number 对象不允许您直接使用 mod 运算符 (%)，如果您遇到这种情况，您可以使用此解决方案。
if(object instanceof Number )
if( ((Number) object).doubleValue() % 1 == 0 )
//your object is an integer
else
//your object is a double
【讨论】：
【参考方案30】：try this one
function amountcheck()
var dpamt=$('#dpamt').val()/5000;
var ints=dpamt.toString();
var isint=ints.split('.');
if(isint[1]>0)
alert('float value');
return false;
else
alert('int value');
【讨论】：
以上是关于如何检查数字是浮点数还是整数？的主要内容，如果未能解决你的问题，请参考以下文章
如何检查数字是浮点数还是整数？ - How do I check that a number is float or integer?
在 Amazon Redshift 中检查数字是整数还是浮点数