When do I need to use hasOwnProperty()?

Question

I read that we should always use hasOwnProperty when looping an object, because the object can be modified by something else to include some keys we don't want.

But is this always required? Are there situations where it's not needed? Is this required for local variables too?

function my(){
  var obj = { ... };
  for(var key in obj){
    if(obj.hasOwnProperty(key)){
      safe
    }
  }
}

I just don't like adding an extra if inside the loop if I don't have to.

Death to hasOwnProperty

This guy says I shouldn't use it at all any more.

score 41 · Accepted Answer · edited Oct 06 '20 at 12:41

41

Object.hasOwnProperty determines if the whole property is defined in the object itself or in the prototype chain.

In other words: do the so-called check if you want properties (either with data or functions) coming from no other place than the object itself.

For example:

function A() {
   this.x = "I'm an own property";
}

A.prototype.y = "I'm not an own property";

var instance = new A();
var xIsOwnProperty = instance.hasOwnProperty("x"); // true
var yIsOwnProperty = instance.hasOwnProperty("y"); // false

Do you want to avoid the whole check if you want own properties only?

Since ECMAScript 5.x, Object has a new function Object.keys which returns an array of strings where its items are the own properties from a given object:

var instance = new A();
// This won't contain "y" since it's in the prototype, so
// it's not an "own object property"
var ownPropertyNames = Object.keys(instance);

Also, since ECMAScript 5.x, Array.prototype has Array.prototype.forEach which let’s perform a for-each loop fluently:

Object.keys(instance).forEach(function(ownPropertyName) {
    // This function will be called for each found "own property", and
    // you don't need to do the instance.hasOwnProperty check any more
});

edited Oct 06 '20 at 12:41

Peter Mortensen

30,738
21
105
131

answered Sep 06 '15 at 11:12

Matías Fidemraizer

63,804
18
124
206

@elad.chen Thanks ;P Simple but still efficient! – Matías Fidemraizer Sep 06 '15 at 11:15
I would consider adding the usage of Object.keys(obj).forEach(..); As this will prevent prototype lookups.. – elad.chen Sep 06 '15 at 11:17
@elad.chen Right, I can add this. My concern is that a simple Q&A can turn into an entire Wikipedia page haha – Matías Fidemraizer Sep 06 '15 at 11:17
I see. Anyway if someone sees my comment, he'll have a basic idea of what I mean. – elad.chen Sep 06 '15 at 11:19
@elad.chen I've added the thing about `Object.keys`. See my update. I was talking about adding even more stuff... This answer can turn into a bible about prototype chaining, object creation approaches..... you know :D – Matías Fidemraizer Sep 06 '15 at 11:22
Does it mean that, if I'm using for example `node`, and I'm over control the object and sure that no one else does `A.prototype.y`, may I then completely avoid using `hasOwnProperty`? – João Pimentel Ferreira Dec 11 '18 at 18:53
@JoãoPimentelFerreira Maybe I'm not understanding you, but you can't use `hasOwnProperty` to check if `y` is a direct property of an instance of `A`, because it's of `A.prototype` – Matías Fidemraizer Dec 12 '18 at 08:32
I was not clear enough. I mean when __must__ I use it within for..in ? – João Pimentel Ferreira Dec 12 '18 at 15:34
@JoãoPimentelFerreira Oh! You need to use `hasOwnProperty` when you want to filter own object (i.e. not in the prototype chain) properties. – Matías Fidemraizer Dec 12 '18 at 15:47
1

But imagine that I create my own object: `var obj = {a: 'a', b: 'b'}` and I want to loop through `obj`. Do I need to filter by `hasOwnProperty`? – João Pimentel Ferreira Mar 13 '21 at 13:26

score 2 · Answer 2 · edited Oct 06 '20 at 12:42

2

When you're using for (var key in obj) it will loop through the given object + its parent objects' properties on the prototype chain until it reaches the end of the chain. As you want to check only a specific object's properties, you need to use hasOwnProperty.

This is not needed in for (var i = 0; i < length; i++) or data.forEach().

edited Oct 06 '20 at 12:42

Peter Mortensen

30,738
21
105
131

answered Sep 06 '15 at 11:14

Davion

881
6
12

score 2 · Answer 3 · edited Apr 22 '22 at 11:57

YES, use it always with for ... in

There are some nice answers here describing what hasOwnProperty() does and offering other solutions.
But none do provide an answer to what this question and @João in comments asks.
Is this always required?

In other words, if the object is mine, if I have control over it, if the object is defined as my own local variable, do I still need to use hasOwnProperty()?

The complication with this question is, that the control over the variable of Object type is not what's important in this consideration.
What's important is the control over the Object type itself.

If the question is slightly rephrased to: "Is the use of hasOwnProperty() required if I have full control over the JS script, where it's used and everything in its or parent scopes?"
Then no, you don't need to use the hasOwnProperty(). But the full control over the environment is not something you should count on.

Consider this example

var variableCreatedByInocentUser = { amisane: 'yes' };
for (let key in variableCreatedByInocentUser) {
    console.log(key +'? '+ variableCreatedByInocentUser[key]);
}

console.log('-----');

Object.prototype.amicrazy = 'yes, you redefined Object type';

for (let key in variableCreatedByInocentUser) {
    console.log(key +'? '+ variableCreatedByInocentUser[key]);
}

console.log('-----');

for (let key in variableCreatedByInocentUser) {
    if (!variableCreatedByInocentUser.hasOwnProperty(key)) { continue; }
    console.log(key +'? '+ variableCreatedByInocentUser[key]);
}

It's fine to drop the hasOwnProperty() only until someone somewhere redefines the Object type. Before or even after your script is started.
The effect is retroactive. Even if you declared your variable "using original Object type", it does not work as expected in JS and the redefined Object type will also affect such variables created before.

Even though the redefining of base types is discouraged, it's being done in some frameworks. Such framework could be included and introduced into your global scope and break your script.
There might also be a safety issue. The Object could be redefined with malicious intention, making your loops perform additional tasks.

If you want to follow good practices, you should always consider all possible scenarios, like that the code you're writing could be reused or inserted, or joined with another project.

Use hasOwnProperty() even when it might seem not necessary and wasteful.

You can also use `Object.freeze(Object.prototype)` to prevent any modifications to `Object.prototype`. Then you only have to trust your JS runtime. Of course it would have to run first before any other imports. [This comment](https://stackoverflow.com/a/71542146/16387) has links to material exploring this route. Outside of security, I just wouldn't use any library that messed up all my loops by adding a global property. — Wayne Bloss, Jan 19 '23 at 03:23

score 1 · Answer 4 · edited Oct 06 '20 at 12:43

hasOwnProperty expects the property name as a string.

When you call Test.hasOwnProperty(name) you are passing it the value of the name variable (which doesn't exist), just as it would if you wrote alert(name).

Every object descended from Object inherits the hasOwnProperty method. This method can be used to determine whether an object has the specified property as a direct property of that object;

When do I need to use hasOwnProperty()?

4 Answers4

Do you want to avoid the whole check if you want own properties only?

YES, use it always with for ... in

Linked

Related