如何检查数字是浮点数还是整数？

时间：2010-10-07 20:55:55

标签： javascript types numbers

如何找到号码为float或integer？

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

48 个答案:

答案 0 :(得分：1153)

除以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;
}

答案 1 :(得分：146)

尝试使用这些函数来测试一个值是否是一个数字原始值，它没有小数部分，并且在可以表示为精确整数的范围内。

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

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

答案 2 :(得分：88)

为什么不这样：

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

答案 3 :(得分：57)

有一种名为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;
  };
}

答案 4 :(得分：33)

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

function isInt(value) {

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

    return er.test(value);
}

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

is_int() =＆gt;检查变量类型是否为整数，以及其内容是否为整数

is_float() =＆gt;检查变量类型是否为float，以及其内容是否为float

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

更新1

现在它也会检查负数，感谢@ChrisBartley comment！

答案 5 :(得分：18)

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

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）。两个解析函数始终首先转换为字符串，然后尝试解析该字符串，如果该值已经是数字，这将是一种浪费。

感谢此处的其他帖子提供进一步的优化建议！

答案 6 :(得分：11)

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

答案 7 :(得分：9)

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

适用于所有情况。

答案 8 :(得分：6)

正如其他人提到的，你只有JS中的双打。那么如何定义一个整数？只需检查舍入数字是否等于它自己：

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

答案 9 :(得分：6)

这是我用于整数的内容：

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

简短，漂亮:)始终有效。如果我没弄错的话，这就是大卫弗拉纳根所说的。

答案 10 :(得分：5)

任何具有零小数部分的浮点数（例如1.0,12.00,0.0）都会隐式转换为Integer，因此无法检查它们是否为Float。

答案 11 :(得分：4)

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

答案 12 :(得分：4)

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

没有这种情况没有做到这一点。

答案 13 :(得分：3)

这个解决方案对我有用。

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

答案 14 :(得分：3)

它确实不一定非常复杂。整数的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) }

答案 15 :(得分：3)

这个怎么样？

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

答案 16 :(得分：3)

这很简单：

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无法处理数字（因为它太大），它将返回除实际值之外的其他内容，因此测试将返回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 is ok; b failed”，这正是因为b中的数字很大。限制可能会有所不同，但我想20个数字“对任何人都应该足够”，引用一个经典的：）

答案 17 :(得分：3)

这实际上取决于你想要达到的目标。如果你想“模仿”强类型语言，那么我建议你不要尝试。正如其他人所提到的，所有数字都具有相同的表示形式（相同类型）。

使用 Claudiu 之类的东西：

isInteger( 1.0 ) - ＆gt;真

看起来很常见，但在像C这样的东西你会得到false

答案 18 :(得分：2)

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

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{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}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{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);

答案 19 :(得分：2)

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

答案 20 :(得分：2)

这是检查INT和FLOAT的最终代码

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

OR 

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

答案 21 :(得分：2)

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

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

答案 22 :(得分：1)

对于那些好奇的人，使用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

答案 23 :(得分：1)

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

答案 24 :(得分：1)

浮动验证的条件： 

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

整数验证的条件： 

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

希望这可能会有所帮助。

答案 25 :(得分：1)

YourJS提供以下两个适用于所有数字的函数，包括为false和-Infinity返回Infinity：

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

答案 26 :(得分：1)

有些时候，Number对象不允许您直接使用mod运算符（％），如果您遇到这种情况，可以使用此解决方案。

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

答案 27 :(得分：1)

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

答案 28 :(得分：1)

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

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

这是因为1或＆＃34; 1＆＃34;变为＆＃34; 1.0＆＃34;，isNaN（）返回false（然后我们否定并返回），但1.0或＆＃34; 1.0＆＃34;变为＆＃34; 1.0.0＆＃34;，而＆＃34;字符串＆＃34;变为＆＃34; string.0＆＃34;，两者都不是数字，所以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（）评估＆＃34; 01＆＃34;，其评估为false。同时，isPositiveInt（-1）导致isNaN（）评估＆＃34; 0-1＆＃34;，其评估为真。我们否定了回报价值，这给了我们想要的东西。 isNegativeInt（）的工作方式类似，但不会否定isNaN（）的返回值。

编辑：

我的原始实现也会在数组和空字符串上返回true。这种实现没有那个缺陷。如果val不是字符串或数字，或者如果它是空字符串，它还具有提前返回的好处，在这些情况下使其更快。您可以通过用

替换前两个子句来进一步修改它 
typeof(val) != "number"

如果你只想匹配文字数字（而不是字符串）

编辑：

我还无法发表评论，所以我将此添加到我的回答中。 @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!

我已经失败了，所以你可以看到每个功能失败的地方，以及（字符串）＆＃39;＃＆＃39;测试所以你可以看到每个函数如何处理字符串中的整数和浮点值，因为有些人可能希望这些值被解析为数字而有些可能不会。

在测试的10个功能中，实际符合OP要求的功能是[1,3,5,6,8,9]

答案 29 :(得分：1)

这是我的代码。它会检查以确保它不是空字符串（否则将通过），然后将其转换为数字格式。现在，根据您是否希望'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;

};

答案 30 :(得分：1)

这可能不像％答案那样高效，这可以防止您必须先转换为字符串，但我还没有看到有人发布它，所以这里的另一个选项应该可以正常工作：

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

答案 31 :(得分：1)

在java脚本中，所有数字都是internally 64 bit floating point，与java中的double相同。 javascript中没有不同的类型，所有类型都由类型number表示。因此，您将无法进行instanceof检查。但是，你可以使用上面给出的解决方案来确定它是否是一个分数。 java脚本的设计者只用一种类型就可以避免许多类型转换错误。

答案 32 :(得分：1)

对于整数我用这个

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

答案 33 :(得分：0)

以下函数可防止空字符串，未定义，空值和最大/最小值范围。从第一天开始，Javascript引擎应该内置这些功能。 ：）

享受！

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
}

答案 34 :(得分：0)

要检查数字是否为 Int 并应用 2 个十进制格式，您可以在 React-Native 中使用以下公式。

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

    show = (x) => {
        if(x) {
           if (this.isInt(x)) {
               return ${x} 
           }
           else {
            return ${x.toFixed(2)}
           }
        }
    }

答案 35 :(得分：0)

有了这个，你可以检查一个字符串或一个数字是否是“十进制”（正确浮动）：

var IsDecimal = function(num){
    return ((num.toString().split('.').length) <= 2 && num.toString().match(/^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/)) ? (!isNaN(Number.parseFloat(num))) : false ;
}

另一个用于检查字符串或数字是否为整数：

var IsInteger = function(num){
    return ((num.toString().split('.').length) == 1 && num.toString().match(/^[\-]?\d+$/)) ? (!isNaN(Number.parseInt(num))) : false ;
}


var IsDecimal = function(num){
    return ((num.toString().split('.').length) <= 2 && num.toString().match(/^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/)) ? (!isNaN(Number.parseFloat(num))) : false ;
}

var IsInteger = function(num){
    return ((num.toString().split('.').length) == 1 && num.toString().match(/^[\-]?\d+$/)) ? (!isNaN(Number.parseInt(num))) : false ;
}


console.log("-------------- As string --------------");
console.log("Integers:");
console.log("0 = " + IsInteger("0"));
console.log("34 = " + IsInteger("34"));
console.log(".34 = " + IsInteger(".34"));
console.log("3.4 = " + IsInteger("3.4"));
console.log("3e = " + IsInteger("3e"));
console.log("e3 = " + IsInteger("e3"));
console.log("-34 = " + IsInteger("-34"));
console.log("--34 = " + IsInteger("--34"));
console.log("034 = " + IsInteger("034"));
console.log("0-34 = " + IsInteger("0-34"));
console.log("Floats/decimals:");
console.log("0 = " + IsDecimal("0"));
console.log("64 = " + IsDecimal("64"));
console.log(".64 = " + IsDecimal(".64"));
console.log("6.4 = " + IsDecimal("6.4"));
console.log("6e2 = " + IsDecimal("6e2"));
console.log("6e = " + IsDecimal("6e"));
console.log("e6 = " + IsDecimal("e6"));
console.log("-64 = " + IsDecimal("-64"));
console.log("--64 = " + IsDecimal("--64"));
console.log("064 = " + IsDecimal("064"));
console.log("0-64 = " + IsDecimal("0-64"));
console.log("\n-------------- As numbers --------------");
console.log("Integers:");
console.log("0 = " + IsInteger(0));
console.log("34 = " + IsInteger(34));
console.log(".34 = " + IsInteger(0.34));
console.log("3.4 = " + IsInteger(3.4));
console.log("-34 = " + IsInteger(-34));
console.log("034 = " + IsInteger(034));
console.log("0-34 = " + IsInteger(0-34));
console.log("Floats/decimals:");
console.log("0 = " + IsDecimal(0));
console.log("64 = " + IsDecimal(64));
console.log(".64 = " + IsDecimal(0.64));
console.log("6.4 = " + IsDecimal(6.4));
console.log("6e2 = " + IsDecimal(6e2));
console.log("-64 = " + IsDecimal(-64));
console.log("064 = " + IsDecimal(064));
console.log("0-64 = " + IsDecimal(0-64));

答案 36 :(得分：0)

对于浮动

var decimal=  /^[-+]?[0-9]+\.[0-9]+$/; 

if (!price.match(decimal)) {
      alert('Please enter valid float');
      return false;
    }

对于整数

var number = /^\d+$/; 

if (!price.match(number)) {
      alert('Please enter valid integer');
      return false;
    }

答案 37 :(得分：0)

有Number.isInteger（number）进行检查。在Internet Explorer中不起作用，但不再使用该浏览器。如果您需要像“ 90”这样的字符串作为整数（这不是问题），请尝试Number.isInteger（Number（number））。 “官方” isInteger将9.0视为整数，请参见https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number。 看起来大多数答案对于较旧的浏览器都是正确的，但现代的浏览器已经发展并实际上支持浮点整数检查。

答案 38 :(得分：0)

例如，您可以使用Number.isInteger()方法将数字除以检查数字是整数还是浮点数：

    function isNumberFloatOrInteger(a, b){
     if(Number.isInteger(a / b)){
      return true;
      }
      else{ return false };
}

注意：isInteger()与Internet Explorer不兼容。

答案 39 :(得分：0)

我们可以通过isInteger函数进行检查。 即数字将返回true，浮点数将返回false

console.log（Number.isInteger（2）） 将返回true

console.log（Number.isInteger（2.5）） 将返回false

答案 40 :(得分：0)

尝试

let n;
return (n = value % 1) !== 0 && !isNaN(n);

当返回值为false时，表示输入值为浮点数或浮点字符串，否则，输入值为整数numbef或整数字符串。

基本上，它需要检查精度值是否不为零。

另一种方法是还要检查正确的字符串号。

答案 41 :(得分：0)

受warfares'答案的启发，我用它来验证字符串输入。

function validLatLng(n) {
  var isInt = function(n) { return parseInt(n) == n };
  var isFloat = function(n) { return parseFloat(n) == n };

  // For testing
  console.log("validLatLng::n", n);
  console.log("validLatLng::parseInt", parseInt(n));
  console.log("validLatLng::parseFloat", parseFloat(n));
  console.log("validLatLng::isInt", isInt(n));
  console.log("validLatLng::isFloat", isFloat(n));

  return isInt(n) || isFloat(n);
}

您可以使用以下命令在控制台上对其进行测试：

// Invalid for my use case
validLatLng("") // or `null`, `undefined`, etc.
validLatLng("a")
validLatLng("a1100")
validLatLng("-100a")
validLatLng("a100.00")
validLatLng("-2a100.00123")

// VALID for my use case
validLatLng("100")
validLatLng("-100")
validLatLng("100.00")
validLatLng("-100.00123")

答案 42 :(得分：0)

我发现这是最优雅的方式：

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

在非数字值的情况下，它也会返回false。

答案 43 :(得分：0)

我需要检查一个输入值，如果它是整数或浮点数，为此我会想出以下内容：

function isInteger(x) {
  var integer = parseInt(x, 10);
  if (!isNaN(integer) && !isFloat(x)) {
    return true;
  }
  return false;
}

function isFloat(x) {
  var f = parseFloat(x);
  var floor = Math.floor(f);
  var fraction = f - floor;
  if (fraction > 0) {
    return true;
  }
  return false;
}

var cases = [
  "1",
  "1.00",
  "1.01",
  "0.05",
  "ab1",
  "ab1.1",
  1,
  1.00,
  1.01,
  0.05,
  1e+5,
  "",
  true,
  false,
  null,
  NaN,
  undefined,
];

console.log("isInteger()");
for (var i = 0; i < cases.length; i++) {
  console.log(cases[i], isInteger(cases[i]));
}

console.log("\nisFloat()");
for (var i = 0; i < cases.length; i++) {
  console.log(cases[i], isFloat(cases[i]));
}

答案 44 :(得分：0)

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

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

但是，shime的解决方案更短，检查次数更少，因此可能更好。

答案 45 :(得分：0)

这是我的：

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

而且：

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

Ad majora！

答案 46 :(得分：-2)

另一种方法是：

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

可能不如其他人那么有效，但另一种方法可能都一样。

答案 47 :(得分：-3)

parseInt(yourNumber)=== parseFloat(yourNumber)
相关问题
最新问题