关于javascript：如何检查数字是浮点数还是整数？

How do I check that a number is float or integer?

如何找到一个数字是float或integer？

1
2
3
4

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

相关讨论

我理解您在这里的要求，但要明确一点：javascript没有不同的整数和浮点数字类型。javascript中的每个数字都只是一个Number。</nit-pick>
让我纠正它！谢谢
你认为Infinity是整数还是非整数值？这里的答案在这个分数上分布得相当均匀。
@Mikesamuel在数学上是精确的：因为无穷大不是实数，所有整数都是实数，所以Infinity不能被视为整数。
@这个问题问的是"浮动"，而不是"真实"。不管怎样，real都是不相关的，因为计算机只能表示可计算的数字。
@对不起，我的意思是整数和浮点数都是实数。不管怎样，我说过整数和浮点数是实数的一部分，而不是它们能代表所有的实数。基本上，我的观点是无穷大不是一个数字，你不应该关心它是浮点还是int。
@rvighne，我认为我们同意无穷大和NaN不是实数的事实，这意味着ieee-754浮点数不是实数的子集。所有基于IEEE-754的数值分析都必须处理这一事实。我不明白的是，你认为这个事实决定了积分应该如何表现W.R.T.基数。我个人认为((x%1)==0)是一个很好的代理，并且完全由IEEE-754指定，所以不需要争论不同数字线之间的对应关系。
@mike"ieee 754"remals"操作从舍入除法而不是截断除法计算余数，因此其行为与通常的整数余数运算符不同。相反，ECMAScript语言定义浮点运算的百分比，以类似于Java整数余数运算符的方式进行操作；这可以与C库函数fMOD进行比较。
计数只能用整数来完成，因此可数无穷大是一个整数。Nb Cantor证明了实数多于可数无穷集。(mathworld.wolfram.com/countablyinfe有限公司.html)
一篇关于浮点规格的好论文。ece.uwaterloo.ca/~dwharder/numericalananalysis/02数字/doub&zwnj；&8203；le/&hellip；
您可以使用数字方法isInteger。在这里检查一下。
jsben.ch//htlvw-一个常用方法的基准
你认为1.0整数还是浮点？

除以1时检查余数：

1
2
3

function isInt(n) {
return n % 1 === 0;
}

如果您不知道参数是数字，则需要进行两次测试：

1
2
3
4
5
6
7

function isInt(n){
return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
return Number(n) === n && n % 1 !== 0;
}

相关讨论

简单有效的解决方案。
注意，对于空字符串、表示整数的字符串、true、false、null、空数组、包含单个整数的数组、包含表示整数的字符串的数组，以及可能更多的情况，这也将返回true。
我认为您的第一个实现是出色和高效的，第二个是多余的。对吗？
只是要注意，这个方法在大多数情况下都可以工作，但是它不足以假定相反的(！isint)表示浮动。在一个非常大的数字上尝试它-！isint(number.max_value-0.1)-不起作用。这是由于使用了模。下面答案中的方法在所有情况下都有效。
谢谢，即使javascript在float和int之间没有区别，这对于翻译也非常有用：unicode.org/repos/cldr tmp/trunk/diff/supplementary/&hellip；
技巧不错，但回答不正确，因为它没有检查空字符串""和1.0isInt("");和isInt(1.0);都会导致true见本演示jsbin.com/elohuq/1/edit
为什么使用==vs==？
在INA中，通常鼓励使用==而不是==，因为它会导致更高的类型安全性和更可预测、统一的行为。正如之前的回答者所说，这个答案绝对是100%的错误。空、空字符串、1.0和许多其他值都将错误地注册为整数(即使使用==检查)。
isint(1.0000000000000000000000000000 1)==真
这是一个公认的答案，现在竖起383个大拇指，但这是错误的。我的意思是，这就像一个工作区，不能带你去你想去的地方。这是反模式。
最坏的答案是什么？null % 1 === 0、[] % 1 === 0。
问题是如何检查数字是否是整数，而不是如何检查任何值。
你会继续使用它还是使用新号码.isinteger()？
这不是错的。1.0000000000000000000000000001==1
上述原因错误。它验证空输入字段是否包含整数。
注意第二个isInt可能得到false和isInt(new Number(0))。
4ff返回真。这是预期的吗？
请问您为什么使用Number(n) === n而不是typeof n ==="number"？我想这取决于你使用什么的意图，但是第一个也是正确的，例如，如果n ==="5"。
不适合我。n==number(n)总是失败并返回false。
关于它如何不验证字符串的许多敌意评论。这不是手术的问题。如果我继续问一个关于检索数组的最后一个元素的问题，有人用function last (array) { return array[array.length - 1]; }回答，是"刚刚错误"还是"最差的答案"，因为它不首先检查参数是否是数组？是的，检查参数的良好实践，但这是开发人员的责任。所以答案应该简短，并且尽可能直接地回答问题。
它不适用于使用==。至少在火狐中。但如果使用==，它确实有效。
这是一个无效的代码，将以1.2这样的数字失败，因为这个数字接近1.2而不是1.2 test: 1.2 false ::: 0.19999999999999996。
很确定这是模量%而不是除以/

尝试使用这些函数来测试一个值是否是一个没有小数部分并且在可以表示为精确整数的大小限制内的数字基元值。

1
2
3
4
5
6
7

function isFloat(n) {
return n === +n && n !== (n|0);
}

function isInteger(n) {
return n === +n && n === (n|0);
}

相关讨论

只有通过一个数字才有效
heh awesom开发，它几乎是我的(n===+n用于检查数字，n|0用于取整)，但有内置的操作符。时髦的
@John Hartsock字符串永远不会是数值。这是一根绳子。这个函数的目的是测试一个值是否是一个没有小数部分的javascript数值，并且在可以表示为精确整数的大小限制内。如果要检查字符串是否包含表示数字的字符序列，可以先调用parseFloat()。
@pointy但parsefloat("1.1a")仍将返回1.1。假设您有一个文本字段要验证它是一个浮点型，并且只有一个不带字母字符的浮点型。测试输入元素的文本字段是否为十进制(浮点)
@约翰·哈特索克：除非传递了一个数字原语，否则它不会返回真。考虑到函数的名称，我认为这是有意义的。如果正在编写此类函数，则任何其他内容都应该是ISString、ISBoolean等的候选者。
@点：双精度浮点数可以精确表示最大为2^53的整数值。所以这取决于OP是在数学意义上询问整数(整数)，还是在32位数据意义上询问整数。如果是后者，您的解决方案是完美的。
@戴夫是的，这是真的，但请注意，当javascript想要处理整数时，它通常会将它们猛击到32位。
+1用于使用n|0将值转换为带符号的32位整数。正如@dave所说，2^31和2^53之间的整数在javascript中很有趣，因为它们可以精确表示，但会被按位运算符截断为最不重要的32位。
@Daggnabbit我以前从未在javascript中看到过===+或|。我知道@claudiu对他们说了些什么，但我在W3school上没有看到他们提到过。有没有地方我可以去看一些有关它们的文档？我猜|是个有点聪明的算符，对吗？===+是某种加法，还是可能是只对数字起作用的正号运算符？再说一次，我在任何地方都找不到这些东西。谢谢.
@丹：===+实际上是两个操作符，===(严格相等)，然后是一元+，例如(+5)。|有点明智，或者，是的。
@丹，克劳迪是对的，埃多克斯1〔4〕只是我懒惰的格式。现在已经修复了，并添加了Pointy的优秀评论。另外，W3学校通常被认为是不准确和不完整的；您可能不想使用它作为参考。最好坚持使用MDN、WHATWG、W3C和官方规范中的文档。
这种方法唯一需要注意的是，javascript中的位运算符最多可以工作32位，因此大的数字将作为整数给出假。
@gast&243；ns&225；nchez istm如果数字不能表示为无符号32位int，则在javascript上下文中它不是"整数"。这一问题唯一有用的方法是询问如何识别可以转换为位运算符所需格式而不更改其值的数字。确定一个数字是否没有小数部分是很简单的；我假设这不是这里要问的问题。
在javascript中，像EDOCX1(or)这样的位运算符只对有符号的32位整数进行操作。如果目标是检查有符号的Int32值，则OP不会声明。所以这不适用于超出范围的数字。isInteger(5000000000)将返回false这是错误的！
@ OnurY？激光二极管？R？M见以上评论。这个答案假设操作询问如何确定一个数字是否可以表示为32位无符号整数。
@daggnabbit很好，isInteger(-1000)将返回true，它不是无符号整数。
@ OnurY？激光二极管？R？我的意思是签字。
n === +n在整数测试中是多余的，不是吗？
isinteger(n)：例如，输入的表格345显示为假。
似乎1.0被拒绝作为一个浮动：1.0 === +1.0 && 1.0 !== (1.0|0)>>false。
当这不起作用时，有趣的情况是你使用Number。
isfloat(12.0)为假。？

为什么不这样：

1	var isInt = function(n) { return parseInt(n) === n };

相关讨论

有一个名为Number.isInteger()的方法，目前仅在最新的firefox中实现，它仍然是ecmascript 6提议的一部分。但是，MDN为其他浏览器提供了一个polyfill，与ecma harmony中指定的浏览器匹配：

1
2
3
4
5

if (!Number.isInteger) {
Number.isInteger = function isInteger (nVal) {
return typeof nVal ==="number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
};
}

相关讨论

可以使用简单的正则表达式：

1
2
3
4
5
6

function isInt(value) {

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

return er.test(value);
}

或者您也可以根据需要使用以下功能。它们由PHPJS项目开发。

is_int()=>检查变量类型是否为整数，内容是否为整数

is_float()=>检查变量类型是否为float，内容是否为float

ctype_digit()=>检查变量类型是否为字符串，其内容是否只有十进制数字

更新1

现在它也检查负数，谢谢@chrisbartley评论！

相关讨论

以下是有效的函数，用于检查值是数字还是可以安全地转换为数字：

1
2
3
4
5
6
7
8
9

function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}

对于整数(如果值是浮点值，则返回false)：

1
2
3
4
5
6

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

这里的效率是，当值已经是数字时，避免使用parseInt(或parseNumber)。两个解析函数总是先转换为字符串，然后尝试解析该字符串，如果该值已经是数字，这将是浪费。

感谢您在这里的其他帖子为优化提供进一步的想法！

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

相关讨论

1
2
3
4
5
6
7

function isInt(n)
{
return n !="" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n !="" && !isNaN(n) && Math.round(n) != n;
}

适用于所有情况。

相关讨论

下面是整数的用法：

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

很短，很好：)一直有效。如果我没弄错的话，这就是大卫·弗拉纳根的建议。

相关讨论

正如其他人提到的，JS中只有双精度。那么，如何定义一个整数？只需检查整数是否等于自身：

1
2
3
4

function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

相关讨论

带有零小数部分(例如1.0、12.00、0.0)的任何浮点数都隐式转换为整数，因此无法检查它们是否为浮点数。

相关讨论

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

相关讨论

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

还没有这样做的案例。

相关讨论

很简单：

1	if( n === parseInt(n) ) ...

在控制台中尝试此操作：

1
2
3
4
5
6
7
8
9
10
11

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。这是一件好事，因为如果你把某个东西看作一个"数字"，你通常期望JS能够用它来计算——所以是的，数字是有限的，ParseInt会考虑到这一点，用这种方式来表达。

试试这个：

1
2
3
4
5

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

在我的浏览器(ie8)中，这会返回"A是正常的；B是失败的"，这完全是因为B中的大量数字。限制可能会有所不同，但我猜20位数字"应该足够任何人使用"，引用一个经典的：)

相关讨论

如果您只需要检查整数(从数学POV)，这是很好的，但是如果您想确保它们实际上像整数一样工作(从计算POV)，对于大数字来说是不正确的。请参阅此评论。
嗯…你为什么这么认为？我的意思是，如果parseint返回某个值，并且它看起来等于变量本身，那么您可以确保n确实是作为整数工作的。我发现99999999999999999(即20倍于"9")是一个数字，同时再添加一个"9"会使ParseInt失败(返回1)。它可能依赖于浏览器；但是，是的，有一个限制，不，任何超出该限制的内容都不会返回true进行上述检查。
我的意思是，位运算符(将数字视为32位整数)不会给出不能表示为32位整数的数字的预期结果，因此这些数字不应被标识为整数。这与拟议的Number.isInteger的工作方式一致。
有些东西可以是一个真正的整数，而不需要以一种特定的方式存储。我看到你的点，但是整数是整数，因为它们没有小数部分，可以任意加/减，而不会得到类似浮点数的结果。如果你把数字当作位域，你就假设它们是如何存储的，在我看来，这实际上是一种有效的但不是100%可靠的方法。如果您在寻找"以某种方式存储的整数"，那么，我不确定您是否可以在所有平台上安全地使用单行测试。
可以用32位整数表示的数字与位运算符100%可靠地工作。您不会"假设它们是如何存储的"；根据规范，这些数字被转换成有符号的32位big endian two的补码整数。不能用这种格式表示的数字不应视为整数。同样，这与Number.isInteger的工作原理是一致的。如另一个答案所示，单线测试是n === (n | 0)。
我不认为这是正确的(它们不是32位整数，而是64位浮点数"每个规范")；而且我认为我们这里的参数对于原始问题没有任何附加值。无论如何谢谢。
正如我上面所写，当与位运算符一起使用时，数字会转换为32位整数。根据Number.isInteger的规定，转换为32位整数时不能保留其原始值的数字不被视为整数。任何手动滚动的解决方案也不应将这些数字视为整数。我们在这里添加的值是在揭穿不正确的解决方案。不客气。
整数在这里并不意味着"某种变量"，因为类型是松散的。整数表示"小数部分为零的浮点数"。在按位运算中，您有一些限制，但在这里完全不讨论这个问题。这个问题显然是针对一件事，你说的是另一件事；一个可能无关紧要的特殊情况。这没用。
也许你是对的。仔细观察Number.isInteger，它的上限是+/-2^53，因此它确实将32位整数范围之外的数字视为整数(但不将大/小到失去精度的数字视为整数--"不安全整数")。在我的经验中，当人们谈论javascript中的整数时，他们谈论的是可以表示为32位无符号整数的数字，因为语言中所有涉及整数的部分都使用这种格式。也许手术室说的是不同的事情，谁知道呢(但问题很小)。
我也很惊讶，这看起来真的很琐碎-但我认为询问者不知道in t是JS中的浮点数。带大数字的位运算是很少见的，至少我很少使用它们。在其他语言中，我总是看到32位整数，称为"integer"，所以我明白了您的观点；但是对于JS，我只是从未尝试过精度有多高。我只是想它远远超过32位，相信所有的数字都是安全的。

这真的取决于你想要实现什么。如果你想"模仿"强类型语言，那么我建议你不要尝试。正如其他人提到的，所有数字都具有相同的表示形式(相同的类型)。

使用克劳迪乌提供的东西：

isInteger( 1.0 )->真

从常识上看，这很好，但在类似c的情况下，你会得到false。

这个怎么样？

1
2
3

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

这个解决方案对我有效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<html>
<body>
<form method="post" action="#">
<input type="text" id="number_id"/>
<input type="submit" value="send"/>
</form>
<p id="message">
</p>

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";
}

</body>
</html>

不必那么复杂。整数的parseFloat()和parseInt()等价物的数值将相同。因此，您可以这样做：

1
2
3

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

然后

1	if (isInt(x)) // do work

这也将允许字符串检查，因此不严格。如果需要强类型解决方案(aka，不适用于字符串)：

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

相关讨论

这是检查int和float的最终代码

1
2
3
4
5
6
7

function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}

或

1
2
3

function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}

相关讨论

1
2
3
4
5
6
7
8
9
10
11

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

相关讨论

我在这里尝试了一些答案，最后写下了这个解决方案。这也适用于字符串中的数字。

1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

我编写了接受字符串的函数(如果有人需要的话)

1
2
3
4
5
6
7

function isInt(x) {
return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}

function isFloat(x) {
return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}

示例输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

console.log(isFloat('0.2')) // true
console.log(isFloat(0.2)) // true
console.log(isFloat('.2')) // true
console.log(isFloat('-.2')) // true
console.log(isFloat(-'.2')) // true
console.log(isFloat(-.2)) // true
console.log(isFloat('u.2')) // false
console.log(isFloat('2')) // false
console.log(isFloat('0.2u')) // false

console.log(isInt('187')) // true
console.log(isInt(187)) // true
console.log(isInt('1.2')) // false
console.log(isInt('-2')) // true
console.log(isInt(-'1')) // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1)) // true

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

我喜欢这个小函数，它对正整数和负整数都返回真：

1
2
3

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(再次求反)。

如果你只想要正整数，有一个变量：

1
2
3

function isPositiveInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

或者，对于负整数：

1
2
3

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"，计算结果为true。我们否定了返回值，这就给了我们想要的。isnegativeint()的工作原理类似，但不否定isnan()的返回值。

编辑：

我最初的实现还将在数组和空字符串上返回true。这个实现没有这个缺陷。如果val不是字符串或数字，或者它是空字符串，那么它也有提前返回的好处，在这些情况下，它会更快地返回。您可以用替换前两个子句来进一步修改它。

1	typeof(val) !="number"

如果您只想匹配文字数字(而不是字符串)

编辑：

我还不能发表评论，所以我要把它添加到我的答案中。@asok发布的基准测试信息非常丰富；但是，最快的函数不符合要求，因为它还返回了float、array、booleans和空字符串的true。

我创建了以下测试套件来测试每个函数，并将我的答案添加到列表中(函数8解析字符串，函数9不解析字符串)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

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]

这是我的密码。它检查以确保它不是空字符串(否则将传递)，然后将其转换为数字格式。现在，取决于您是否希望"1.1"等于1.1，这可能是您要查找的内容，也可能不是。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

对于整数，我使用这个

1
2
3
4
5
6
7
8
9

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

对于那些好奇的人，我使用benchmark.js在本文中测试了投票最多的答案(以及今天发布的答案)，下面是我的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

1
2
3
4
5
6
7
8
9
10

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

相关讨论

在Java脚本中，所有的数字都是EDCOX1，5，和Java中的双一样。在javascript中没有不同的类型，所有类型都由类型number表示。因此，你将无法进行instanceof支票。然而，你可以用上面给出的解来找出它是否是分数。JAVA脚本的设计者用单一类型的感觉，可以避免许多类型的铸造错误。

浮动验证条件：

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

整数验证条件：

1	if (lnk.value == +lnk.value && lnk.value == (lnk.value \| 0))

希望这会有所帮助。

YourJS提供了以下两种功能，适用于所有数字，包括返回false用于-Infinity和Infinity：

1
2
3
4
5
6
7

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

这可能不如%答案的性能好，这会阻止您首先转换为字符串，但我还没有看到有人发布它，因此这里有另一个选项可以很好地工作：

1
2
3

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

相关讨论

1
2
3
4
5
6
7

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'。

相关讨论

有时，数字对象不允许直接使用mod运算符(%)，如果您正面临这种情况，可以使用此解决方案。

1
2
3
4
5
6
7
8

if(object instanceof Number ){
if( ((Number) object).doubleValue() % 1 == 0 ){
//your object is an integer
}
else{
//your object is a double
}
}

基于我在这里所看到的一切，我创建了自己的一组函数来测试我需要的东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

然而，Shime的解决方案更短，检查更少，因此它可能是更好的解决方案。

根据战争解答的启发，我使用这个来验证一条输入。

1
2
3
4
5
6
7
8
9
10
11
12
13

你可以用这个在控制台上测试

ZZU1

我需要检查一个输入值，如果它是整型或浮点型的，为此我想出了以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

下面的函数防止空字符串、取消定义、空值和最大/最小值范围。Javascript引擎应该从第一天开始就内置了这些函数。：)

享受！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function IsInteger(iVal) {
var iParsedVal; //our internal converted int value

iParsedVal = parseInt(iVal,10);

if (isNaN(iParsedVal) || Infinity == iParsedVal || -Infinity == iParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return Number(iVal) === (iParsedVal | 0); //the 2nd operand group (intValue | 0), evaluates to true only if the intValue is an integer; so an int type will only return true
}

function IsFloat(fVal) {
var fParsedVal; //our internal converted float value

fParsedVal = parseFloat(fVal);

if (isNaN(fParsedVal) || Infinity == fParsedVal || -Infinity == fParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return !!(fVal % 1); //true only if there is a fractional value after the mod op; the !! returns the opposite value of the op which reflects the function's return value
}

相关讨论

这是我的：

1
2
3
4
5
6
7
8

function isInt(quale) {
var valore = $('#'+quale).val().toLowerCase();
if (isNaN(Number(String(valore))) || (valore.indexOf("e") > 0)) {
// Not int
} else {
// Is Int!
}
}

而这：

1
2
3
4
5
6
7
8
9

function isFloat(quale) {
var valore = $('#'+quale).val();
valore = valore.replace(",","");
if (isNaN(String(valore)) || (valore.indexOf("e") > 0)) {
// Not Float
} else {
// Float
}
}

广告！

我觉得这是最优雅的方式：

1
2
3

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

它还关心在非数字值的情况下返回false。

相关讨论

另一种方法是：

1
2
3

function isFloat(float) {
return /\./.test(float.toString());
}

可能不如其他方法有效，但另一种方法完全相同。

相关讨论

1	parseInt(yourNumber)=== parseFloat(yourNumber)