# Check if character is number?

I need to check whether `justPrices[i].substr(commapos+2,1)`.

The string is something like: "blabla,120"

In this case it would check whether '0' is a number. How can this be done?

You could use comparison operators to see if it is in the range of digit characters:

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

you can either use `parseInt` and than check with `isNaN`

or if you want to work directly on your string you can use regexp like this:

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

EDIT: Blender's updated answer is the right answer here if you're just checking a single character (namely `!isNaN(parseInt(c, 10))`). My answer below is a good solution if you want to test whole strings.

Here is jQuery's `isNumeric` implementation (in pure JavaScript), which works against full strings:

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

The comment for this function reads:

// parseFloat NaNs numeric-cast false positives (null|true|false|"")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN

I think we can trust that these chaps have spent quite a bit of time on this!

Commented source here. Super geek discussion here.

I wonder why nobody has posted a solution like:

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

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

with an invocation like:

``````if (isDigitCode(justPrices[i].charCodeAt(commapos+2))) {
... // digit
} else {
... // not a digit
}
``````

You can use this:

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

Here, I compared it to the accepted method: http://jsperf.com/isdigittest/5 . I didn't expect much, so I was pretty suprised, when I found out that accepted method was much slower.

Interesting thing is, that while accepted method is faster correct input (eg. '5') and slower for incorrect (eg. 'a'), my method is exact opposite (fast for incorrect and slower for correct).

Still, in worst case, my method is 2 times faster than accepted solution for correct input and over 5 times faster for incorrect input.

I think it's very fun to come up with ways to solve this. Below are some.
(All functions below assume argument is a single character. Change to `n[0]` to enforce it)

## Method 1:

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

## Method 2:

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

## Method 3:

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

## Method 4:

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

## Method 5:

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

### Test string:

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

Simple function

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

If you are testing single characters, then:

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

will return true or false depending on whether c is a digit or not.

I suggest a simple regex.

If you're looking for just the last character in the string:

``````/^.*?[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
``````

And the regex is even simpler if you are just checking a single char as an input:

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

The shortest solution is:

``````const isCharDigit = n => n < 10;
``````

You can apply these as well:

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

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

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

if you want to check more than 1 chatacter, you might use next variants

Regular Expression:

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

Comparison:

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

Check if it is not NaN

``````const isDigit = n => !isNaN(n);
``````
``````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;
}
})()
}
};
``````
``````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));
}
}
``````

output without strict mode:

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

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

true
true
false
false
``````

output with strict mode:

``````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
``````

Try:

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

This seems to work:

Static binding:

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

Prototype binding:

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

It will check single characters, as well as whole strings to see if they are numeric.

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

Source

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

Source code

You can try this (worked in my case)

If you want to test if the first char of a string is an int:

``````if (parseInt(YOUR_STRING.slice(0, 1))) {
} else {
}
``````

If you want to test if the char is a int:

``````if (parseInt(YOUR_CHAR)) {
} else {
}
``````

A simple solution by leveraging language's dynamic type checking:

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

``````

see test cases below

``````function isNumber (string) {
if(string === ' '.repeat(string.length)){
return false
}
return string - 0 === string * 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'))``````

This function works for all test cases that i could find. It's also faster than:

``````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];

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

As far as I know, easiest way is just to multiply by `1`:

``````var character = ... ; // your character
var isDigit = ! isNaN(character * 1);
``````

Multiplication by one makes a number from any numeric string (as you have only one character it will always be an integer from 0 to 9) and a `NaN` for any other string.

Similar to one of the answers above, I used

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

This blogpost sheds some more light on this check if a string is numeric in Javascript | Typescript & ES6

Just use `isFinite`

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