Check whether variable is number or string in JavaScript

Question

Does anyone know how can I check whether a variable is a number or a string in JavaScript?

Answer 1

If you're dealing with literal notation, and not constructors, you can use typeof:.

typeof "Hello World"; // string
typeof 123;           // number

If you're creating numbers and strings via a constructor, such as var foo = new String("foo"), you should keep in mind that typeof may return object for foo.

Perhaps a more foolproof method of checking the type would be to utilize the method found in underscore.js (annotated source can be found here),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

This returns a boolean true for the following:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

Answer 2

Best way to do that is using isNaN + type casting:

Updated all-in method:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

The same using regex:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber('123'); // true  
isNumber('123abc'); // false  
isNumber(5); // true  
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

Answer 3

The best way I have found is to either check for a method on the string, i.e.:

if (x.substring) {
// do string thing
} else{
// do other thing
}

or if you want to do something with the number check for a number property,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

This is sort of like "duck typing", it's up to you which way makes the most sense. I don't have enough karma to comment, but typeof fails for boxed strings and numbers, i.e.:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

will alert "object".

Answer 4

Since ES2015 the correct way to check if a variable holds a valid number is Number.isFinite(value)

Examples:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

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

Number.isFinite('0')        // false
Number.isFinite(null)       // false

Answer 5

You're looking for isNaN():

console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));

See JavaScript isNaN() Function at MDN.

Answer 6

Check if the value is a string literal or String object:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Unit test:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

Checking for a number is similar:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Answer 7

Try this,

<script>
var regInteger = /^-?\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>

Answer 8

Simple and thorough:

function isNumber(x) {
  return parseFloat(x) == x
};

Test cases:

console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));

console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));

Answer 9

Best way to do this:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

This satisfies the following test cases:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

Answer 10

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is('String', 'test'); // true
is('Array', true); // false

Or adapt it to return an unknown type:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

May 12, 2012 Update: Full example at Javascript: A Better typeof.

Answer 11

Here's an approach based on the idea of coercing the input to a number or string by adding zero or the null string, and then do a typed equality comparison.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

For some unfathomable reason, x===x+0 seems to perform better than x===+x.

Are there any cases where this fails?

In the same vein:

function is_boolean(x) { return x === !!x; }

This appears to be mildly faster than either x===true || x===false or typeof x==="boolean" (and much faster than x===Boolean(x)).

Then there's also

function is_regexp(x)  { return x === RegExp(x); }

All these depend on the existence of an "identity" operation particular to each type which can be applied to any value and reliably produce a value of the type in question. I cannot think of such an operation for dates.

For NaN, there is

function is_nan(x) { return x !== x;}

This is basically underscore's version, and as it stands is about four times faster than isNaN(), but the comments in the underscore source mention that "NaN is the only number that does not equal itself" and adds a check for _.isNumber. Why? What other objects would not equal themselves? Also, underscore uses x !== +x--but what difference could the + here make?

Then for the paranoid:

function is_undefined(x) { return x===[][0]; }

or this

function is_undefined(x) { return x===void(0); }

Answer 12

Or just use the invert of isNaN():

if(!isNaN(data))
  do something with the number
else
  it is a string

And yes, using jQuery's $.isNumeric() is more fun for the buck.

Answer 13

Beware that typeof NaN is... 'number'

typeof NaN === 'number'; // true

Answer 14

Can you just divide it by 1?

I assume the issue would be a string input like: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

Just a way I did it recently.

Answer 15

I think converting the var to a string decreases the performance, at least this test performed in the latest browsers shows so.

So if you care about performance, I would, I'd use this:

typeof str === "string" || str instanceof String

for checking if the variable is a string (even if you use var str = new String("foo"), str instanceof String would return true).

As for checking if it's a number I would go for the native: isNaN; function.

Answer 16

uh, how about just:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

After further review many months later, this only guarantees obj is an object that has the method or property name toLowerCase defined. I am ashamed of my answer. Please see top-voted typeof one.

Answer 17

jQuery uses this:

function isNumber(obj) {
  return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}

Answer 18

This solution resolves many of the issues raised here!

This is by far the most reliable method I have used by far. I did not invent this, and cannot recall where I originally found it. But it works where other techniques fail:

// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
  if (undefined === data ){ return 'Undefined'; }
  if (data === null ){ return 'Null'; }
  return {}.toString.call(data).slice(8, -1);
};  
// End public utility /getVarType/

Example of correctness

var str = new String();
console.warn( getVarType(str) ); // Reports "String"    
console.warn( typeof str );      // Reports "object"

var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num );      // Reports "object"

var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list );        // Reports "object"

Answer 19

Jsut an FYI, if you're using jQuery you have

$.isNumeric() 

to handle this. More details on http://api.jquery.com/jQuery.isNumeric/

Answer 20

the best way i found which also thinks of positive and negative numbers is from : O'Reilly Javascript and DHTML Cookbook :

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
    oneChar = str.charAt(i).charCodeAt(0);
    // OK for minus sign as first character
    if (oneChar =  = 45) {
        if (i =  = 0) {
            continue;
        } else {
            alert("Only the first character may be a minus sign.");
            return false;
        }
    }
    // OK for one decimal point
    if (oneChar =  = 46) {
        if (!oneDecimal) {
            oneDecimal = true;
            continue;
        } else {
            alert("Only one decimal is allowed in a number.");
            return false;
        }
    }
    // characters outside of 0 through 9 not OK
    if (oneChar < 48 || oneChar > 57) {
        alert("Enter only numbers into the field.");
        return false;
    }
}
return true;

}

Answer 21

Errr? Just use regular expressions! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*/\.[0-9]+$/)
}

Answer 22

since a string as '1234' with typeof will show 'string', and the inverse cannot ever happen (typeof 123 will always be number), the best is to use a simple regex /^\-?\d+$/.test(var). Or a more advanced to match floats, integers and negative numbers, /^[\-\+]?[\d]+\.?(\d+)?$/ The important side of .test is that it WON'T throw an exception if the var isn't an string, the value can be anything.

var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;

regex.test(val)       // false 
val = '1234';
regex.test(val)       // true
val = '-213';
regex.test(val)       // true
val = '-213.2312';
regex.test(val)       // true
val = '+213.2312';
regex.test(val)       // true
val = 123;
regex.test(val)       // true
val = new Number(123);
regex.test(val)       // true
val = new String('123');
regex.test(val)       // true
val = '1234e';
regex.test(val)       // false 
val = {};
regex.test(val)       // false 
val = false;
regex.test(val)       // false 
regex.test(undefined) // false 
regex.test(null)      // false 
regex.test(window)    // false 
regex.test(document)  // false 

If you are looking for the real type, then typeof alone will do.

Answer 23

@BitOfUniverse's answer is good, and I come up with a new way:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('')  // false
isNum(2)   // true
isNum('2k') // false
isNum('2')  //true

I know 0 can't be dividend, but here the function works perfectly.

Answer 24

typeof works very well for me in most case. You can try using an if statement

if(typeof x === 'string' || typeof x === 'number') {
    console.log("Your statement");
}

where x is any variable name of your choice

Answer 25

Type checking

You can check the type of variable by using typeof operator:

typeof variable

Value checking

The code below returns true for numbers and false for anything else:

!isNaN(+variable);

Answer 26

XOR operation can be used to detect number or string. number ^ 0 will always give the same number as output and string ^ 0 will give 0 as output.

Example: 
   1)  2 ^ 0 = 2
   2)  '2' ^ 0  = 2
   3)  'Str' ^ 0 = 0

Answer 27

With the many answers with many examples already, this answer is to show a comparison of results from the many different combinations of functions and values.

You will find almost each function returns different results using the same sample set of data. You may have to be selective to ensure the function you are using returns the results you are indeed looking for.

And of course, the functions & values objects can be further modified with your favorite different entries if not already included.

'use strict';

// Collection of test functions
const functions = {
    'constructor.name': value => !(value === undefined || value === null) ? value.constructor.name : '',
    'typeof': value => typeof value,
    'Number.isFinite': value => Number.isFinite(value),
    'isFinite': value => isFinite(value),
    '!Number.isNaN': value => !Number.isNaN(value),
    '!isNaN': value => !isNaN(value),
    'ternany': value => value ? 'true' : 'false',
    '>=<0': value => value >= 0 || value < 0,
    'regexInteger': value => /^-?\d+$/.test(value),
    'regexFloat': value => /^[\-\+]?[\d]+\.?(\d+)?$/.test(value),
    '$.isNumeric()': value => !isNaN(parseFloat(value)) && isFinite(value),
    'parseFloatLoose': value => parseFloat(value) == value,
    'parseFloatStrict': value => parseFloat(value) === value,
    'divideBy0': value => value == 0 ? true : !isNaN(value / 0)
};

// Collection of sample data to send to functions
const values = {
    // Number – number
    '0': 0,
    '123': 123,
    '-123': -123,
    '123.456': 123.456,
    '1e+30': 1e+30,
    '1e+10000': 1e+10000,
    'Infinity': Infinity,
    '-Infinity': -Infinity,
    'NaN': NaN,
    'Number(123)': Number(123.4),
    "Number('123')": Number('123.4'),
    'parseInt(123)': parseInt(123.4),
    "parseInt('123')": parseInt('123.4'),
    'parseFloat(123)': parseFloat(123.4),
    "parseFloat('123')": parseFloat('123.4'),
    // Number – object
    'new Number(123)': new Number(123),
    'new Number(-123)': new Number(-123),

    // String – string
    "'0'": '0',
    "'123'": '123',
    "'-123'": '-123',
    "'123.456'": '123.456',
    "'1e+30'": '1e+30',
    "'1e+10000'": '1e+10000',
    "'Infinity'": 'Infinity',
    "'-Infinity'": '-Infinity',
    "'NaN'": 'NaN',
    "'foo'": 'foo',
    "'123px'": '123px',
    "''": '',
    "' '": ' ',
    // String – object
    'new String(-1)': new String(-1),
    'new String(123)': new String(123),
    "new String('123')": new String('123'),
    "new String('foo')": new String('foo'),

    // Boolean – boolean
    'true': true,
    'false': false,
    // Boolean – object
    'new Boolean(true)': new Boolean(true),
    'new Boolean(false)': new Boolean(false),

    // N/A – undefined
    'undefined': undefined,
    // N/A – object
    'null': null,

    // Array – object
    '[]': [],
    '[0]': [0],
    '[0,1]': [0, 1],
    "['123']": ['123'],
    'new Array': new Array,
    'new Array()': new Array(),
    'new Array(2)': new Array(2),
    "new Array('x')": new Array('x'),
    'new Object([])': new Object([]),
    'new Object([123])': new Object([123]),

    // Object – object *** Extra data to show constructor name & typeof ***
    '{}': {},
    "{foo: 'bar'}": { foo: 'bar' },
    'new Object({})': new Object({}),

    // <Class Name> - object *** Extra data to show constructor name & typeof ***
    'new class { }': new class { },
    'new class Foo { }': new class Foo { },

    // Function – function *** Extra data to show constructor name & typeof ***
    'Number': Number,
    'String': String,
    'Boolean': Boolean,
    'Array': Array,
    'Object': Object,
    'class { }': class { },
    'class Bar { }': class Bar { },
    'function() { }': function () { },
    'function x() { }': function x() { },
    '() => { }': () => { },
};

((columnWidth, field = (value, prefix = '', suffix = '') => `${prefix}${value}${suffix}${' '.repeat(columnWidth - prefix.length - value.toString().length - suffix.length)}`) => {
    console.log(Object.entries(functions).reduce((header, [functionsKey, functionsValue]) => header = `${header.replace('\n\n', `\n${field(functionsKey, '', ':')}${functionsValue};\n\n`)}${field(functionsKey, '', ':')}`, `Functions List:\n\nValue Results:\n${field('Value:')}`));
    Object.entries(values).forEach(([valuesKey, valuesValue]) => console.log(Object.values(functions).reduce((results, functionsValue) => results += field(functionsValue(valuesValue), '// '), field(valuesKey))));
})(Object.keys({ ...functions, ...values }).reduce((len, current) => Math.max(len, current.length + 2), 16));

This will return:

Functions List:
constructor.name:   value => !(value === undefined || value === null) ? value.constructor.name : '';
typeof:             value => typeof value;
Number.isFinite:    value => Number.isFinite(value);
isFinite:           value => isFinite(value);
!Number.isNaN:      value => !Number.isNaN(value);
!isNaN:             value => !isNaN(value);
ternany:            value => value ? 'true' : 'false';
>=<0:               value => value >= 0 || value < 0;
regexInteger:       value => /^-?\d+$/.test(value);
regexFloat:         value => /^[\-\+]?[\d]+\.?(\d+)?$/.test(value);
$.isNumeric():      value => !isNaN(parseFloat(value)) && isFinite(value);
parseFloatLoose:    value => parseFloat(value) == value;
parseFloatStrict:   value => parseFloat(value) === value;
divideBy0:          value => value == 0 ? true : !isNaN(value / 0);

Value Results:
Value:              constructor.name:   typeof:             Number.isFinite:    isFinite:           !Number.isNaN:      !isNaN:             ternany:            >=<0:               regexInteger:       regexFloat:         $.isNumeric():      parseFloatLoose:    parseFloatStrict:   divideBy0:
0                   // Number           // number           // true             // true             // true             // true             // false            // true             // true             // true             // true             // true             // true             // true
123                 // Number           // number           // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true
-123                // Number           // number           // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true
123.456             // Number           // number           // true             // true             // true             // true             // true             // true             // false            // true             // true             // true             // true             // true
1e+30               // Number           // number           // true             // true             // true             // true             // true             // true             // false            // false            // true             // true             // true             // true
1e+10000            // Number           // number           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // true             // true
Infinity            // Number           // number           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // true             // true
-Infinity           // Number           // number           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // true             // true
NaN                 // Number           // number           // false            // false            // false            // false            // false            // false            // false            // false            // false            // false            // false            // false
Number(123)         // Number           // number           // true             // true             // true             // true             // true             // true             // false            // true             // true             // true             // true             // true
Number('123')       // Number           // number           // true             // true             // true             // true             // true             // true             // false            // true             // true             // true             // true             // true
parseInt(123)       // Number           // number           // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true
parseInt('123')     // Number           // number           // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true             // true
parseFloat(123)     // Number           // number           // true             // true             // true             // true             // true             // true             // false            // true             // true             // true             // true             // true
parseFloat('123')   // Number           // number           // true             // true             // true             // true             // true             // true             // false            // true             // true             // true             // true             // true
new Number(123)     // Number           // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
new Number(-123)    // Number           // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
'0'                 // String           // string           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
'123'               // String           // string           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
'-123'              // String           // string           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
'123.456'           // String           // string           // false            // true             // true             // true             // true             // true             // false            // true             // true             // true             // false            // true
'1e+30'             // String           // string           // false            // true             // true             // true             // true             // true             // false            // false            // true             // true             // false            // true
'1e+10000'          // String           // string           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // false            // true
'Infinity'          // String           // string           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // false            // true
'-Infinity'         // String           // string           // false            // false            // true             // true             // true             // true             // false            // false            // false            // true             // false            // true
'NaN'               // String           // string           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
'foo'               // String           // string           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
'123px'             // String           // string           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
''                  // String           // string           // false            // true             // true             // true             // false            // true             // false            // false            // false            // false            // false            // true
' '                 // String           // string           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
new String(-1)      // String           // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
new String(123)     // String           // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
new String('123')   // String           // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
new String('foo')   // String           // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
true                // Boolean          // boolean          // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
false               // Boolean          // boolean          // false            // true             // true             // true             // false            // true             // false            // false            // false            // false            // false            // true
new Boolean(true)   // Boolean          // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
new Boolean(false)  // Boolean          // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
undefined           //                  // undefined        // false            // false            // true             // false            // false            // false            // false            // false            // false            // false            // false            // false
null                //                  // object           // false            // true             // true             // true             // false            // true             // false            // false            // false            // false            // false            // false
[]                  // Array            // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
[0]                 // Array            // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
[0,1]               // Array            // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
['123']             // Array            // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
new Array           // Array            // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
new Array()         // Array            // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
new Array(2)        // Array            // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
new Array('x')      // Array            // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
new Object([])      // Array            // object           // false            // true             // true             // true             // true             // true             // false            // false            // false            // false            // false            // true
new Object([123])   // Array            // object           // false            // true             // true             // true             // true             // true             // true             // true             // true             // true             // false            // true
{}                  // Object           // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
{foo: 'bar'}        // Object           // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
new Object({})      // Object           // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
new class { }       //                  // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
new class Foo { }   // Foo              // object           // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
Number              // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
String              // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
Boolean             // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
Array               // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
Object              // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
class { }           // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
class Bar { }       // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
function() { }      // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
function x() { }    // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false
() => { }           // Function         // function         // false            // false            // true             // false            // true             // false            // false            // false            // false            // false            // false            // false

Answer 28

function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}

Answer 29

For detecting numbers, the following passage from JavaScript: The Good Parts by Douglas Crockford is relevant:

The isFinite function is the best way of determining whether a value can be used as a number because it rejects NaN and Infinity . Unfortunately, isFinite will attempt to convert its operand to a number, so it is not a good test if a value is not actually a number. You may want to define your own isNumber function:

var isNumber = function isNumber(value) { return typeof value === 'number' &&
            isFinite(value);
};

Answer 30

Simply use

myVar.constructor == String

or

myVar.constructor == Number

if you want to handle strings defined as objects or literals and saves you don't want to use a helper function.