How do I check if an object has a specific property in JavaScript?

How do I check if an object has a specific property in JavaScript?


x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this

Is that the best way to do it?



I'm really confused by the answers that have been given - most of them are just outright incorrect. Of course you can have object properties that have undefined, null, or false values. So simply reducing the property check to typeof this[property] or, even worse, x.key will give you completely misleading results.

It depends on what you're looking for. If you want to know if an object physically contains a property (and it is not coming from somewhere up on the prototype chain) then object.hasOwnProperty is the way to go. All modern browsers support it. (It was missing in older versions of Safari - 2.0.1 and older - but those versions of the browser are rarely used any more.)

If what you're looking for is if an object has a property on it that is iterable (when you iterate over the properties of the object, it will appear) then doing: prop in object will give you your desired effect.

Since using hasOwnProperty is probably what you want, and considering that you may want a fallback method, I present to you the following solution:

var obj = {
    a: undefined,
    b: null,
    c: false

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );

The above is a working, cross-browser, solution to hasOwnProperty, with one caveat: It is unable to distinguish between cases where an identical property is on the prototype and on the instance - it just assumes that it's coming from the prototype. You could shift it to be more lenient or strict, based upon your situation, but at the very least this should be more helpful.


With Underscore.js or (even better) lodash:

_.has(x, 'key');

Which calls Object.prototype.hasOwnProperty, but (a) is shorter to type, and (b) uses "a safe reference to hasOwnProperty" (i.e. it works even if hasOwnProperty is overwritten).

In particular, lodash defines _.has as:

   function has(object, key) {
      return object ?, key) : false;
   // hasOwnProperty = Object.prototype.hasOwnProperty

What about?

var x = {'key': 1};

if ('key' in x) {

Note: the following is nowadays largely obsolete thanks to strict mode, and hasOwnProperty. The correct solution is to use strict mode and to check for the presence of a property using obj.hasOwnProperty. This answer predates both these things, at least as widely implemented (yes, it is that old). Take the following as a historical note.

Bear in mind that undefined is (unfortunately) not a reserved word in JavaScript if you’re not using strict mode. Therefore, someone (someone else, obviously) could have the grand idea of redefining it, breaking your code.

A more robust method is therefore the following:

if (typeof(x.attribute) !== 'undefined')

On the flip side, this method is much more verbose and also slower. :-/

A common alternative is to ensure that undefined is actually undefined, e.g. by putting the code into a function which accepts an additional parameter, called undefined, that isn’t passed a value. To ensure that it’s not passed a value, you could just call it yourself immediately, e.g.:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
if (x.key !== undefined)

Armin Ronacher seems to have already beat me to it, but:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');

A safer, but slower solution, as pointed out by Konrad Rudolph and Armin Ronacher would be:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';

You can use the in operator to check if the property exists on an object:

x = {'key': 1};
alert("key" in x);

You can also loop through all the properties of the object using a for - in loop, and then check for the specific property:

for (prop in x) {
    if (prop == "key") {
        //Do something

You must consider if this object property is enumerable or not, because non-enumerable properties will not show up in a for-in loop. Also, if the enumerable property is shadowing a non-enumerable property of the prototype, it will not show up in Internet Explorer 8 and earlier.

If you’d like a list of all instance properties, whether enumerable or not, you can use


This will return an array of names of all properties that exist on an object.

Finally, you can use the typeof operator to directly check the data type of the object property:

if (typeof x.key == "undefined") {

If the property does not exist on the object, it will return the string undefined. Else it will return the appropriate property type. However, note that this is not always a valid way of checking if an object has a property or not, because you could have a property that is set to undefined, in which case, using typeof x.key would still return true (even though the key is still in the object).

Update: You can check if a property exists by comparing to the undefined javascript property

if (x.key === undefined) {

This should work unless key was specifically set to undefined on the x object


Let's cut through some confusion here. First, let's simplify by assuming hasOwnProperty already exists; this is true of the vast majority of current browsers in use.

hasOwnProperty returns true if the attribute name that is passed to it has been added to the object. It is entirely independent of the actual value assigned to it which may be exactly undefined.


var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true


var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

The problem is what happens when an object in the prototype chain has an attribute with the value of undefined? hasOwnProperty will be false for it, and so will !== undefined. Yet, will still list it in the enumeration.

The bottom line is there is no cross-browser way (since Internet Explorer doesn't expose __prototype__) to determine that a specific identifier has not been attached to an object or anything in its prototype chain.


If you are searching for a property, then "NO". You want:

if ('prop' in obj) { }

In general you should not care whether or not the property comes from the prototype or the object.

However, because you used 'key' in your sample code, it looks like you are treating the object as a hash, in which case your answer would make sense. All of the hashes keys would be properties in the object, and you avoid the extra properties contributed by the prototype.

John Resig's answer was very comprehensive, but I thought it wasn't clear. Especially with when to use "'prop' in obj".


Yes it is :) I think you can also do, 'key') which should also work if x has a property called hasOwnProperty :)

But that tests for own properties. If you want to check if it has an property that may also be inhered you can use typeof != 'undefined'.


For testing simple objects use: if (obj[x] !== undefined)

If you don't know what object type it is use: if (obj.hasOwnProperty(x))

All other options are slower..


Performance evaluation of 100,000,000 cycles under Nodejs to the 5 options suggested by others here:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

The evaluation tells us that unless we specifically want to check the object's prototype chain as well as the object itself, we should not use the common form: if (X in Obj)... It is between 2 to 6 times slower depending on the use case

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

Bottom line, if your Obj is not necessarily a simple object and you wish to avoid checking the object's prototype chain and to ensure x is owned by Obj directly, use 'if (obj.hasOwnProperty(x))...'.

Otherwise, when using a simple object and not being worried about the object's prototype chain, using if (typeof(obj[x]) !== 'undefined')... is the safest and fastest way.

If you use a simple object as a hash table and never do anything kinky, I would use if (obj[x])... as I find it much more readable.

Have fun.


You can also use the ES6 Reflect object:

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

Documentation on MDN for Reflect.has can be found here.

The static Reflect.has() method works like the in operator as a function.

if (typeof x.key != "undefined") {



if (x.key)

fails if x.key resolves to false (for example, x.key = "").


OK, it looks like I had the right answer unless if you don't want inherited properties:

if (x.hasOwnProperty('key'))

Here are some other options to include inherited properties:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Do not do this object.hasOwnProperty(key)), its really bad because these methods may be shadowed by properties on the object in question - consider { hasOwnProperty: false } - or, the object may be a null object (Object.create(null)).

The best way is to do, key) or:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; //
// ...
console.log(, key));

hasOwnProperty "can be used to determine whether an object has the specified property as a direct property of that object; unlike the in operator, this method does not check down the object's prototype chain."

So most probably, for what seems by your question, you don't want to use hasOwnProperty, which determines if the property exists as attached directly to the object itself,.

If you want to determine if the property exists in the prototype chain you main want to use in, like:

if( prop in object ){ // do something }

I hope this helps.


Another relatively simple way is using Object.keys. This returns an array which means you get all of the features of an array.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Although we are in a world with great browser support. Because this question is so old I thought I'd add this: This is safe to use as of JS v1.8.5


With risk of massive downvoting, here is another option for a specific case. :)

If you want to test for a member on an object and want to know if it has been set to something other than:

  • ''
  • false
  • null
  • undefined
  • 0 ...

then you can use:

var foo = {}; = "Yes, this is a proper value!";
if (!! {
        // member is set, do something

ECMA Script 6 solution with reflect. Create wrapper like:

Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   return retVal;
}  // getSafeReflectArg

There is method "hasOwnProperty" exists on object, but its not recommended to call this method directly because might be sometimes the object is null or some property exist on object like: { hasOwnProperty: false }

So better way would be:

// good
var obj = {"bar": "here bar desc"}
console.log(, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(, "bar"));


You need to use the method object.hasOwnProperty(property). It returns true if the object has the property and false if the object doesn't.


Why over-complicate things when you can do:

var isProperty =  (objectname.keyname || "") ? true : false;

Simple and clear for most cases...


You can use JSON.stringify function, to turn around reference checking.

var obj = {};
// check object
JSON.stringify(obj) == JSON.stringify({}) // return true

If the key you are checking is stored in a variable, you can check it like this:

x = {'key': 1};
y = 'key';

i used this. which is lots helped me if you have a objects inside object


You can use the following approaches-

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

The difference between the following approaches are as follows-

  1. In 1st and 3rd approach we are not just searching in object but its prototypal chain too. If the object does not have the property, but the property is present in its prototype chain it is going to give true.

 var obj = {
      __proto__ :{b:2}

    console.log('b' in obj)

  1. 2nd approach will check only for its own properties. Ex -

var obj = {
      __proto__ :{b:2}


  1. The difference between 1st and third is if there is a property which has value undefined the 3rd approach is going to give false while first will give true.

var obj = {
      b : undefined
    console.log('b' in obj);


Javascript is now evolving and growing it has now good and best even efficient way to check it here are some easy ways to check if object has a particular property

  1. using hasOwnProperty()
const hero = {
  name: 'Batman'

hero.hasOwnProperty('name');     // => true
hero.hasOwnProperty('realName'); // => false
  1. using keyword/operator in
const hero = {
  name: 'Batman'

'name' in hero;     // => true
'realName' in hero; // => false
  1. comparing with undefined keyword
const hero = {
  name: 'Batman'
};;     // => 'Batman'
hero.realName; // => undefined

//so consider this
hero.realName == undefined // => true (which means property does not exists in object) == undefined // => false (which means that property exists in object)

hope you understand more and everything for more info check here


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.