在Typescript中，如何检查字符串是否为Numeric

小开

一个字符串是否可以被解析为数字是一个运行时的问题。Typescript不支持这个用例，因为它关注的是编译时(而不是运行时)安全。

小开

最佳答案

将字符串转换为数字的方法是使用Number，而不是parseFloat。

Number('1234') // 1234
Number('9BX9') // NaN

如果你喜欢速记，你也可以使用一元加号运算符:

+'1234' // 1234
+'9BX9' // NaN

检查NaN时要小心(操作符===和!==对NaN不能像预期的那样工作)。使用:

 isNaN(+maybeNumber) // returns true if NaN, otherwise false

小开

更新

此方法在rxjs v6中不再可用

我通过使用rxjs库中的isNumeric操作符来解决它(导入rxjs / util / isNumeric

import { isNumeric } from 'rxjs/util/isNumeric';

。． .

var val = "5700";
if (isNumeric(val)){
alert("it is number !");
}

小开

function isNumber(value: string | number): boolean
{
return ((value != null) &&
(value !== '') &&
!isNaN(Number(value.toString())));
}

小开

我会选择一个现有的和已经测试过的解决方案。例如，typescript中的rxjs:

function isNumeric(val: any): val is number | string {
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN
// adding 1 corrects loss of precision from parseFloat (#15100)
return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
}

rxjs/isNumeric.ts .ts

没有rxjs的isArray()函数，只有简化的类型:

function isNumeric(val: any): boolean {
return !(val instanceof Array) && (val - parseFloat(val) + 1) >= 0;
}

你应该总是用你的用例来测试这样的函数。如果您有特殊的值类型，这个函数可能不是您的解决方案。你可以在这里测试这个函数。

结果是:

enum         : CardTypes.Debit   : true
decimal      : 10                : true
hexaDecimal  : 0xf10b            : true
binary       : 0b110100          : true
octal        : 0o410             : true
stringNumber : '10'              : true


string       : 'Hello'           : false
undefined    : undefined         : false
null         : null              : false
function     : () => {}          : false
array        : [80, 85, 75]      : false
turple       : ['Kunal', 2018]   : false
object       : {}                : false

如您所见，如果您将此函数用于枚举，则必须非常小心。

小开

大多数情况下，我们想要检查的值是字符串或数字，所以这里是我使用的函数:

const isNumber = (n: string | number): boolean =>
!isNaN(parseFloat(String(n))) && isFinite(Number(n));

Codesandbox测试。

const willBeTrue = [0.1, '1', '-1', 1, -1, 0, -0, '0', "-0", 2e2, 1e23, 1.1, -0.1, '0.1', '2e2', '1e23', '-0.1', ' 898', '080']


const willBeFalse = ['9BX46B6A', "+''", '', '-0,1', [], '123a', 'a', 'NaN', 1e10000, undefined, null, NaN, Infinity, () => {}]

小开

考虑到你的变量可以是字符串、数字或任何类型——对于Angular/Typescript中的完整数字(非浮点数)，你可以使用:

var isFullNumber: boolean =
Number.isInteger(Number(yourVariable)) && yourVariable !== null;

正如@tarrbal所指出的那样，我们不能使用just:

Number.isInteger(yourVariable);

要证明这一点，请检查以下三个测试:

let testVariables = [0, 1, "0", "1", "A", {}, -3, 0.1, NaN, null, undefined];


let isFullNumber: boolean;
let ix: number = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(v);                         // <---
console.log(ix++, ': ', v, isFullNumber);
})


console.log('--------------');


ix = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(Number(v));                 // <---
console.log(ix++, ': ', v, isFullNumber);
})


console.log('--------------');
ix = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(Number(v)) && v !== null;   // <---
console.log(ix++, ': ', v, isFullNumber);
})

这三个结果:

1   :       0           true
2   :       1           true
3   :       0           false <- would expect true
4   :       1           false <- would expect true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        false
11  :       undefined   false
----------------------------
1   :       0           true
2   :       1           true
3   :       0           true
4   :       1           true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        true <- would expect false
11  :       undefined   false
----------------------------
1   :       0           true
2   :       1           true
3   :       0           true
4   :       1           true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        false
11  :       undefined   false

小开

你可以使用Number.isFinite()函数:

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false
Number.isFinite('0');       // false
Number.isFinite(null);      // false


Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

注意:在全局函数isFinite()和后面的Number.isFinite()之间有一个显著的区别。在前者的情况下，执行字符串强制—因此isFinite('0') === true和Number.isFinite('0') === false。

另外，请注意这在IE中是不可用的!

小开

简单的回答:(手表为空白&空)

isNaN(+'111') = false;
isNaN(+'111r') = true;
isNaN(+'r') = true;
isNaN(+'') = false;
isNaN(null) = false;

< a href = " https://codepen.io/CQCoder/pen/zYGEjxd?编辑= 1111 noreferrer“rel = > https://codepen.io/CQCoder/pen/zYGEjxd?编辑= 1111 < / >

小开

我的简单解决方案是:

const isNumeric = (val: string) : boolean => {
return !isNaN(Number(val));
}


// isNumberic("2") => true
// isNumeric("hi") => false;

小开

如果 var和= 0; var x;

那么，这个呢? 和+ = (x | 0);

小开

浏览了每个答案，惊讶地发现竟然没有出现这样简单的一行字:

const isNumber = (val: string | number) => !!(val || val === 0) && !isNaN(Number(val.toString()));

小开

我的解决方案:

 function isNumeric(val: unknown): val is string | number {
return (
!isNaN(Number(Number.parseFloat(String(val)))) &&
isFinite(Number(val))
);
}

// true
isNumeric("-10");
isNumeric("0");
isNumeric("0xff");
isNumeric("0xFF");
isNumeric("8e5");
isNumeric("3.1415");
isNumeric("+10");
isNumeric("144");
isNumeric("5");


// false
isNumeric("-0x42");
isNumeric("7.2acdgs");
isNumeric("");
isNumeric({});
isNumeric(NaN);
isNumeric(null);
isNumeric(true);
isNumeric(Infinity);
isNumeric(undefined);
isNumeric([]);
isNumeric("some string");

小开

 const isNumeric = (value: string): boolean =>
!new RegExp(/[^\d]/g).test(value.trim());

如果你想允许小数点

   const isNumeric = (value: string): boolean =>
!new RegExp(/[^\d.]/g).test(value.trim());

小开

这是我信赖的isNumber函数。明智地使用它

function isNumber(numStr: string) {
return !isNaN(parseFloat(numStr)) && !isNaN(+numStr)
}

测试

it("test valid isNumber", () => {
expect(isNumber("0")).toEqual(true)
expect(isNumber("-1")).toEqual(true)
})


it("test invalid isNumber", () => {
expect(isNumber('" 1000 "')).toEqual(false)
expect(isNumber('" 100,00.00 "')).toEqual(false)
expect(isNumber("100,00.00")).toEqual(false)
expect(isNumber("")).toEqual(false)
expect(isNumber(null as any as string)).toEqual(false)
expect(isNumber("abc")).toEqual(false)
expect(isNumber("10%")).toEqual(false)
expect(isNumber("#10")).toEqual(false)
expect(isNumber("2^10")).toEqual(false)
expect(isNumber("2!")).toEqual(false)
expect(isNumber("(10)")).toEqual(false)
expect(isNumber("10px")).toEqual(false)
})

小开

这适用于特殊情况，例如空值

if(!isNaN(yourValue) && yourValue !== true && yourValue !== false) {
// then it's a number
} else {
// then it's not a number
}