检查字符是否为数字？答案

【问题标题】：Check if character is number?检查字符是否为数字？
【发布时间】：2012-01-20 01:12:54
【问题描述】：

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

字符串类似于：“blabla,120”

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

【问题讨论】：

可能复制到here
@cctan 这不是重复的。这个问题是关于检查一个字符串，这是关于检查一个字符。
Validate decimal numbers in JavaScript - IsNumeric()的可能重复

标签： javascript

【解决方案1】：

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

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

【讨论】：

【解决方案2】：

您可以使用parseInt，也可以使用isNaN检查

或者如果你想直接处理你的字符串，你可以像这样使用正则表达式：

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

【讨论】：

如果我们只需要检查单个字符，甚至更简单：function is_numeric_char(c) { return /\d/.test(c); }
@jackocnr 对于包含多个字符的字符串（例如is_numeric_char("foo1bar") == true），您的测试也将返回true。如果您想检查数字字符 /^\d$/.test(c) 将是一个更好的解决方案。但无论如何，这不是问题:)
你也可以使用 typeof 比如：typeof parseInt(char, 10) === 'number'

【解决方案3】：

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

这是 jQuery 的 isNumeric 实现（在纯 JavaScript 中），它适用于完整字符串：

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

这个函数的注释是：

// parseFloat NaNs 数字转换误报 (null|true|false|"")
// ...但会误解前导数字字符串，尤其是十六进制文字 ("0x...")
// 减法迫使无穷大为 NaN

我认为我们可以相信这些家伙已经为此花费了相当多的时间！

评论源here。超级极客讨论here.

【讨论】：

这行得通，但它对于仅数字检查来说是一种过度杀伤（它适用于多位数字）。我的解决方案可能不那么清楚，但比这快得多。

【解决方案4】：

我想知道为什么没有人发布这样的解决方案：

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
}

【讨论】：

精确搜索了那种解决方案 - ty
您可以删除 charCodeAt 的 0 参数值，因为在未提供参数时隐含 0。

【解决方案5】：

简单的功能

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

【讨论】：

【解决方案6】：

你可以用这个：

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 倍以上。

【讨论】：

我喜欢这个答案！也许将其优化为：!!([!0, !0, !0, !0, !0, !0, !0, !0, !0, !0][n]); 它具有巨大的 WTF 潜力并且运行良好（007 失败）。
@Jonathan - 见我的answer，方法#4
根据这个“解决方案”，"length"（和数组上的其他属性）是数字：P

【解决方案7】：

我认为想出解决这个问题的方法很有趣。以下是一些。
（assume 参数下的所有函数都是单个字符。更改为 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) );

【讨论】：

方法 1、2、3 和 5 输出 true 为 " "。
为了好玩，我做了一个 jsperf，然后添加了一个 charCodeAt() 比较 - 这几乎快 4 倍 - jsperf.com/isdigit3
@Rycochet - 不错。 ASCII 码范围确实是最好的测试方法..

【解决方案8】：

最短的解决方案是：

const isCharDigit = n => n < 10;

您也可以应用这些：

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

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

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

如果您想检查超过 1 个字符，您可以使用下一个变体

正则表达式：

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

比较：

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

检查是否不是NaN

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

【讨论】：

第一个似乎是错误的，例如n<10会为空格字符返回true。
Boolean(++n) 也为空格字符返回 true。

【解决方案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

【讨论】：

【解决方案10】：

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

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

将根据 c 是否为数字返回真或假。

【讨论】：

【解决方案11】：

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

【讨论】：

【解决方案12】：

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

【讨论】：

【解决方案13】：

试试：

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

【讨论】：

【解决方案14】：

类似于上面的一个答案，我用过

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

这篇博文进一步阐明了check if a string is numeric in Javascript | Typescript & ES6

【讨论】：

【解决方案15】：

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

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

【讨论】：

【解决方案16】：

结合使用isNaN 和parseInt 函数：

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

另一种值得注意的方式 - 乘以一（例如 character * 1 而不是 parseInt(character)） - 不仅可以从任何数字字符串生成数字，还可以从空字符串和仅包含空格的字符串生成 0，因此它是不适合这里。

【讨论】：

【解决方案17】：

这是一个简单的函数。

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

Returns:  true, false

【讨论】：

【解决方案18】：

这似乎有效：

静态绑定：

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

原型绑定：

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

它将检查单个字符以及整个字符串以查看它们是否为数字。

【讨论】：

【解决方案19】：

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

Source

【讨论】：

【解决方案20】：

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

Source code

【讨论】：

【解决方案21】：

你可以试试这个（在我的情况下有效）

如果要测试字符串的第一个字符是否为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")
}

【讨论】：

if (parseInt(YOUR_CHAR)) 在字符为 0 时不会是真的 :) 至少你必须做 if (parseInt(YOUR_CHAR) + 1) 或更好地比较 NaN => if (parseInt(YOUR_CHAR) !== NaN)

【解决方案22】：

此功能适用于我能找到的所有测试用例。它也比：

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)

【讨论】：

我修复了“0”的情况。

【解决方案23】：

我正在使用这个：

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

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

【讨论】：

【解决方案24】：

修改此answer 使其更方便并限制为字符（而不是字符串）：

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

【讨论】：

【解决方案25】：

只需使用isFinite

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

【讨论】：

这对空格“”返回true