用ChatGPT解决这个技术问题 Extra ChatGPT

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

如何找到一个数字是 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 应该如何表现 wrt 基数。就个人而言，我认为 ((x % 1) == 0) 是一个很好的代理，并且完全由 IEEE-754 指定，因此无需争论不同数行之间的对应关系。
您考虑 1.0 整数还是浮点数？

O
Omn

除以 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、false、null、空数组、包含单个整数的数组、包含表示整数的字符串的数组，这也会返回 true整数，甚至更多。
不错的技巧，但不是正确的答案，因为它无法检查空字符串 "" 和 1.0 isInt(""); && isInt(1.0); 都导致 true 看到这个演示jsbin.com/elohuq/1/edit
Ina，通常鼓励使用 === 而不是 ==，因为它会带来更多的类型安全性和更可预测的统一行为。正如之前的回答者所说，这个答案绝对是 100% 不正确的。值 null、空字符串、1.0 和许多其他值都将错误地注册为整数（即使使用 === 检查）。
问题是如何检查一个数字是否为整数，而不是如何检查任何值。
很多关于它如何不验证字符串的敌对评论。这不是OP问题的一部分。如果我去 SO 询问有关检索数组的最后一个元素的问题并且有人用 function last (array) { return array[array.length - 1]; } 回答，是“只是错误”还是“SO 上的最差答案”，因为它不检查参数是否为数组第一的？是的，检查参数的好习惯，但这是开发人员的责任。所以答案应该简短，并尽可能清楚地直接回答问题。
D
Dagg Nabbit

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

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，这是错误的！
O
Omn

有一个名为 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。
J
John Conde

为什么不这样： 

var isInt = function(n) { return parseInt(n) === n };
这对我来说实际上是一个好的解决方案的核心。我需要允许正整数并禁止浮点数、字符串和负整数。
这似乎是比该线程中的其他解决方案更好的解决方案。也许社区可以提出一些批评吗？
变量 y = 1.00; y === parseInt(y, 10); // 这对我来说返回 true，这并不是我们真正想要的。
@ekussberg：为什么要返回false？ 1 是一个整数。第二个参数 02 被忽略。
-1 因为将一个数字转换为一个字符串，然后将其解析回一个数字只是为了检查这是否会产生相同的值，这是一个荒谬的复杂性，而真正需要的是检查一个数字是否已经是浮点数形式！——是一个整数。
C
Community

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

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，谢谢！我做了更新，包括你的学分。请检查现在是否一切正常。
T
Tal Liron

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

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('') 为真。
s
shime 
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
D
Deepak Yadav 
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) 为假
s
sheriff_paul

这个怎么样？ 

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}
尝试 console.log(isFloat(1.0)); 结果为假。
isFloat(NaN) 和 isFloat(Infinity) 返回 true：/
C
Claudiu

正如其他人提到的，您在 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 在技术上是一个浮点数，虽然......取决于我认为的用例。
A
Arman

这是我用于整数的： 

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

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

我喜欢这个，因为它是一个简短而简单的答案，不依赖于神秘的按位运算。
为什么是 parseFloat ？
В
Виктор Дакалов 
!!(24%1) // false
!!(24.2%1) // true
!!(24.0%1) 为假
a
ankr 
var isInt = function (n) { return n === (n | 0); };

没有一个案例，这没有做这项工作。

嘿抱歉为什么这返回假？ console.log(isInt(7932938942839482938));
因为那超过了 MaxInt。
但你可以设置一个 Int 最大长度不？如果我不知道返回的 int 长度怎么办？
@ekussberg 是的，因为 2 是一个整数，而 23 被认为是函数的第二个参数。在 javascript 中，小数是使用点作为分隔符写入的 - 所以它应该是 2.23。
或者这是学习按位运算的好机会。今后，您将从中受益匪浅。
A
Aryan

我们可以通过isInteger函数检查。 ie number 将返回 true 并且 float 返回 false

console.log(Number.isInteger(2)),
将返回 true

console.log(Number.isInteger(2.5)) 将返回 false

g
gblazex

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

使用类似 Claudiu 提供的东西：

isInteger( 1.0 ) ->真的

对于常识来说这看起来不错，但在 C 之类的语言中你会得到 false

M
Mike Mancini

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

A
Alejandro Hernandez

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

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'：假，'notValidTrue'：真，'notValidString'：'45lorem'，'notValidStringFloat'：'4.5lorem'，'notValidNan'：NaN，' notValidObj' : {}, 'notValidArr' : [1,2], };函数 isInt(number) { if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|' ]{0,1}$/.test(number)) 返回 false；返回！（数字 - parseInt（数字））； } function isFloat(number) { if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["| ']{0,1}$/.test(number)) 返回 false；返回数字 - parseInt(number) ？真假; } 功能 testFunctions(obj) { var keys = Object.keys(obj); var values = Object.values(obj); values.forEach(function(element, index){ console.log(`Is ${keys[index]} (${element}) var 一个整数吗？${isInt(element)}`); console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`); }); } 测试功能（测试）；

d
dkellner

简单整数测试： 

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)。
S
SpYk3HH

它真的不必那么复杂。整数的 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) 为真
K
Ken Le

这是检查整数和浮点数的最终代码 

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 恰好是数字，这仅测试浮点数
V
Vitim.us 
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');
}
整数不是浮点数？给我的消息。
Z
Zeromus

这个解决方案对我有用。 

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

尝试这个 

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

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

基本上它需要检查不等于零的精度值。

另一种是检查正确的字符串编号。

评论：欢迎来到 Stack Overflow！尽管您的答案在技术上可能是正确的，但我看不出它与此处的其他答案有何本质不同。因此，在这种情况下，我投票删除它。
B
Bharath SanjU 
const integerCheck = (num) => {
        const isInt = (n) => Number(n) === n && n % 1 === 0
        const isFloat = (n) => Number(n) === n && n % 1 !== 0
        return (isInt(num) || !isFloat(num))        
}
console.log( integerCheck('23.3') );
我不明白这里的设计理念。根本不需要使用 lambdas。您还进行了许多冗余计算。这里还有 48 个其他答案。这个和其他的有什么区别？
n
neoneye

对于整数我使用这个 

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

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

j
jnthnjns

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

我喜欢这个小函数，它将对正整数和负整数都返回 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"

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

编辑：

我还不能发表评论，所以我将其添加到我的答案中。 @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]

M
Mirek Rusin 
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'。

Z
Zaur Nasibov

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

关注公众号,不定期副业成功案例分享
关注公众号

不定期副业成功案例分享

想领先一步获取最新的外包任务吗？

立即订阅

HuntsBot(狩猎机器人)，一站式外包任务、远程工作、产品创意分享与订阅平台，支持钉钉、飞书、企业微信、邮箱、Telegram机器人订阅。平台会以及时、稳定、可靠的技术把外包任务需求、远程工作机会、产品创意等推送给每一位订阅的用户。

简体中文 English

平台

支持

友情链接

联系我们

在使用过程中有任何问题或建议，可以通过以下方式联系我们：

微信公众号: 火星来客

Email: huntsbot@xinbeitime.com

Copyright© 2022-2023 www.huntsbot.com 浙ICP备2022000860号-4 All Rights Reserved.