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?
A global variable, window , representing the window in which the script is running, is exposed to JavaScript code. The Window interface is home to a variety of functions, namespaces, objects, and constructors which are not necessarily directly associated with the concept of a user interface window.
The window object represents an open window in a browser. If a document contain frames (<iframe> tags), the browser creates one window object for the HTML document, and one additional window object for each frame.
The window object is simply like the root of them all to which document and screen are properties of. The screen is just the user display area, document is the DOM containing all html elements, their classes and attributes. So, the window is the parent object while they are children objects.
Definition of jQuery window. jQuery window object represents an open window in the browser. The window object is automatically created by the browser. Suppose our documents contain multiple frames, then the browser creates one window object for the HTML document and creates additional window objects for each frame.
We write window.
when we want to be explicit about it. There are basically two cases when this is good form to use it:
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.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.
I see following reasons:
window
is sent as parameter to the function and inside it the local reference to the window is used.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.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.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With