Object.prototype.hasOwnProperty()
=================================

 The **`hasOwnProperty()`** method of `Object` instances returns a boolean indicating whether this
 object has the specified property as its own property (as opposed to inheriting
 it).


**Note:** `Object.hasOwn()` is recommended over
 `hasOwnProperty()`, in browsers where it is supported.


Try it
------

Syntax
------


```js
hasOwnProperty(prop)
```

### Parameters

`prop`

The `String` name or Symbol of the property to test.

### Return value

 Returns `true` if the object has the specified property as own property; `false`
 otherwise.

Description
-----------

 The **`hasOwnProperty()`** method returns `true` if the specified property is a
 direct property of the object — even if the value is `null` or `undefined`. The
 method returns `false` if the property is inherited, or has not been declared at
 all. Unlike the `in` operator, this
 method does not check for the specified property in the object's prototype
 chain.

 The method can be called on *most* JavaScript objects, because most objects
 descend from `Object`, and hence inherit its methods. For
 example `Array` is an `Object`, so you can
 use `hasOwnProperty()` method to check whether an index exists:


```js
const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
fruits.hasOwnProperty(3); // true ('Orange')
fruits.hasOwnProperty(4); // false - not defined
```


 The method will not be available in objects where it is reimplemented, or on
 `null`-prototype objects (as these don't inherit from
 `Object.prototype`). Examples for these cases are given below.

Examples
--------

### Using hasOwnProperty to test for an own property's existence

The following code shows how to determine whether the `example` object contains a property named `prop`.


```js
const example = {};
example.hasOwnProperty("prop"); // false

example.prop = "exists";
example.hasOwnProperty("prop"); // true - 'prop' has been defined

example.prop = null;
example.hasOwnProperty("prop"); // true - own property exists with value of null

example.prop = undefined;
example.hasOwnProperty("prop"); // true - own property exists with value of undefined
```

### Direct vs. inherited properties

The following example differentiates between direct properties and properties inherited through the prototype chain:


```js
const example = {};
example.prop = "exists";

// `hasOwnProperty` will only return true for direct properties:
example.hasOwnProperty("prop"); // true
example.hasOwnProperty("toString"); // false
example.hasOwnProperty("hasOwnProperty"); // false

// The `in` operator will return true for direct or inherited properties:
"prop" in example; // true
"toString" in example; // true
"hasOwnProperty" in example; // true
```

### Iterating over the properties of an object

 The following example shows how to iterate over the enumerable properties of an
 object without executing on inherited properties.


```js
const buz = {
  fog: "stack",
};

for (const name in buz) {
  if (buz.hasOwnProperty(name)) {
    console.log(`this is fog (${name}) for sure. Value: ${buz[name]}`);
  } else {
    console.log(name); // toString or something else
  }
}
```


 Note that the `for...in` loop
 only iterates enumerable items: the absence of non-enumerable properties emitted
 from the loop does not imply that `hasOwnProperty` itself is confined strictly
 to enumerable items. You can iterate over non-enumerable properties with
 `Object.getOwnPropertyNames()`.

### Using hasOwnProperty as a property name

 JavaScript does not protect the property name `hasOwnProperty`; an object that
 has a property with this name may return incorrect results:


```js
const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "Here be dragons",
};

foo.hasOwnProperty("bar"); // re-implementation always returns false
```


 The recommended way to overcome this problem is to instead use
 `Object.hasOwn()` (in browsers that support it). Other
 alternatives include using an *external* `hasOwnProperty`:


```js
const foo = { bar: "Here be dragons" };

// Use Object.hasOwn() method - recommended
Object.hasOwn(foo, "bar"); // true

// Use the hasOwnProperty property from the Object prototype
Object.prototype.hasOwnProperty.call(foo, "bar"); // true

// Use another Object's hasOwnProperty
// and call it with 'this' set to foo
({}).hasOwnProperty.call(foo, "bar"); // true
```


Note that in the first two cases there are no newly created objects.

### Objects created with Object.create(null)

`null`-prototype objects do not
 inherit from `Object.prototype`, making `hasOwnProperty()` inaccessible.


```js
const foo = Object.create(null);
foo.prop = "exists";
foo.hasOwnProperty("prop"); // Uncaught TypeError: foo.hasOwnProperty is not a function
```


 The solutions in this case are the same as for the previous section: use
 `Object.hasOwn()` by preference, otherwise use an
 external object's `hasOwnProperty()`.

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.hasownproperty |

Browser compatibility
---------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Object.hasOwn()`
* Enumerability and ownership of properties
* `Object.getOwnPropertyNames()`
* `for...in`
* `in`
* Inheritance and the prototype chain