12

While adding some initialisation code to a webpage, I found myself writing window.onload = ... for the umptieth time, when a thought hit me.

The window. isn't necessary, because window is the current object. So it's optional!
But nobody writes just onload = ... and I wonder why that is.

I mean, we have no qualms about writing other things, say alert without the window. qualifier.

window.onload = function() {
  alert('Your window has loaded');
};

while in reality, alert is just as much a method of the window object as the onload is.
So, why the difference? Why do even formal websites like the W3C do this?

Brian Tompsett - 汤莱恩
  • 5,753
  • 72
  • 57
  • 129
Mr Lister
  • 45,515
  • 15
  • 108
  • 150
  • 17
    It's *explicit*, so nobody thinks you're just accidentally assigning to a global variable. – Bergi Oct 23 '15 at 15:20
  • 1
    I like this argument, as it explains the difference. Assigning something to a variable vs calling a function - you couldn't possibly create a new function by just calling it, hence it's clear that the function already exists somewhere. – Mr Lister Oct 23 '15 at 16:28
  • @Bergi Can you post this as an answer? I think this is still the most compelling argument. – Mr Lister Oct 24 '15 at 07:04

4 Answers4

8

We write window. when we want to be explicit about it. There are basically two cases when this is good form to use it:

  • properties and methods of the window object - everything that is part of the Window interface. The .onload listener you've mentioned is an example of this, things like window.scrollY, window.status, window.parent, window.open(), window.focus(), window.removeEventListener() are others.
  • creation of global properties. Assigning to window.myGlobalVar from any scope is a common JS idiom to create a global "variable". Admittedly, it is still better practise to explicitly declare it with var.

While we could "optionally" omit the window. part here, it's uncommon. Especially creation of implicitly global variables through assignment is despised, and usually seen as a mistake. So if you do it on purpose, you declare your intention by using window..

However, the first case is not always well-defined. We often do omit the window. part when the property we want to use is essentially a static, global variable, and not necessarily related to the window object even when it is formally specified on it. You seldom see anybody using document, atob(), Worker, setTimeout() or fetch() with the window. prefix, just as you don't use window.JSON.parse or window.Array for the built-in objects (although it would be valid).

For some other properties like navigator, location or alert() it is not always clear, and those are used maybe fifty-fifty without or not.

Bergi
  • 630,263
  • 148
  • 957
  • 1,375
5

I see following reasons:

  1. Reduce searching up the scope-chain will improve the performance slightly. This is also seen in the IIFE where window is sent as parameter to the function and inside it the local reference to the window is used.
  2. If the function/member defined on window globally is overriden in the scope, then it'll not work as expected, so referencing explicitly makes it refer to the correct function/member. This is useful to create the function/member with the same name as the global one and still able to access the global member from shadowed scope.
Tushar
  • 85,780
  • 21
  • 159
  • 179
  • 1
    OK, but why the difference? Why doesn't everybody write `window.alert` instead of `alert`, which would also improve performance? – Mr Lister Oct 23 '15 at 16:00
  • @MrLister check `function onload() { // Code Here } onload = something;`, here `onload` will not work as expected. And as explained by Andre in the answer, `onload` is not only limited to `window`, it can be applied to `img`, `iframe`, etc. so it is explicitly added on window. In case of `alert` it is not that _critical_ function, even when it is overwrite it doesn't harm the code(as opposed to `onload`). – Tushar Oct 23 '15 at 16:29
1

Because .onload isn't exclusive to window. It can also be used, for example, as document.onload. So you define it depending on when you want your script to be executed.

Andre Felipe
  • 57
  • 1
  • 9
  • OK, but why the difference? Why doesn't everybody write `window.alert` instead of `alert`, which also isn't exclusive? – Mr Lister Oct 23 '15 at 16:00
-2

window object is by default initialized by browser. Its a good practice to defined explicitly window object it effect on performance &your code will become understandable.

ABHI
  • 27
  • 5