How to check if a value is an object in JavaScript?

To check if a value is an object in JavaScript, use the following steps and reference code.

If typeof yourVariable === 'object', it’s an object or null.

If you want null, arrays or functions to be excluded, just make it:

if (
    typeof yourVariable === 'object' &&
    !Array.isArray(yourVariable) &&
    yourVariable !== null
) {

How to check if a value is an object in JavaScript?

This can be done very easily with the following function and I’m fond of it:

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);

If the item is a JS object, and it’s not a JS array, and it’s not null…if all three prove true, return true. If any of the three conditions fails, the && test will short-circuit and false will be returned. The null test can be omitted if desired (depending on how you use null).

Explained answer:

Let’s define “object” in Javascript. According to the MDN docs, every value is either an object or a primitive:

primitive, primitive value

A data that is not an object and does not have any methods. JavaScript has 7 primitive data types: string, number, bigint, boolean, undefined, symbol, and null.

What’s a primitive?

  • 3
  • 'abc'
  • true
  • null
  • undefined

What’s an object (i.e. not a primitive)?

  • Object.prototype
  • everything descended from Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} — user-defined functions
    • C.prototype — the prototype property of a user-defined function: this is not Cs prototype
      • new C() — “new”-ing a user-defined function
    • Math
    • Array.prototype
      • arrays
    • {"a": 1, "b": 2} — objects created using literal notation
    • new Number(3) — wrappers around primitives
    • … many other things …
  • Object.create(null)
  • everything descended from an Object.create(null)

How to check whether a value is an object

instanceof by itself won’t work, because it misses two cases:

// oops:  isObject(Object.prototype) -> false
// oops:  isObject(Object.create(null)) -> false
function isObject(val) {
    return val instanceof Object; 

typeof x === 'object' won’t work, because of false positives (null) and false negatives (functions):

// oops: isObject(Object) -> false
function isObject(val) {
    return (typeof val === 'object');
} won’t work, because of false positives for all of the primitives:

"[object Number]"

> Number(3))
"[object Number]"

So I use:

function isObject(val) {
    if (val === null) { return false;}
    return ( (typeof val === 'function') || (typeof val === 'object') );

@Daan’s answer also seems to work:

function isObject(obj) {
  return obj === Object(obj);

because according to the MDN docs:

The Object constructor creates an object wrapper for the given value. If the value is null or undefined, it will create and return an empty object, otherwise, it will return an object of a type that corresponds to the given value. If the value is an object already, it will return the value.

A third way that seems to work (not sure if it’s 100%) is to use Object.getPrototypeOf which throws an exception if its argument isn’t an object:

// these 5 examples throw exceptions

// these 5 examples don't throw exceptions

Answer #2:

underscore.js provides the following method to find out if something is really an object:

_.isObject = function(obj) {
  return obj === Object(obj);


Because of a previous bug in V8 and minor micro speed optimization, the method looks as follows since underscore.js 1.7.0 (August 2014):

_.isObject = function(obj) {
  var type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;

Alternative answer: will return:

  • "[object Object]" if myVar is an object
  • "[object Array]" if myVar is an array
  • etc.

Answer #3:

For simply checking against Object or Array without additional function call (speed).


isArray = function(a) {
    return (!!a) && (a.constructor === Array);
console.log(isArray(        )); // false
console.log(isArray(    null)); // false
console.log(isArray(    true)); // false
console.log(isArray(       1)); // false
console.log(isArray(   'str')); // false
console.log(isArray(      {})); // false
console.log(isArray(new Date)); // false
console.log(isArray(      [])); // true

isLiteralObject() – Note: use for Object literals only, as it returns false for custom objects, like new Date or new YourCustomObject.

isLiteralObject = function(a) {
    return (!!a) && (a.constructor === Object);
console.log(isLiteralObject(        )); // false
console.log(isLiteralObject(    null)); // false
console.log(isLiteralObject(    true)); // false
console.log(isLiteralObject(       1)); // false
console.log(isLiteralObject(   'str')); // false
console.log(isLiteralObject(      [])); // false
console.log(isLiteralObject(new Date)); // false
console.log(isLiteralObject(      {})); // true

How to check if a value is an object in JavaScript? Answer #4:

With function Array.isArray:

function isObject(o) {
  return o !== null && typeof o === 'object' && Array.isArray(o) === false;

Without function Array.isArray:

Here I’ve created my simplified version of one of the answers above:

function isObject(o) {
  return o instanceof Object && o.constructor === Object;

As for me, it’s clear and simple, and just works! Here my tests:

console.log(isObject({}));             // Will return: true
console.log(isObject([]));             // Will return: false
console.log(isObject(null));           // Will return: false
console.log(isObject(/.*/));           // Will return: false
console.log(isObject(function () {})); // Will return: false

ONE MORE TIME: not all answers pass this tests !!! 🙈

In case you need to verify that object is instance of particular class you have to check constructor with your particular class, like:

function isDate(o) {
  return o instanceof Object && o.constructor === Date;

simple test:

var d = new Date();
console.log(isObject(d)); // Will return: false
console.log(isDate(d));   // Will return: true

As result, you will have strict and robust code!

In case you won’t create functions like isDateisErrorisRegExp, etc you may consider option to use this generalized functions:

function isObject(o) {
  return o instanceof Object && typeof o.constructor === 'function';

it won’t work correctly for all test cases mentioned earlier, but it’s good enough for all objects (plain or constructed).

isObject won’t work in case of Object.create(null) because of the internal implementation of Object.create but you can use isObject in more sophisticated implementation:

function isObject(o, strict = true) {
  if (o === null || o === undefined) {
    return false;
  const instanceOfObject = o instanceof Object;
  const typeOfObject = typeof o === 'object';
  const constructorUndefined = o.constructor === undefined;
  const constructorObject = o.constructor === Object;
  const typeOfConstructorObject = typeof o.constructor === 'function';
  let r;
  if (strict === true) {
    r = (instanceOfObject || typeOfObject) && (constructorUndefined || constructorObject);
  } else {
    r = (constructorUndefined || typeOfConstructorObject);
  return r;

Answer #5:

Oh My God! I think this could be more shorter than ever, let see this:

Short and Final code

function isObject(obj)
    return obj != null && === "Object"

console.log(isObject({})) // returns true
console.log(isObject([])) // returns false
console.log(isObject(null)) // returns false


Return Types

typeof JavaScript objects (including null) returns "object"

console.log(typeof null, typeof [], typeof {})

Checking on Their constructors

Checking on their constructor property returns function with their names.

console.log(({}).constructor) // returns a function with name "Object"
console.log(([]).constructor) // returns a function with name "Array"
console.log((null).constructor) //throws an error because null does not actually have a property

Introducing returns a readonly name of a function or "anonymous" for closures.

console.log(({}) // returns "Object"
console.log(([]) // returns "Array"
console.log((null) //throws an error because null does not actually have a property

Check if a value is an object in JavaScript- Answer #6:

OK, let’s give you this concept first before answering your question, in JavaScript Functions are Object, also null, Object, Arrays and even Date, so as you see there is not a simple way like typeof obj === ‘object’, so everything mentioned above will return true, but there are ways to check it with writing a function or using JavaScript frameworks, OK:

Now, imagine you have this object that’s a real object (not null or function or array):

var obj = {obj1: 'obj1', obj2: 'obj2'};

Pure JavaScript:

//that's how it gets checked in angular framework
function isObject(obj) {
  return obj !== null && typeof obj === 'object';


//make sure the second object is capitalised 
function isObject(obj) {
   return === '[object Object]';


function isObject(obj) {
    return obj.constructor.toString().indexOf("Object") > -1;


function isObject(obj) {
    return obj instanceof Object;

You can simply use one of these functions as above in your code by calling them and it will return true if it’s an object:


If you are using a JavaScript framework, they usually have prepared these kind of functions for you, these are few of them:


 //It returns 'object' if real Object;



Underscore and Lodash:

//(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null)

Answer #7:

My God, too much confusion in other answers.

Short Answer

typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array)

To test this simply run the following statements in chrome console.

Case 1.

var anyVar = {};
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // true

Case 2.

anyVar = [];
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // false

Case 3.

anyVar = null;
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array); // false


Okay.Let’s break it down

typeof anyVar == 'object' is returned true from three candidates – [], {} and null,

anyVar instanceof Object narrows down these candidates to two – [], {}

!(anyVar instanceof Array) narrows to only one – {}

Drum rolls please!

By this you may have already learnt how to check for Array in Javascript.

Hope you learned something from this post.

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →