JavaScript中的(内置)方式来检查字符串是否为有效数字


1188

我希望与旧的VB6 IsNumeric()函数在同一概念空间中存在某些东西?


3
请参阅我之前问过的这个相关问题
Michael Haren

38
如果您要解决此问题,请尝试跳过所有RegEx答案。那不是做到这一点的方法。
Joel Coehoorn

14
除非有人想这样做:检查给定的字符串是否具有有效数字流的格式。那为什么要错呢?
2014年

16
所选答案不正确!!!看到它的意见,但基本上失败,例如isNaN("")isNaN(" ")isNaN(false)等它返回false这些,这意味着它们是数字。
安德鲁

1
所以选择的答案是错误的,regexp也不是做到这一点的方法。那么哪一个是正确的呢?
vir我们

Answers:


2320

要检查变量(包括字符串)是否是数字,请检查它是否不是数字:

无论变量内容是字符串还是数字,这都有效。

isNaN(num)         // returns true if the variable does NOT contain a valid number

例子

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

当然,您可以根据需要对此进行否定。例如,要实现IsNumeric您给出的示例:

function isNumeric(num){
  return !isNaN(num)
}

要将包含数字的字符串转换为数字:

仅当字符串包含数字字符时才有效,否则返回NaN

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

例子

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

将字符串宽松地转换为数字

有助于将“ 12px”转换为12,例如:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

例子

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

浮点数

请记住,与,不同+numparseInt顾名思义,它将通过截断小数点后的所有内容将浮点数转换为整数(如果parseInt() 由于这种行为要使用话,最好改用其他方法) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

空字符串

空字符串可能有点违反直觉。+num将空字符串或带空格的字符串转换为零,并isNaN()假定相同:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

parseInt()不同意:

parseInt('')       // NaN
parseInt('   ')    // NaN

133
关于parseInt的一个非常重要的注意事项是,它将允许您指定一个基数来将字符串转换为int。这是一个很大的陷阱,因为如果您不提供它,它会尝试为您猜测一个基数。因此,例如:parseInt(“ 17”)的结果为17(十进制,10),而parseInt(“ 08”)的结果为0(八进制,8)。因此,除非另有说明,否则最安全的方法是使用parseInt(number,10),将10显式指定为基数。
亚当·兰尼

36
请注意,!isNaN(undefined)返回false。
David Hellsing,2010年

111
这完全是错误的-它是如何获得这么多投票的?您不能使用isNaN“检查变量是否不是数字”。“非数字”与“ IEEE-794 NaN”不同,这是要isNaN测试的内容。特别是,至少在测试布尔值和空字符串时,此用法将失败。请参阅developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/…
EML 2013年

46
最快的检查数字是否为数字的方法是“等于自己”检查:var n = 'a'; if (+n === +n) { // is number }它比最新版本的Chrome中的isNaN快〜3994%。在此处查看性能测试:jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski 2014年

22
**警告**这个答案是错误的。使用风险自负。范例:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley's

55

您可以使用RegExp方式:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

40
在这种情况下,RegExp ==不好
Joel Coehoorn

10
这在十六进制数字(例如0x12)上失败,在没有前导零(例如0.42)和负数的情况下浮动。
Ori 2012年

17
@JoelCoehoorn Care会详细说明为什么RegExp ==这里不好?对我来说似乎是一个有效的用例。
computrius

6
建立数字似乎有更多的方法(另一条注释中的十六进制数字仅是一个示例),并且许多数字可能不被认为是有效的(类型溢出,精度太高等)。而且,正则表达式不仅比仅使用内置机制慢而且更复杂
Joel Coehoorn 2014年

1
还应该匹配科学记法... 1e10等
约瑟夫·默德里格

51

如果您只是想检查字符串是否为整数(无小数位),则正则表达式是一种不错的选择。诸如此类的其他方法isNaN对于如此简单的事物而言过于复杂。

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

要只允许整数使用此:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

11
console.log(isNumeric('-1'));
永南2014年

5
console.log(isNumeric('2e2'));
加尔·巴宾

11
也许只是将“ isNumeric”重命名为“ hasOnlyDigits”。在许多情况下,这正是您要查找的支票。
gus3001 '10 -10-9

1
这就是我想要的,相当于php ctype_digit
Miguel Pynto

/^-?\d+$/对?
Sukima

36

如果你真的想确保字符串只包含一个数字,任何数字(整数或浮点数),并准确一些,你不能使用parseInt()/ parseFloat()Number()!isNaN()自己。请注意,!isNaN()实际上是true在什么时候Number()会返回数字,false什么时候会返回NaN,所以我将在其余的讨论中将其排除在外。

的问题parseFloat()是,它会返回一个数字,如果字符串中包含任何数量,即使字符串不包含准确的数字:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

问题Number()在于,如果传递的值根本不是数字,它将返回一个数字!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

滚动自己的正则表达式的问题在于,除非您创建了与浮点数匹配的确切正则表达式,否则Javascript会识别该正则表达式,否则您会错过某些情况,或者会发现本不应该的情况。即使您可以使用自己的正则表达式,为什么呢?有更简单的内置方法。

但是,事实证明Number()(和isNaN())在每种情况下parseFloat()都应该做正确的事情,在这种情况下,本不应该返回数字,反之亦然。因此,要找出一个字符串是否确实是唯一且仅是一个数字,请调用这两个函数并查看它们是否返回true:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

2
当字符串包含前导或尾随空格时,此方法返回true。' 1''2 '并且' 3 '全部返回true。
Rudey

在返回语句中添加这样的内容将解决以下问题:&&!/ ^ \ s + | \ s + $ / g.test(str)
塔科马奥

2
@RuudLenders-大多数人不在乎是否会拖尾空格以使字符串成为有效数字,因为它很容易意外地在许多接口中放入多余的空格。
伊恩(Ian)

3
如果数字字符串来自用户输入,则为真。但是我认为无论如何我都应该提到空格,因为我认为大多数需要isNumber功能的人都不会处理用户界面。同样,输入的数字不允许以空格开头。
Rudey

36

这个问题的公认答案有很多缺陷(其他几个用户都强调了这一点)。这是在javascript中解决该问题的最简单且经过验证的方法之一:

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

以下是一些好的测试用例:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

22

尝试isNan函数

isNaN()函数确定一个值是否为非法数字(非数字)。

如果该值等于NaN,则此函数返回true。否则,它返回false。

此函数不同于Number特定Number.isNaN()方法。

  全局isNaN()函数,将测试的值转换为Number,然后对其进行测试。

Number.isNan()不会将值转换为Number,并且对于任何非Number类型的值也不会返回true。


2
确保添加对空字符串的检查。isNaN('')返回false,但是在这种情况下,您可能希望它返回true。
Michael Haren

3
isFinite是更好的选择-它处理的是Infinity的
怪异

3
@MichaelHaren还不够好! isNaN()返回false用于ANY串只包含空白字符,包括像“\ u00A0”。
迈克尔

1
警告:不适用于以下值:null,“”(空字符串)和false。
珍妮·奥雷利

我知道这个答案是11年前给出的,比接受的答案早了几分钟,但是不管喜欢与否,接受的答案周围都有更多的话题,所以这个答案并没有为回答这个问题真正添加任何东西。我建议删除它,以避免分散新读者的注意力。我还认为,如果这样做,您将获得纪律徽章。
Dan Dascalescu

14

旧问题,但给出的答案中缺少几点。

科学计数法。

!isNaN('1e+30')true,但在大多数情况下,当人们问数字,他们不想匹配类的东西1e+30

大的浮点数可能会表现得很奇怪

观察(使用Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

另一方面:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

因此,如果期望的String(Number(s)) === s话,最好将字符串最多限制为15位(省略前导零)。

无限

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

鉴于所有这些,请检查给定的字符串是否是一个满足以下所有条件的数字:

  • 非科学记数法
  • 可预测的Number往返转换String
  • 有限

这不是一件容易的事。这是一个简单的版本:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

但是,即使这一步也远远不够。此处不处理前导零,但它们会拧长长度测试。


1
“但是,在大多数情况下,当人们要求输入数字时,他们不想匹配1e + 30之类的东西。”为什么这么说呢?如果有人想知道一个字符串是否包含一个数字,在我看来,他们想知道它是否包含一个数字,而1e + 30是一个数字。当然,如果我正在用JavaScript测试字符串中的数字值,我希望它可以匹配。
丹·琼斯

9

我已经测试过,迈克尔的解决方案是最好的。投票给他上面的答案(在该页面上搜索“如果您确实要确保该字符串”以找到它)。本质上,他的答案是这样的:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

它适用于每个测试用例,我在这里记录了这些内容:https : //jsfiddle.net/wggehvp9/5/

对于这些边缘情况,许多其他解决方案均失败:'',null,“”,true和[]。从理论上讲,您可以通过适当的错误处理来使用它们,例如:

return !isNaN(num);

要么

return (+num === +num);

对/ \ s /,null,“”,true,false,[](还有其他?)进行特殊处理


1
尾随/前导空格仍返回true。在返回语句中添加这样的内容将解决以下问题:&&!/ ^ \ s + | \ s + $ / g.test(str)
塔科马奥

2
因此,“ 123”应该为假,而不是数字,而“ 1234”应该为数字?我喜欢这样,所以“ 123”是一个数字,但是如果前导或尾随空格应更改值,则可能由开发人员决定。
JohnP2

8

将参数传递给构造函数时,可以使用Number的结果。

如果参数(字符串)不能转换为数字,则返回NaN,因此您可以确定所提供的字符串是否为有效数字。

注意:当传递空字符串或 '\t\t'and '\n\t'作为Number时,将返回0;传递true将返回1,而false则返回0。

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

Number构造是完全一样的+x
GregRos

作为一个方面说明,记住了ES6 Number()手柄浮点数,以及像Number.parseFloat()Number.parseInt()
zurfyx

7

也许有一个或两个遇到这个问题的人需要比平时更严格的检查(就像我一样)。在这种情况下,这可能会很有用:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

谨防!这将拒绝像琴弦.140.00008000.1。非常挑剔-字符串必须与“ 最小最小完美形式 ”匹配 ”才能通过此测试。

它使用Stringand Number构造函数将字符串转换为数字,然后再次返回,从而检查JavaScript引擎的“完美最小形式”(使用初始Number构造函数将其转换为最小形式)是否与原始字符串匹配。


2
谢谢@JoeRocc。我也需要这个,但是仅用于整数,所以我添加了:(str === String(Math.round(Number(str))))
keithpjolley

要知道"Infinity""-Infinity""NaN"通过这项测试。但是,可以使用其他Number.isFinite测试解决此问题。
GregRos

这与完全相同str === ("" + +str)。它基本上检查字符串是否是对JS号进行字符串化的结果。知道了这一点,我们还可以看到一个问题:测试通过了,0.000001但是失败了0.00000011e-7而是通过了。对于很大的数字也是如此。
GregRos


4

引用:

isNaN(num)//如果变量不包含有效数字,则返回true

如果您需要检查前导/尾随空格(例如,当需要一定数量的数字时),并且需要输入例如“ 1111”而不是“ 111”或“ 111”,那么这并不是完全正确的输入。

更好地使用:

var num = /^\d+$/.test(num)

'-1''0.1'并且'1e10'所有返回FALSE。此外,大于正无穷大或小于负无穷大的值将返回true,而它们可能应返回false。
Rudey

4

为什么jQuery的实现不够好?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

迈克尔提出了类似的建议(尽管我在这里偷了“ user1691651-约翰”的变更版):

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

以下是最有可能性能较差但结果稳定的解决方案。这是jQuery 1.12.4实现和Michael的回答的矛盾之处,需要额外检查前导/后缀空格(因为Michael的版本对于前导/后缀空格的数字返回true):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

不过,后一个版本具有两个新变量。通过执行以下操作,可以绕开其中之一:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

除了手动测试我将在当前困境中遇到的几个用例(这都是非常标准的东西)以外,我还没有通过其他方式对这些中的任何一个进行过测试。这是“站在巨人的肩膀上”的情况。



3

好吧,我正在使用我制作的这个...

到目前为止,它一直在工作:

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

如果您发现任何问题,请告诉我。


12
对于空字符串,空数组,false和null,这将导致错误的结果。
Ori 2012年

2
它不应该等于三倍吗?
toasted_flakes 2013年

1
在我的应用程序中,我们仅允许使用AZ AZ和0-9字符。我发现上面的方法是可行的,除非字符串以0xnn开头,然后在不应该以0xnn开头的情况下将其返回为数字。
rwheadon 2014年

6
您可以做“返回值%1 === 0”
Brian Schermerhorn,2015年

只是去做return !isNaN(parseInt(value, 10));
DarkNeuron

3

如果有人失望了,我会花一些时间来破解这个补丁,尝试修补moment.js(https://github.com/moment/moment)。这是我从中拿走的东西:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

处理以下情况:

真正!:

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

假!:

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

具有讽刺意味的是,我最努力的一个:

isNumeric(new Number(1)) => false

任何建议欢迎。:]


2
怎么样isNumeric(' ')isNumeric('')
Alex Cory

&& (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Number为了解决上述问题,我想补充一点。
frankenapps


3
function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

谢谢,谢谢!
M.Abulsoud

3

2019年:包括ES3,ES6和TypeScript示例

也许这个问题已经被重复了很多次,但是我今天也与这个问题作斗争,并想发表我的答案,因为我没有看到其他任何简单或彻底的答案:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

打字稿

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

这似乎很简单,涵盖了我在许多其他帖子上看到的所有基础,并自己思考:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

您还可以尝试使用自己的isNumeric功能,并在这些用例中跳过所有内容,并扫描“ true”。

或者,查看每个返回的值:

针对<code> isNumeric()</ code>的每个测试的结果


3

2019:实用且严格的数值有效性检查

通常,“有效数字”是指不包含NaN和Infinity的Javascript数字,即“有限数字”。

要检查值的数字有效性(例如,从外部来源),可以使用ESlint Airbnb样式进行定义:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

并以这种方式使用它:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

2

PFB的工作解决方案:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

2

不必为寻找“内置”解决方案而烦恼。

没有一个好的答案,并且在这个线程中被高估的答案是错误的。

npm install is-number

在JavaScript中,可靠地检查值是否为数字并不总是那么简单。开发人员通常使用+,-或Number()将字符串值转换为数字(例如,从用户输入返回值,正则表达式匹配,解析器等)。但是,有许多非直觉性的边缘案例会产生意想不到的结果:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

1

我最近写了一篇有关确保变量为有效数字的方法的文章:https : //github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md本文介绍了如何确保浮点数或整数(如果是)重要(+xvs~~x)。

本文假定变量开头是a string或a number,并且trim可用/已填充。同样,将其扩展为处理其他类型也不难。这是它的实质:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

1

我的尝试有些混乱,但不是最好的解决方案

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

它还不错,有两个缺点,它不适用于任何非十进制表示法,例如(1)科学计数法和(2)非以10为基数的表示法,例如八进制(042)和十六进制(0x45f
Domi

这不能回答寻找数值的问题,而只是寻找一个整数。
杰里米

0

在我的应用程序中,我们仅允许使用AZ AZ和0-9字符。我发现使用“ 字符串%1 === 0”的上述答案有效,除非字符串以0xnn开头(例如0x10),然后在我们不希望使用字符串时将其返回为数字。在我们的数字检查中,以下简单的陷阱似乎可以解决我们的特定情况。

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

警告:这可能是利用Javascript和Actionscript [Number(“ 1” + the_string)%1 === 0)]中的一个长期错误,我不能代表这个,但这正是我们所需要的。


为什么那会是JavaScript中的错误?
Bergi 2014年

我只是没有在Perl或C中看到具有类似解决方案的相同行为,并且由于我不是JavaScript或ActionScript 的编程语言开发人员,所以我不知道我所遇到的行为是否确实是故意的。
rwheadon 2014年

嗯,javascript在隐式类型转换方面有些草率,但是一旦您知道它就可以轻松理解其工作原理。您正在将字符串转换为数字(通过对其进行数字% 1运算),这会将字符串解释为十六进制或浮点文字。
Bergi 2014年

0

我的解决方案:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

您可以在循环内添加其他条件,以满足您的特定需求。


0

您可以像使用流librar y 一样使用类型,以获取静态的编译时检查。当然,对于用户输入而言并不是十分有用。

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

0

这是一线检查是否sNum为有效数值;它已针对多种输入进行了测试:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

0

只需使用isNaN(),它将把字符串转换为数字,如果得到一个有效数字,将返回false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

0

我正在使用以下内容:

const isNumber = s => !isNaN(+s)

工作比较好是很多情况下,但未能情况下,像1..11,1-32.1.12,更重要的是失败undefinedNaN。如果您通过了undefined或a NaN,它将返回一个误报您说这是一个数字。
杰里米
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.