I've seen a bit of chatter about
document.write being deprecated, but I'm not sure exactly where this information came from. I did look it up in MDN, but there wasn't any notation about it being deprecated.. so now I'm a bit suspicious. Google wasn't much help either unfortunately (perhaps I just wasn't using the right search terms).
If it is indeed deprecated, can someone link me to the appropriate documents showing that it is indeed deprecated?
No. It's just most often considered bad practice and almost as misused as
Quoting some important points from the linked question above:
document.write(henceforth DW) does not work in XHTML
DW executed after the page has finished loading will overwrite the page, or write a new page, or not work
DW executes where encountered: it cannot inject at a given node point
Also as @JaredFarrish stated,
deprecated is mostly a state of mind. It's a relic that most likely will never go away otherwise it'd break many sites - even the Traditional Google Analytics code uses DW.
Obviously, functionality-wise it has been superseded long ago by proper DOM manipulation methods, and quoting the linked question above again:
DW is effectively writing serialised text which is not the way the DOM works conceptually.
To counterbalance, here's a list of where DW may be considered appropriate:
It allows for easily fallbacking an external script to a local copy such as when loading jQuery from a CDN fails:
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script> <script>window.jQuery || document.write('<script src="js/libs/jquery-1.8.2.min.js">\x3C/script>');</script>
It's one of the easiest ways to insert external snippets in your page while keeping the code short (e.g. analytics). Note that systems such as Google Analytics now favor the asynchronous method - creating a
script element through the
document.createElement API, setting its properties and appending it to the DOM - rather than using its traditional
DW is easily misused, hence for real world use, prefer a proper DOM manipulation method whenever viable.
There are many places where programmers are encouraged to avoid
document.write (even the HTML5 specification gives it a hardy slap), which is a good thing because it's one of those rather clunky things that was introduced at the very start of web scripting that was never standardised or even specified and it has been superceded by other methods.
However, there is still at least one case where it might be considered helpful.
Many web pages have hundreds of kb of scripts, mostly because developers just drop in libraries and plugins with no regard for page size because it saves a few hours of development time and developers consider their time more important that that of their client or employer's visitors.
Browsers generally won't download scripts if scripting is disabled or not available, but some may. Using script to insert scripts means that if scripting isn't available, the script elements are never placed in the document and the related resources are never downloaded.
document.write is a very simple way of implementing a script loader. Sure, there are much more sophisticated script loaders to do the same thing, but good old
document.write is dead basic, works everywhere and, for this purpose, does the job superbly with the same ease as innerHTML.
And given the widespread use of innerHTML (and even markup snippets as a method of creating elements using DOM methods), it seems reasonable to use a similar tool for inserting scripts.
This is almost the same as the one above, but a little different.
Script elements inserted using innerHTML aren't executed, so if the document stream is open, it's pretty trivial to use
document.write instead of innerHTML. The usual caveat applies though, using
document.write after the document is loaded will first remove the current document, which is not always (err, almost never) desirable.
Ok, everyone hates pop–ups and combining them with
document.write seems like the worst of the worst of the worst. But sometimes a simple pop–up with content written by
document.write is simpler and faster (both to develop and present) than more sophisticated dialogues.
document.write doesn't work in non–HTML documents (e.g. XML). But while many pages on the web have an XHTML DOCTYPE (possibly because CMSs prefer XML to HTML), the pages are almost always served as text/HTML, so that's how the browser treats them. It's extremely unlikely that the web will move to XML (i.e. documents actually served as XML) anytime soon. For web pages, the DOCTYPE is essentially a flag used by the browser to work out if it should be in standards mode or not, so the XML thing is a bit of a Phurphy.
However, the bottom line is that
document.write should almost never be used "in the real world" because DOM methods provide a standardised alternative, have well specified behaviour and are almost universally supported.
document.write is more or less equivalent to
eval in that there are some rare cases where it's useful, but there is nearly always a better way to do things.
In the W3C HTML5 specification [W3C Recommendation 28 October 2014 section 6.3.3] document.write() still exists, https://www.w3.org/TR/html5/webappapis.html#document.write() although there is a rather explicit warning in the specification, ending with... "For all these reasons, use of this method is strongly discouraged."
©2020 All rights reserved.