2019：包括ES3，ES6和TypeScript示例

Question

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

Answer 1

要检查变量（包括字符串）是否为数字，请检查它是否为数字：

无论变量内容是字符串还是数字，都可以使用。

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.

浮筒

请记住，与+num不同，parseInt（顾名思义）会通过砍掉小数点后的所有内容将浮点数转换为整数（如果要使用{{1}因为这种行为而导致 you're probably better off using another method instead）：

parseInt()

空字符串

空字符串可能有点违反直觉。 +'12.345' // 12.345 parseInt(12.345) // 12 parseInt('12.345') // 12将空字符串转换为零，+num假设相同：

isNaN()

但+'' // 0 isNaN('') // false不同意：

parseInt()

Answer 2

你可以去RegExp-way：

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
}

Answer 3

如果您只是想检查一个字符串是否是整数（没有小数位），那么正则表达式是一个很好的方法。其他方法如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

Answer 4

如果你真的想确保一个字符串只包含一个数字，任何数字（整数或浮点数），以及一个数字，那么你不能使用parseInt() / {{ 1}}，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()

滚动自己的正则表达式的问题在于，除非您创建用于匹配浮点数的精确正则表达式，因为Javascript会识别它，否则您将错过案例或识别您不应该的情况。即使你可以推出自己的正则表达式，为什么呢？有更简单的内置方法可以做到。

然而，事实证明，Number("") // returns 0 Number(" ") // returns 0 Number(" \u00A0 \t\n\r") // returns 0（和Number()）对于isNaN()在不应该返回数字的情况下做出正确的事情，反之亦然。因此，要查明字符串是否确实只是一个数字，请调用这两个函数并查看它们两者是否返回true：

parseFloat()

Answer 5

试试isNan function：

isNaN（）函数确定某个值是否为非法数字（非数字）。

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

此功能与特定于数字的Number.isNaN()方法不同。

全局isNaN（）函数，将测试值转换为Number，然后对其进行测试。

Number.isNan（）不会将值转换为数字，并且对于任何非Number类型的值都不会返回true ...

Answer 6

老问题，但在给定的答案中缺少几点。

科学记数法。

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

然而，即便是这个还远未完成。这里没有处理前导零，但他们确实搞了长度测试。

Answer 7

这个问题的公认答案有很多缺陷（其他几个用户都强调了这一点）。这是在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

Answer 8

也许有一两个人遇到这个问题需要比平常更强烈的更严格的检查（就像我一样）。在这种情况下，这可能很有用：

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

小心！这将拒绝.1，40.000，080，00.1等字符串。它非常挑剔 - 字符串必须与此测试通过的数字的“最小完美形式”相匹配。

它使用String和Number构造函数将字符串转换为数字并再次返回，从而检查JavaScript引擎的“完美最小形式”（它是否转换为初始形式） Number构造函数）匹配原始字符串。

Answer 9

parseInt（），但要注意这个函数有点不同，例如它为parseInt（“100px”）返回100。

Answer 10

我已经测试过，迈克尔的解决方案是最好的。投票给他上面的答案（搜索此页面“如果你真的想确保一个字符串”找到它）。从本质上讲，他的回答是：

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，[]（和其他人？）

Answer 11

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

如果参数（字符串）无法转换为数字，则返回NaN，因此您可以确定提供的字符串是否为有效数字。

注意：注意传递空字符串或'\t\t'和'\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

Answer 12

好吧，我正在使用我制作的那个...

到目前为止一直在努力：

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

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

Answer 13

引用：

isNaN（num）//如果变量不包含有效数字
，则返回true

如果你需要检查前导/尾随空格，那么

并不完全正确 - 例如当需要一定数量的数字时，你需要得到'1111'而不是'111'或'111'也许是PIN输入。

最好使用：

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

Answer 14

为什么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));
};

我没有通过其他方式测试过这些，除了手动测试我将遇到的当前困境的几个用例，这些都是非常标准的东西。这是一个“站在巨人肩上”的情况。

Answer 15

这似乎抓住了看似数量不小的边缘情况：

function isNumber(x, noStr) {
    /*

        - Returns true if x is either a finite number type or a string containing only a number
        - If empty string supplied, fall back to explicit false
        - Pass true for noStr to return false when typeof x is "string", off by default

        isNumber(); // false
        isNumber([]); // false
        isNumber([1]); // false
        isNumber([1,2]); // false
        isNumber(''); // false
        isNumber(null); // false
        isNumber({}); // false
        isNumber(true); // false
        isNumber('true'); // false
        isNumber('false'); // false
        isNumber('123asdf'); // false
        isNumber('123.asdf'); // false
        isNumber(undefined); // false
        isNumber(Number.POSITIVE_INFINITY); // false
        isNumber(Number.NEGATIVE_INFINITY); // false
        isNumber('Infinity'); // false
        isNumber('-Infinity'); // false
        isNumber(Number.NaN); // false
        isNumber(new Date('December 17, 1995 03:24:00')); // false
        isNumber(0); // true
        isNumber('0'); // true
        isNumber(123); // true
        isNumber(123.456); // true
        isNumber(-123.456); // true
        isNumber(-.123456); // true
        isNumber('123'); // true
        isNumber('123.456'); // true
        isNumber('.123'); // true
        isNumber(.123); // true
        isNumber(Number.MAX_SAFE_INTEGER); // true
        isNumber(Number.MAX_VALUE); // true
        isNumber(Number.MIN_VALUE); // true
        isNumber(new Number(123)); // true
    */

    return (
        (typeof x === 'number' || x instanceof Number || (!noStr && x && typeof x === 'string' && !isNaN(x))) &&
        isFinite(x)
    ) || false;
};

Answer 16

这是基于先前的一些答案和评论。以下内容涵盖了所有极端情况，并且也相当简洁：

const isNumRegEx = /^-?(\d*\.)?\d+$/;

function isNumeric(n, allowScientificNotation = false) {
    return allowScientificNotation ? 
                !Number.isNaN(parseFloat(n)) && Number.isFinite(n) :
                isNumRegEx.test(n);
}

Answer 17

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

Answer 18

如果有人这么做，我花了一些时间来试图修补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

欢迎任何建议。：

Answer 19

我将此功能用作表单验证工具，但我不希望用户能够编写指数函数，所以我想到了以下功能：

Answer 20

检查JS中的数字：

检查它是否是数字的最佳方法：

.isFinite(20); //真
从字符串中读取一个值。 CSS *:

.parseInt('2.5rem'));//2

.parseFloat('2.5rem'));//2.5
对于整数：

.isInteger(23 / 0));//假
如果值为 NaN：

.isNaN(20)//假

Answer 21

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函数，并在这些用例中进行操作，然后为所有用例扫描“真”。

或者，查看每个返回的值：

Answer 22

省去尝试寻找“内置”解决方案的麻烦。

没有一个很好的答案，这个线程中被高估的答案是错误的。

npm install is-number

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

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

Answer 23

我喜欢这个简单。

id='b'

以上是常规Javascript，但我将其与打字稿typeguard结合使用以进行智能类型检查。这对于打字稿编译器为您提供正确的智能提示并且没有类型错误非常有用。

打字稿字体保护者

Number.isNaN(Number(value))

假设您有一个isNotNumber(value: string | number): value is string { return Number.isNaN(Number(this.smartImageWidth)); } isNumber(value: string | number): value is number { return Number.isNaN(Number(this.smartImageWidth)) === false; }属性width。您可能要根据是否为字符串来进行逻辑处理。

number | string

Typeguard足够聪明，可以将var width: number|string; width = "100vw"; if (isNotNumber(width)) { // the compiler knows that width here must be a string if (width.endsWith('vw')) { // we have a 'width' such as 100vw } } else { // the compiler is smart and knows width here must be number var doubleWidth = width * 2; }语句中的width的类型限制为仅if。这允许编译器允许string，如果类型为width.endsWith(...)则不允许。

您可以随心所欲地调用键盘保护程序string | number，isNotNumber，isNumber，isString，但我认为isNotString有点模棱两可，难以阅读

Answer 24

PFB工作解决方案：

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

Answer 25

我尝试稍微混淆，Pherhaps不是最好的解决方案

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

Answer 26

测试字符串或数字是否为数字

const isNumeric = stringOrNumber =>
  stringOrNumber == 0 || !!+stringOrNumber;

或者如果您想将字符串或数字转换为数字

const toNumber = stringOrNumber =>
  stringOrNumber == 0 || +stringOrNumber ? +stringOrNumber : NaN;

Answer 27

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

Answer 28

因此，这取决于您要处理的测试用例。

function isNumeric(number) {
  return !isNaN(parseFloat(number)) && !isNaN(+number);
}

我要寻找的是javascript中的常规数字类型。 0, 1 , -1, 1.1 , -1.1 , 1E1 , -1E1 , 1e1 , -1e1, 0.1e10, -0.1.e10 , 0xAF1 , 0o172, Math.PI, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY

而且它们也表示为字符串：
'0', '1', '-1', '1.1', '-1.1', '1E1', '-1E1', '1e1', '-1e1', '0.1e10', '-0.1.e10', '0xAF1', '0o172'

我确实想省略而不是将其标记为数字 '', ' ', [], {}, null, undefined, NaN

截止到今天，所有其他答案似乎都未能通过这些测试用例之一。

Answer 29

这是isNumber实现的高性能（2.5 * 10 ^ 7迭代/ s @ 3.8GHz @ Haswell）版本。它适用于我可以找到的每个测试用例（包括符号）：

var isNumber = (function () {
  var isIntegerTest = /^\d+$/;
  var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];
  function hasLeading0s (s) {
    return !(typeof s !== 'string' ||
    s.length < 2 ||
    s[0] !== '0' ||
    !isDigitArray[s[1]] ||
    isIntegerTest.test(s));
  }
  var isWhiteSpaceTest = /\s/;
  return function isNumber (s) {
    var t = typeof s;
    var n;
    if (t === 'number') {
      return (s <= 0) || (s > 0);
    } else if (t === 'string') {
      n = +s;
      return !((!(n <= 0) && !(n > 0)) || n === '0' || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
    } else if (t === 'object') {
      return !(!(s instanceof Number) || ((n = +s), !(n <= 0) && !(n > 0)));
    }
    return false;
  };
})();

Answer 30

它对于TypeScript无效，为：

declare function isNaN(number: number): boolean;

对于TypeScript，您可以使用：

/^\d+$/.test(key)

Answer 31

使用纯JavaScript：

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

使用Lodash：

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

Answer 32

我正在使用以下内容：

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

Answer 33

只需使用isNaN()，这会将字符串转换为数字，如果获得有效的数字，将返回false ...

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

Answer 34

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

本文假设变量以string或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
}

Answer 35

您可以使用类型（如flow librar y）来获取静态的编译时间检查。当然对用户输入并不十分有用。

// @flow

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

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

Answer 36

我的解决方案：

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

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

Answer 37

在我的应用程序中，我们只允许a-z A-Z和0-9个字符。我发现上面的答案使用“ string ％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）]，我不能代表这一点，但是这正是我们所需要的。

Answer 38

我这样做：

function isString(value)
{
    return value.length !== undefined;
}
function isNumber(value)
{
    return value.NaN !== undefined;
}

当然，如果你传递了一些其他具有“长度”的对象，那么isString（）将在这里被绊倒。定义

JavaScript中的（内置）方式，用于检查字符串是否为有效数字

38 个答案:

要检查变量（包括字符串）是否为数字，请检查它是否为数字：

实施例

将包含数字的字符串转换为数字：

实施例

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

实施例

浮筒

空字符串

2019：包括ES3，ES6和TypeScript示例

ES3

ES6

打字稿

打字稿字体保护者

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