Has Own Property Javascript

Javascript Programming

Hey there! Today, I want to talk about a really cool feature in JavaScript called “hasOwnProperty”. This feature allows you to check if an object has its own property. Let’s dive into the details, shall we?

First of all, what exactly does it mean for an object to have its own property? Well, in JavaScript, objects can inherit properties from their prototype. The prototype is essentially a blueprint for objects, and it contains properties and methods that can be shared across multiple instances. When you access a property of an object, JavaScript first checks if the object has its own property with that name. If it doesn’t, it then looks for the property in the object’s prototype chain.

So, how do we determine if an object has its own property? This is where the “hasOwnProperty” method comes in. It is a built-in method provided by JavaScript that allows us to check if a property exists directly on an object, without traversing its prototype chain.

Here’s the syntax for using “hasOwnProperty”:


The “object” parameter is the object that you want to check, and “property” is the name of the property you want to check for. The method returns a boolean value – true if the object has its own property, and false otherwise.

Let’s look at an example to see how “hasOwnProperty” works:

const car = {
make: 'Tesla',
model: 'Model S'

console.log(car.hasOwnProperty('make')); // Output: true
console.log(car.hasOwnProperty('color')); // Output: false

In this example, we have an object called “car” with properties “make” and “model”. When we use “hasOwnProperty” to check if “car” has its own property “make”, it returns true because “make” is a property directly defined on the “car” object. However, when we check for the property “color”, which doesn’t exist on the “car” object, “hasOwnProperty” returns false.

It’s important to note that “hasOwnProperty” only checks for properties directly on the object, and not properties inherited from the prototype chain. This can be really useful in situations where you want to perform specific operations only on properties that are unique to an object.

So, why is “hasOwnProperty” useful? Well, it allows you to safely iterate over the properties of an object without worrying about inadvertently traversing the prototype chain. By checking if a property is an object’s own property, you can avoid accessing unnecessary properties and prevent unexpected behavior.


The “hasOwnProperty” method in JavaScript is a handy tool for checking if an object has its own property. It allows you to distinguish between properties that are directly defined on an object and properties inherited from the prototype chain. By using “hasOwnProperty”, you can ensure that your code behaves as expected and avoid any unwanted surprises. So go ahead and make use of this powerful feature in your JavaScript projects!