Difference between Object.prototype.hasOwnProperty.call and {}.hasOwnProperty.call.(eslint rule guard-for-in)

Question

In the eslint rule guard-for-in , use for in directly is incorrect. The good practice is

for (key in foo) {
    if (Object.prototype.hasOwnProperty.call(foo, key)) {
        doSomething(key);
    }
    if ({}.hasOwnProperty.call(foo, key)) {
        doSomething(key);
    }
}

My question is when Object.prototype.hasOwnProperty.call(foo, key) and {}.hasOwnProperty.call(foo, key) will lead different result? Anyone can show a specific example?

Answer 1

They'll never¹ lead to different results, which is why both of them are considered correct.

The object {} always inherits from the object prototype and has no own keys, so accessing the .hasOwnProperty method on it will get you what you want. And Object.prototype is a non-writable property of the global Object constructor, so it always refers to the object prototype as well.

Now, there are some cases where the expression does not do what you wanted it to do:

• Someone did overwrite the global Object variable
• Someone did shadow the Object identifier in your scope so that it doesn't refer to the global
• Someone did overwrite Object.prototype.hasOwnProperty with something else
• Someone did overwrite Function.prototype.call with something else

_{1: Obviously, the first two edge cases only mess with the Object.prototype reference, but they're still edgy enough to be ignored.}