检查字符是否为数字？

我需要检查 justPrices[i].substr(commapos+2,1)。

字符串类似于: “ blabla，120”

在这种情况下，它会检查“0”是否是一个数字。如何做到这一点？

302055 次浏览
小开

你可以使用 parseInt，然后用 isNaN检查

或者如果想直接处理字符串，可以像下面这样使用 regexp:

function is_numeric(str){
return /^\d+$/.test(str);
}
小开

可以使用比较运算符查看它是否在数字字符范围内:

var c = justPrices[i].substr(commapos+2,1);
if (c >= '0' && c <= '9') {
// it is a number
} else {
// it isn't
}
小开

如果您正在测试单个字符，那么:

var isDigit = (function() {
var re = /^\d$/;
return function(c) {
return re.test(c);
}
}());

将返回 true 或 false，具体取决于 c 是否为数字。

小开 
function is_numeric(mixed_var) {
return (typeof(mixed_var) === 'number' || typeof(mixed_var) === 'string') &&
mixed_var !== '' && !isNaN(mixed_var);
}

源代码

小开

编辑: 如果你只是检查一个字符(即 !isNaN(parseInt(c, 10))) ，Blender 更新的答案是正确的。如果您想测试整个字符串，我下面的答案是一个很好的解决方案。

下面是 jQuery 的 isNumeric实现(纯 JavaScript) ，它是针对 全部条件工作的:

function isNumeric(s) {
return !isNaN(s - parseFloat(s));
}

该函数的注释如下:

//parseFloat NaNs 数值转换假阳性(null | true | false | “”)
//... 但是误解了前导数字符串，特别是十六进制文字(“0x...”)
//减法对 NaN 的作用力无穷大

我想我们可以相信，这些家伙花了相当多的时间在这上面！

评论源 给你。超级极客讨论 给你。

小开

你可以用这个:

function isDigit(n) {
return Boolean([true, true, true, true, true, true, true, true, true, true][n]);
}

在这里，我将其与公认的方法 http://jsperf.com/isdigittest/5进行了比较。我没有期望太多，所以当我发现接受的方法要慢得多时，我非常惊讶。

有趣的是，虽然接受的方法是更快的正确输入(例如’5’)和慢的不正确(例如’a’) ，我的方法是完全相反的(快的不正确和慢的正确)。

尽管如此，在最坏的情况下，我的方法对于正确的输入比接受的解快2倍，对于不正确的输入快5倍以上。

小开 
square = function(a) {
if ((a * 0) == 0) {
return a*a;
} else {
return "Enter a valid number.";
}
}

来源

小开

你可以试试这个(在我的案例中起作用)

如果要测试字符串的第一个字符是否为 int:

if (parseInt(YOUR_STRING.slice(0, 1))) {
alert("first char is int")
} else {
alert("first char is not int")
}

如果您想测试 char 是否为 int:

if (parseInt(YOUR_CHAR)) {
alert("first char is int")
} else {
alert("first char is not int")
}
小开

我认为想出解决这个问题的方法是非常有趣的。
(假设参数下面的所有函数都是单个字符。更改为 n[0]以强制执行它)

方法一:

function isCharDigit(n){
return !!n.trim() && n > -1;
}

方法二:

function isCharDigit(n){
return !!n.trim() && n*0==0;
}

方法三:

function isCharDigit(n){
return !!n.trim() && !!Number(n+.1); // "+.1' to make it work with "." and "0" Chars
}

方法四:

var isCharDigit = (function(){
var a = [1,1,1,1,1,1,1,1,1,1];
return function(n){
return !!a[n] // check if `a` Array has anything in index 'n'. Cast result to boolean
}
})();

方法五:

function isCharDigit(n){
return !!n.trim() && !isNaN(+n);
}

测试字符串:

var str = ' 90ABcd#?:.+', char;
for( char of str )
console.log( char, isCharDigit(char) );
小开

这似乎行得通:

静态绑定:

String.isNumeric = function (value) {
return !isNaN(String(value) * 1);
};

原型绑定:

String.prototype.isNumeric = function () {
return !isNaN(this.valueOf() * 1);
};

它将检查单个字符以及整个字符串，以确定它们是否是数字。

小开

我想知道为什么没有人提出这样的解决方案:

var charCodeZero = "0".charCodeAt(0);
var charCodeNine = "9".charCodeAt(0);


function isDigitCode(n) {
return(n >= charCodeZero && n <= charCodeNine);
}

像这样的调用:

if (isDigitCode(justPrices[i].charCodeAt(commapos+2))) {
... // digit
} else {
... // not a digit
}
小开 
isNumber = function(obj, strict) {
var strict = strict === true ? true : false;
if (strict) {
return !isNaN(obj) && obj instanceof Number ? true : false;
} else {
return !isNaN(obj - parseFloat(obj));
}
}

没有严格模式的输出:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;


isNumber(num);
isNumber(textnum);
isNumber(text);
isNumber(nan);


true
true
false
false

严格模式输出:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;


isNumber(num, true);
isNumber(textnum, true);
isNumber(text, true);
isNumber(nan);


true
false
false
false
小开 
var Is = {
character: {
number: (function() {
// Only computed once
var zero = "0".charCodeAt(0), nine = "9".charCodeAt(0);


return function(c) {
return (c = c.charCodeAt(0)) >= zero && c <= nine;
}
})()
}
};
小开

用 isFinite

const number = "1";
if (isFinite(number)) {
// do something
}
小开

试试:

function is_numeric(str){
try {
return isFinite(str)
}
catch(err) {
return false
}
}
小开

简单的功能

function isCharNumber(c) {
return c >= '0' && c <= '9';
}
小开

我建议使用简单的正则表达式。

如果您只是在查找字符串中的最后一个字符:

/^.*?[0-9]$/.test("blabla,120");  // true
/^.*?[0-9]$/.test("blabla,120a"); // false
/^.*?[0-9]$/.test("120");         // true
/^.*?[0-9]$/.test(120);           // true
/^.*?[0-9]$/.test(undefined);     // false
/^.*?[0-9]$/.test(-1);            // true
/^.*?[0-9]$/.test("-1");          // true
/^.*?[0-9]$/.test(false);         // false
/^.*?[0-9]$/.test(true);          // false

如果只检查一个字符作为输入，那么正则表达式甚至更简单:

var char = "0";
/^[0-9]$/.test(char);             // true
小开

一个利用语言的动态类型检查的简单解决方案:

function isNumber (string) {
//it has whitespace
if(string.trim() === ''){
return false
}
return string - 0 === string * 1
}

参见下面的测试用例

function isNumber (str) {
if(str.trim() === ''){
return false
}
return str - 0 === str * 1
}




console.log('-1' + ' → ' + isNumber ('-1'))
console.log('-1.5' + ' → ' + isNumber ('-1.5'))
console.log('0' + ' → ' + isNumber ('0'))
console.log(', ,' + ' → ' + isNumber (', ,'))
console.log('0.42' + ' → ' + isNumber ('0.42'))
console.log('.42' + ' → ' + isNumber ('.42'))
console.log('#abcdef' + ' → ' + isNumber ('#abcdef'))
console.log('1.2.3' + ' → ' + isNumber ('1.2.3'))
console.log('' + ' → ' + isNumber (''))
console.log('blah' + ' → ' + isNumber ('blah'))

小开

这个函数适用于我能找到的所有测试用例。 它也比:

function isNumeric (n) {
if (!isNaN(parseFloat(n)) && isFinite(n) && !hasLeading0s(n)) {
return true;
}
var _n = +n;
return _n === Infinity || _n === -Infinity;
}


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


function fIsNaN(n) {
return !(n <= 0) && !(n > 0);
}


function isNumber(s) {
var t = typeof s;
if (t === 'number') {
return (s <= 0) || (s > 0);
} else if (t === 'string') {
var n = +s;
return !(fIsNaN(n) || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
} else if (t === 'object') {
return !(!(s instanceof Number) || fIsNaN(+s));
}
return false;
}


function testRunner(IsNumeric) {
var total = 0;
var passed = 0;
var failedTests = [];


function test(value, result) {
total++;
if (IsNumeric(value) === result) {
passed++;
} else {
failedTests.push({
value: value,
expected: result
});
}
}
// true
test(0, true);
test(1, true);
test(-1, true);
test(Infinity, true);
test('Infinity', true);
test(-Infinity, true);
test('-Infinity', true);
test(1.1, true);
test(-0.12e-34, true);
test(8e5, true);
test('1', true);
test('0', true);
test('-1', true);
test('1.1', true);
test('11.112', true);
test('.1', true);
test('.12e34', true);
test('-.12e34', true);
test('.12e-34', true);
test('-.12e-34', true);
test('8e5', true);
test('0x89f', true);
test('00', true);
test('01', true);
test('10', true);
test('0e1', true);
test('0e01', true);
test('.0', true);
test('0.', true);
test('.0e1', true);
test('0.e1', true);
test('0.e00', true);
test('0xf', true);
test('0Xf', true);
test(Date.now(), true);
test(new Number(0), true);
test(new Number(1e3), true);
test(new Number(0.1234), true);
test(new Number(Infinity), true);
test(new Number(-Infinity), true);
// false
test('', false);
test(' ', false);
test(false, false);
test('false', false);
test(true, false);
test('true', false);
test('99,999', false);
test('#abcdef', false);
test('1.2.3', false);
test('blah', false);
test('\t\t', false);
test('\n\r', false);
test('\r', false);
test(NaN, false);
test('NaN', false);
test(null, false);
test('null', false);
test(new Date(), false);
test({}, false);
test([], false);
test(new Int8Array(), false);
test(new Uint8Array(), false);
test(new Uint8ClampedArray(), false);
test(new Int16Array(), false);
test(new Uint16Array(), false);
test(new Int32Array(), false);
test(new Uint32Array(), false);
test(new BigInt64Array(), false);
test(new BigUint64Array(), false);
test(new Float32Array(), false);
test(new Float64Array(), false);
test('.e0', false);
test('.', false);
test('00e1', false);
test('01e1', false);
test('00.0', false);
test('01.05', false);
test('00x0', false);
test(new Number(NaN), false);
test(new Number('abc'), false);
console.log('Passed ' + passed + ' of ' + total + ' tests.');
if (failedTests.length > 0) console.log({
failedTests: failedTests
});
}
testRunner(isNumber)

小开

最短的解决办法是:

const isCharDigit = n => n < 10;

你也可以应用这些:

const isCharDigit = n => Boolean(++n);


const isCharDigit = n => '/' < n && n < ':';


const isCharDigit = n => !!++n;

如果要检查多个字符，可以使用下一个变量

正则表达式:

const isDigit = n => /\d+/.test(n);

比较:

const isDigit = n => +n == n;

检查是否不是 NaN

const isDigit = n => !isNaN(n);
小开

结合使用 isNaN和 parseInt功能:

var character = ... ; // your character
var isDigit = ! isNaN( parseInt(character) );

另一种值得注意的方法是乘以1(比如用 character * 1代替 parseInt(character)) ，不仅可以从任何数字字符串中得到一个数字，还可以从空字符串中得到一个 0，并且字符串中只包含空格，所以这里不适合使用。

小开

与上面的一个答案类似，我使用

 var sum = 0; //some value
let num = parseInt(val); //or just Number.parseInt
if(!isNaN(num)) {
sum += num;
}

这篇博客文章对这个 检查一个字符串在 Javascript 中是否为数字提供了更多的解释

小开

下面是一个简单的函数。

function is_number(char) \{\{
return !isNaN(parseInt(char));
}}


Returns:  true, false
小开

我用的是这个:

const isNumber = (str) => (
str.length === str.trim().length
&& str.length > 0
&& Number(str) >= 0
)

它适用于字符串或单个字符。

小开

修改这个 回答使其更加方便，并且限制为字符(而不是字符串) :

const charCodeZero = "0".charCodeAt(0);
const charCodeNine = "9".charCodeAt(0);
function isDigit(s:string) {
return s.length==1&& s.charCodeAt(0) >= charCodeZero && s.charCodeAt(0) <= charCodeNine;
}


console.log(isDigit('4'))   //true
console.log(isDigit('4s'))  //false
console.log(isDigit('s'))   //false
小开

使用简单的正则表达式解决方案只检查一个字符:

function isDigit(chr) {
return  chr.match(/[0-9]/i);
}
小开

Let ch =’6’;//或任何其他具有整数值的字符串

可以使用的简单函数: ! isNaN (ch-’0’)

小开

尝试使用 isNAN

一般来说:

isNAN(char)

例子:

let isNum = !isNAN('5')  // true
let isNum = !isNAN('a')  // false

提交答案