我如何检查一个数字是浮点数还是整数？
如何find一个数字是float还是integer ？
1.25 --> float 1 --> integer 0 --> integer 0.25 --> float
检查余数除以1：
function isInt(n) { return n % 1 === 0; }
如果你不知道参数是一个数字，你需要两个testing：
function isInt(n){ return Number(n) === n && n % 1 === 0; } function isFloat(n){ return Number(n) === n && n % 1 !== 0; }
尝试使用这些函数来testing一个值是否是一个没有小数部分的数字原始值，并且在可以被表示为精确整数的大小范围内。
function isFloat(n) { return n === +n && n !== (n|0); } function isInteger(n) { return n === +n && n === (n|0); }
为什么不是这样的：
var isInt = function(n) { return parseInt(n) === n };
有一个名为Number.isInteger()的方法，目前只在最新的Firefox中实现，并且仍然是EcmaScript 6提议的一部分。 但是， MDN为其他浏览器提供了一个polyfill，它与ECMA和谐中指定的匹配：
if (!Number.isInteger) { Number.isInteger = function isInteger (nVal) { return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal; }; }
你可以使用一个简单的正则expression式：
function isInt(value) { var er = /^-?[0-9]+$/; return er.test(value); }
或者你也可以根据你的需要使用下面的function。 它们是由PHPJS项目开发的。
is_int() =>检查variablestypes是整型还是整数
is_float() =>检查variablestypes是否为浮点数，以及浮点数是否为浮点数
ctype_digit() =>检查variablestypes是否是string，以及其内容是否只有十进制数字
更新1
现在它也检查负数，感谢@ChrisBartley评论 ！
以下是检查值是数字还是可以安全转换为数字的高效函数：
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）被避免时，值已经是一个数字。 这两个parsing函数总是先转换为string，然后尝试parsing该string，如果该值已经是数字，那么这将是浪费。
感谢您在这里的其他post提供进一步的优化思路！
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
function isInt(n) { return n != "" && !isNaN(n) && Math.round(n) == n; } function isFloat(n){ return n != "" && !isNaN(n) && Math.round(n) != n; }
适用于所有情况。
正如其他人所说，你只有JS的双打。 那么你如何定义一个数字是一个整数？ 只要检查四舍五入的数字是否等于自己：
function isInteger(f) { return typeof(f)==="number" && Math.round(f) == f; } function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
以下是我用于整数的内容：
Math.ceil(parseFloat(val)) === val
简短，很好:)工作的所有时间。 这就是大卫·弗拉纳根（David Flanagan）如果我没有弄错的话。
!!(24%1) // false !!(24.2%1) // true
var isInt = function (n) { return n === (n | 0); };
没有一个这样做没有工作的情况下。
任何小数零（例如1.0，12.00，0.0）的浮点数都隐含地转换为整数，所以不可能检查它们是否为浮点数。
这很简单：
if( n === parseInt(n) ) ...
在控制台中试试这个：
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无法处理数字（因为它太大），它会返回除了实际值以外的东西，所以testing将返回FALSE。 这是一件好事，因为如果你考虑一个“数字”，你通常希望JS能够用它来计算 – 所以是的，数字是有限的，parseInt会考虑到这一点。
尝试这个：
<script> 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); </script>
在我的浏览器（IE8）中，这返回“a是好的; b失败”，这正是因为在b中的数量巨大。 限制可能会有所不同，但我想20位数“应该足够的任何人”，引用古典:)
这真的取决于你想达到什么。 如果你想“模仿”强types的语言，那么我build议你不要尝试。 正如其他人所说，所有的数字都有相同的表示forms（相同的types）。
使用类似Claudiu提供的：
isInteger( 1.0 ) – > true
这对于常识来说看起来不错，但是像C这样的东西你会得到false
这是最终的代码来检查INT和FLOAT
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; }
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'); }
我写了函数接受string（如果有人需要）
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 }
例子ouptuts：
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
整数我用这个
function integer_or_null(value) { if ((undefined === value) || (null === value)) { return null; } if(value % 1 != 0) { return null; } return value; }
它并不一定非常复杂。 整数的parseFloat（）和parseInt（）等效的数值是相同的。 因此你可以这样做：
function isInt(value){ return (parseFloat(value) == parseInt(value)) && !isNaN(value); }
然后
if (isInt(x)) // do work
这也将允许string检查，因此并不严格。 如果想要一个强大的types解决scheme（又名，将不会使用string）：
function is_int(value){ return !isNaN(parseInt(value * 1) }
在Java脚本中，所有的数字都是internally 64 bit floating point ，与java中的double相同。 在javascript中没有不同的types，所有的都由typesnumber表示。 所以你不能做一个检查的instanceof 。 然而，你可以使用上面给出的解决scheme来找出它是否是一个小数。 Java脚本的devise者感觉到一个单一的types，他们可以避免大量的types转换错误。
这可能不像％回答，它可以防止你不必先转换为string，但我还没有见过任何人发布它，所以这里有另一个选项应该工作正常：
function isInteger(num) { return num.toString().indexOf('.') === -1; }
这是我的代码。 它检查以确保它不是一个空string（否则将通过），然后将其转换为数字格式。 现在，取决于你是否希望'1.1'等于1.1，这可能是也可能不是你要找的。
var isFloat = function(n) { n = n.length > 0 ? Number(n) : false; return (n === parseFloat(n)); }; var isInteger = function(n) { n = n.length > 0 ? Number(n) : false; return (n === parseInt(n)); }; var isNumeric = function(n){ if(isInteger(n) || isFloat(n)){ return true; } return false; };
我喜欢这个小函数，对于正整数和负整数都会返回true。
function isInt(val) { return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0"); }
这是因为1或“1”变成了“1.0”，这是NaN（）返回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（）通过在要testing的值之前移动连接的数字string来工作。 例如，isPositiveInt（1）导致isNaN（）评估为“01”，评估为false。 同时，isPositiveInt（-1）导致isNaN（）评估为“0-1”，其评估为真。 我们否定了回报价值，这给了我们想要的东西。 isNegativeInt（）的工作方式类似，但不会否定isNaN（）的返回值。
编辑：
我原来的实现也将返回true和数组和空string。 这个实现没有这个缺陷。 如果val不是一个string或数字，或者它是一个空string，在这种情况下使它更快，它也有利于早期返回。 您可以通过replace前两个子句进一步修改它
typeof(val) != "number"
如果你只想匹配文字数字（而不是string）
编辑：
我无法发表评论，所以我把这个添加到我的答案。 @Asok发布的基准信息非常丰富， 然而，最快的函数不符合要求，因为它也返回TRUE浮游物，数组，布尔值和空string。
我创build了下面的testing套件来testing每个函数，并将我的答案添加到列表中（函数8，parsingstring，函数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!"); }
我也重新把function＃8的基准添加到列表中。 我不会公布结果，因为他们有点尴尬（例如，这个function不是很快）。
（删节 – 我删除了成功的testing，因为输出很长）结果如下：
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!
我留下了失败，所以你可以看到每个函数失败的位置，（string）'＃'testing，所以你可以看到每个函数如何处理string中的整数和浮点值，因为有些人可能希望这些parsing为数字和一些不得。
在testing的10个function中，实际符合OP要求的function是[1,3,5,6,8,9]
浮动validation条件：
if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
整数validation条件：
if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
希望这可能会有所帮助。
function int(a) { return a - a === 0 && a.toString(32).indexOf('.') === -1 } function float(a) { return a - a === 0 && a.toString(32).indexOf('.') !== -1 }
如果要排除string，可以添加typeof a === 'number' 。
YourJS provides the following two functions which work for all numbers including returning false for -Infinity and Infinity :
function isFloat(x) { return typeOf(x, 'Number') && !!(x % 1); } function isInt(x) { return typeOf(x, 'Number') && x % 1 == 0; }
Due to the fact that typeOf() is a YourJS internal function, if you wanted to use these definitions you can download the version for just these functions here: http://yourjs.com/snippets/build/34
Some times Number objects don't allow you to use direct the mod operator (%), if you are facing that case you can use this solution.
if(object instanceof Number ){ if( ((Number) object).doubleValue() % 1 == 0 ){ //your object is an integer } else{ //your object is a double } }
Based on all that I have seen here, I've created my own set of functions to test for what I need:
function NumberValidator() { this.isFloat = function (n) { return typeof(n)==="number" && n === +n && Math.round(n) !== n; }; this.isInteger = function (n) { return typeof(n)==="number" && n === +n && Math.round(n) === n; }; this.isFloatOrInteger = function (n) { return this.isFloat(n) || this.isInteger(n); }; this.isNonZeroFloatOrInteger = function (n) { return this.isFloatOrInteger(n) && n > 0; }; this.isNonZeroInteger = function (n) { return this.isInteger(n) && n > 0; }; }
However, shime 's solution is shorter and with less checks, so it might be a better one.
For those curious, using Benchmark.js I tested the most up-voted answers (and the one posted today) on this post, here are my results:
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
