CODEWITHSUNDEEP
javascript
lisovaccaro
lisovaccaro

Reputation: 33946

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?

Upvotes: 182

Views: 366822

Answers (28)

João Pimentel Ferreira
João Pimentel Ferreira

Reputation: 16233

Simple function:

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

If you want to ensure c is really a single character:

function isCharNumber(c) {
  return typeof c === 'string' && c.length === 1 && c >= '0' && c <= '9';
}

Upvotes: 43

Lucianoomd
Lucianoomd

Reputation: 21

I am using this:

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

It works for strings or single characters.

Upvotes: 1

Maciej Kravchyk
Maciej Kravchyk

Reputation: 16607

This assumes that the input is string (makes more sense in TypeScript).


const isDigit = (char) => ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].indexOf(char) !== -1;

Upvotes: 0

RobG
RobG

Reputation: 147363

If you are testing single characters, then:

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

['e','0'].forEach(c => console.log(
  `isDigit("${c}") : ${isDigit(c)}`)
);

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

Upvotes: 5

Matt
Matt

Reputation: 35203

Try using isNAN

generally:

isNAN(char)

examples:

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

Upvotes: 0

Puneet Pant
Puneet Pant

Reputation: 39

let ch = '6'; // or any other string that has integer value

Simple function that can be used : !isNaN(ch - '0')

Upvotes: 0

burak isik
burak isik

Reputation: 571

Use simple regex solution to check only one char:

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

Upvotes: 0

Eliav Louski
Eliav Louski

Reputation: 5214

modifying this answer to be little more convenient and limiting to chars(and not string):

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

Upvotes: 1

1234ru
1234ru

Reputation: 842

Use combination of isNaN and parseInt functions:

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

Another notable way - multiplication by one (like character * 1 instead of parseInt(character)) - makes a number not only from any numeric string, but also a 0 from empty string and a string containing only spaces so it is not suitable here.

Upvotes: 4

Mechanic
Mechanic

Reputation: 5380

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

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

see test cases below

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

Upvotes: 1

Vladyslav Beziazychenko
Vladyslav Beziazychenko

Reputation: 95

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

Upvotes: 6

mjs
mjs

Reputation: 22347

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

Upvotes: 3

cptdanko
cptdanko

Reputation: 842

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

Upvotes: 4

c7x43t
c7x43t

Reputation: 274

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

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)

Upvotes: 0

zenslug
zenslug

Reputation: 61

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

Upvotes: 6

jackocnr
jackocnr

Reputation: 17416

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.

Upvotes: 41

Insp
Insp

Reputation: 11

Try:

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

Upvotes: 1

vsync
vsync

Reputation: 130065

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

Upvotes: 13

Banning Stuckey
Banning Stuckey

Reputation: 575

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

Upvotes: 1

TheOne LuKcian
TheOne LuKcian

Reputation: 89

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))) {
    alert("first char is int")
} else {
    alert("first char is not int")
}

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

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

Upvotes: 0

Alexander Serkin
Alexander Serkin

Reputation: 1787

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

Source code

Upvotes: 0

Lourayad
Lourayad

Reputation: 9

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

Source

Upvotes: 0

Gibolt
Gibolt

Reputation: 47079

Just use isFinite

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

Upvotes: 0

Marian
Marian

Reputation: 7472

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
}

Upvotes: 32

Matthew Layton
Matthew Layton

Reputation: 42229

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.

Upvotes: 0

user2486570
user2486570

Reputation: 982

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.

Upvotes: 19

GregL
GregL

Reputation: 38103

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
}

Upvotes: 132

Yaron U.
Yaron U.

Reputation: 7881

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

Upvotes: 85

Related Questions