To check what data type something has in javascript is not always the easiest. The language itself provides an operator called typeof for that which works in a straightforward way. Typeof returns a string of what a values data type is, so for an object "object" is returned and for a string "string".

However javascripts data types and the typeof operator aren't exactly perfect. For example for arrays and null "object" is returned and for NaN and Infinity "number". To check for anything more than just the primitive data types and to know if something's actually a number, string, null, an array or a real object a little more logic is required.

Table of contents


A string is always a string so this one is easy. Except if called with new (new String) typeof will instead return "object". So to also include those strings instanceof can be used.

// Returns if a value is a string
function isString (value) {
return typeof value === 'string' || value instanceof String;


From typeof more things than just an ordinary number will return "number" like NaN and Infinity. To know if a value really is a number the function isFinite is also required.

// Returns if a value is really a number
function isNumber (value) {
return typeof value === 'number' && isFinite(value);


In javascript arrays are not true arrays like in java and in other languages. They're actually objects so typeof will return "object" for them. To know if something's really an array its constructor can be compared to Array.

// Returns if a value is an array
function isArray (value) {
return value && typeof value === 'object' && value.constructor === Array;

// ES5 actually has a method for this (ie9+)


Functions are functions so here just typeof is enough.

// Returns if a value is a function
function isFunction (value) {
return typeof value === 'function';


Many things are objects in javascript. To know if a value is really an object that can have properties and be looped through, its constructor can be compared to Object.

// Returns if a value is an object
function isObject (value) {
return value && typeof value === 'object' && value.constructor === Object;

Null & undefined

Most times you don't need to check explicitly for null and undefined since they're both falsy values. However to do it below functions does the trick.

// Returns if a value is null
function isNull (value) {
return value === null;

// Returns if a value is undefined
function isUndefined (value) {
return typeof value === 'undefined';


For booleans typeof is enough since it returns "boolean" for both true and false.

// Returns if a value is a boolean
function isBoolean (value) {
return typeof value === 'boolean';


RegExp's are objects so the only thing needed to check is if the constructor is RegExp.

// Returns if a value is a regexp
function isRegExp (value) {
return value && typeof value === 'object' && value.constructor === RegExp;


Errors in javascript are the same as "exceptions" in many other programming languages. They come in a couple different forms like for instance Error, TypeError and RangeError. An instanceof statement is enough for them all, but just to be extra sure we also check for the "message" property that errors have.

// Returns if value is an error object
function isError (value) {
return value instanceof Error && typeof value.message !== 'undefined';


Date isn't really a data type in javascript. But to know if something's a Date object it can be tested with instanceof against Date.

// Returns if value is a date object
function isDate (value) {
return value instanceof Date;


In ES6 the new datatype Symbol was added. Nicely enough typeof returns "symbol" for it so no more logic is required.

// Returns if a Symbol
function isSymbol (value) {
return typeof value === 'symbol';

That was all types for now. If you think something is wrong or missing and should be added, just leave a comment below! Some more in depth reading about javascripts data types and structures can be found at