dom getelementbyid global-variables html javascript

Do DOM tree elements with IDs become global properties?


Working on an idea for a simple HTMLElement wrapper I stumbled upon the following for Internet Explorer and Chrome:

For a given HTMLElement with an id in the DOM tree, it is possible to retrieve the <div> using its ID as a variable name or as a property of window. So for a <div> like

<div id="example">some text</div>

in Internet Explorer 8 and Chrome you can do:

alert(example.innerHTML); // Alerts "some text".


alert(window["example"].innerHTML); // Alerts "some text".

So, does this mean every element in the DOM tree is converted to a property on the global object? And does it also mean one can use this as a replacement for the getElementById method in these browsers?


  • 10

    See also Why don’t we just use element IDs as identifiers in JavaScript? on why this should not be used, and Is there a spec that the id of elements be made global variable? on how it is spec’d.

    – Bergi

    Sep 1, 2014 at 15:38

  • 3

    @Bergi, the comment which states to not do this it now outdated and even invalid. Therefore, I cannot find a concrete reason to not use this feature.

    – ESR

    Aug 28, 2017 at 3:04

  • 1

    @EdmundReed You might want to read the answer of the linked question again – it’s still a bad idea: “implicitly-declared global variables” have bad to no tooling support and “lead to brittle code“. Don’t call it a “feature”, the answer below explains how it’s just a bug that became part of the standard for compatibility reasons.

    – Bergi

    Aug 28, 2017 at 16:07

  • 2

    @Bergi fair enough, you’re right. I still think it’s a really neat feature though, and is only considered problematic because people aren’t aware of it. This is how I envision using it:

    – ESR

    Aug 29, 2017 at 0:22

  • 1

    @EdmundReed It’s less problematic if you don’t properly separate content and logic of course. Also I recommend to never use inline event handlers or install custom methods on DOM elements abusing them as namespaces (notice it’s not a “scope”).

    – Bergi

    Aug 29, 2017 at 0:27


What is supposed to happen is that ‘named elements’ are added as apparent properties of the document object. This is a really bad idea, as it allows element names to clash with real properties of document.

IE made the situation worse by also adding named elements as properties of the window object. This is doubly bad in that now you have to avoid naming your elements after any member of either the document or the window object you (or any other library code in your project) might want to use.

It also means that these elements are visible as global-like variables. Luckily in this case any real global var or function declarations in your code shadow them, so you don’t need to worry so much about naming here, but if you try to do an assignment to a global variable with a clashing name and you forget to declare it var, you’ll get an error in IE as it tries to assign the value to the element itself.

It’s generally considered bad practice to omit var, as well as to rely on named elements being visible on window or as globals. Stick to document.getElementById, which is more widely-supported and less ambiguous. You can write a trivial wrapper function with a shorter name if you don’t like the typing. Either way, there’s no point in using an id-to-element lookup cache, because browsers typically optimise the getElementById call to use a quick lookup anyway; all you get is problems when elements change id or are added/removed from the document.

Opera copied IE, then WebKit joined in, and now both the previously-unstandardised practice of putting named elements on document properties, and the previously-IE-only practice of putting them on window are being standardised by HTML5, whose approach is to document and standardise every terrible practice inflicted on us by browser authors, making them part of the web forever. So Firefox 4 will also support this.

What are ‘named elements’? Anything with an id, and anything with a name being used for ‘identifying’ purposes: that is, forms, images, anchors and a few others, but not other unrelated instances of a name attribute, like control-names in form input fields, parameter names in <param> or metadata type in <meta>. ‘Identifying’ names are the ones that should be avoided in favour of id.


  • 17

    WHY!? Is there anything we can do to stop this madness? My functions got redefined by references to elements and it took an hour for me to debug. 🙁

    – Farzher

    May 8, 2014 at 15:26

  • 2

    Can we have some TLDR for this post, and maybe update to 2016? Would it be like “Having ‘named elements’ exposed to global/window/document scope was a bad idea for the browsers to implement. And relying on this feature should be avoided. [TODO: what would be the advice for naming elements to avoid name clashes? eg. can I name my DIV#location?]’?

    – Dimitry K

    Jan 6, 2016 at 12:19

  • 1

    I was curious to see the performance difference and I think this shows that it’s dramatic, unless I’m missing something.

    May 19, 2017 at 17:13

  • 2

    Fun fact: These global properties also carry over into the “””isolated””” execution context of browser extension code, and the LastPass extension got fully owned due to this amazing feature

    – a cat

    Nov 6, 2021 at 2:22

  • 2

    I agree using document.getElementById is best practice, however I through I would test performance to see if there’s a benefit of doing it differently. It appears is indeed to most performant for a modern browser. Here’s the simple test I ran to evaluate this:

    – jjr2000

    Feb 16 at 18:52


As mentioned in the earlier answer this behavior is known as named access on the window object. The value of the name attribute for some elements and the value of the id attribute for all elements are made available as properties of the global window object. These are known as named elements. Since window is the global object in the browser, each named element will be accessible as a global variable.

This was originally added by Internet Explorer and eventually was implemented by all other browsers simply for compatibility with sites that are dependent on this behavior. Interestingly, Gecko (Firefox’s rendering engine) chose to implement this in quirks mode only, whereas other rendering engines left it on in standards mode.

However, as of Firefox 14, Firefox now supports named access on the window object in standards mode as well. Why did they change this? Turns out there’s still a lot of sites that rely on this functionality in standards mode. Microsoft even released a marketing demo that did, preventing the demo from working in Firefox.

Webkit has recently considered the opposite, relegating named access on the window object to quirks mode only. They decided against it by the same reasoning as Gecko.

So… crazy as it seems this behavior is now technically safe to use in the latest version of all major browsers in standards mode. But while named access can seem somewhat convenient , it should not be used.

Why? A lot of the reasoning can be summed up in this article about why global variables are bad. Simply put, having a bunch of extra global variables leads to more bugs. Let’s say you accidentally type the name of a var and happen to type an id of a DOM node, SURPRISE!

Additionally, despite being standardized there are still quite a few discrepancies in browser’s implementations of named access.

  • IE incorrectly makes the value of the name attribute accessible for form elements (input, select, etc).
  • Gecko and Webkit incorrectly do NOT make <a> tags accessible via their name attribute.
  • Gecko incorrectly handles multiple named elements with the same name (it returns a reference to a single node instead of an array of references).

And I’m sure there’s more if you try using named access on edge cases.

As mentioned in other answers use document.getElementById to get a reference to a DOM node by its id. If you need to get a reference to a node by its name attribute use document.querySelectorAll.

Please, please do not propagate this problem by using named access in your site. So many web developers have wasted time trying to track down this magical behavior. We really need to take action and get rendering engines to turn named access off in standards mode. In the short term it will break some sites doing bad things, but in the long run it’ll help move the web forward.

If you’re interested I talk about this in more detail on my blog –


  • 5

    Just a note to the obvious caveat to the premise that “it should not be used”. That is, “it should not be used UNLESS you happen to be a code cowboy.” Code cowboys just go for it.

    Sep 13, 2014 at 0:19

  • 6

    @jeremyfoster unless “code cowboy” means someone who uses and propagates bad developer-unfriendly implementations, I strongly disagree.

    Jun 28, 2015 at 5:30

  • 3

    One mark of a good cowboy is that many disagree. But now I’m like the philosophical cowboy or something like that.

    Jun 28, 2015 at 15:49

  • 1

    More people should be using document.querySelectorAll and document.querySelector when accessing the DOM. +1 for the good suggestion of using that. Accessing elements by selector is definitely a more efficient process.

    – Travis J

    Oct 28, 2015 at 23:14

  • @TravisJ Only if id is not available, otherwise it’s, as well as getElementsByClassName, etc twice slower than getElementById

    – vanowm

    Apr 3 at 15:46


You should stick to getElementById() in these cases, for example:


IE likes to mix elements with name and ID attributes in the global namespace, so best to be explicit about what you’re trying to get.