JavaScript: How to check if Key exists in Object

Best Solution: Using the in Operator

The in operator was introduced in JavaScript specifically for this reason. It’s used to examine whether or not a property is present in a particular object or in its prototype chain.

You can use the in operator is as follows:

let exampleObject = { property1: 'value1', property2: 'value2' };

if ('property1' in exampleObject) {
    console.log('Yes, the object has the property');
} else {
    console.log('No, the object does not have the property');
}

The code above will log “Yes, the object has the property” to the console because property1 exists in the object exampleObject.

Remember, the in operator in JavaScript checks not only the object itself but also its prototype chain. This means it will return true for properties that are not directly on the object but are inherited from its prototype.

For example:

function MyObject() {
  this.myProperty = 'Hello';
}

MyObject.prototype.inheritedProperty = 'World';

let myObj = new MyObject();

console.log('myProperty' in myObj); // returns: true
console.log('inheritedProperty' in myObj); // also returns: true

Even though inheritedProperty is not a direct property of myObj, in operator still returns true because it’s in the prototype chain. If you want to check just the object’s own properties, use the hasOwnProperty method below.

Using the hasOwnProperty Method

The hasOwnProperty() method in JavaScript is a method available on all objects that allows you to check whether an object has a specific property as its own. This method returns a boolean indicating whether the object has the specified property directly on itself, not inherited from the prototype chain.

Here’s how you use it:

let object = {
  property1: "Value1",
  property2: "Value2"
};

console.log(object.hasOwnProperty('property1')); // Output: true
console.log(object.hasOwnProperty('property3')); // Output: false

In this example, object.hasOwnProperty('property1') returns true because property1 is actually a direct property of object. However, object.hasOwnProperty('property3') returns false because property3 does not exist as a direct property of object.

Using the Object.keys Method

The Object.keys() method returns an array of a given object’s own enumerable property names. You can use it in conjunction with the Array.prototype.includes() method to check if an object has a specific key.

let obj = { key1: 'value1', key2: 'value2' };

if (Object.keys(obj).includes('key1')) {
    console.log('The object has the key');
} else {
    console.log('The object does not have the key');
}

This code checks if the array of keys includes key1, and it will also log “The object has the key” to the console.

Object.getOwnPropertyNames()

The Object.getOwnPropertyNames() method returns an array of all properties (including non-enumerable properties except for those that use Symbol) found directly in a given object.

let obj = { key1: 'value1', key2: 'value2' };

if (Object.getOwnPropertyNames(obj).includes('key1')) {
    console.log('The object has the key');
} else {
    console.log('The object does not have the key');
}

This code will log “The object has the key” to the console as well.

Using propertyIsEnumerable()

The propertyIsEnumerable() method returns true if the specified property is an own property of the object and is enumerable. A property is enumerable if it can appear in a for...in loop (except for the case when the property name is a Symbol).

let obj = { a: 1, b: 2, c: 3 };
console.log(obj.propertyIsEnumerable('a')); // Output: true
console.log(obj.propertyIsEnumerable('d')); // Output: false

Remember, propertyIsEnumerable() only checks for properties that are directly on the object (not inherited) and are enumerable. Non-enumerable properties or properties inherited from the prototype chain will return false.

Reflect.has() Method

The Reflect.has() method is part of the Reflect API in JavaScript, which provides a set of utility functions, many of which appear to overlap with existing methods. However, these methods have some differences. For example, while the in operator also checks for a property’s existence, it throws an error if used with non-objects. On the other hand, Reflect.has() simply returns false when used with non-objects.

Here is an example of how to use Reflect.has():

let object = { prop1: 'value1', prop2: 'value2' };

console.log(Reflect.has(object, 'prop1'));  // Output: true
console.log(Reflect.has(object, 'prop3'));  // Output: false

In this example, Reflect.has(object, 'prop1') returns true because prop1 is a property of the object. However, Reflect.has(object, 'prop3') returns false because prop3 is not a property of the object.

The Reflect.has() method can be particularly useful when you want to check for a property’s existence without risking throwing an error. Plus, it works with both string keys and Symbol keys, making it more flexible than some other property-checking methods.