What exactly is the difference between the window.onload event and the onload event of the body tag? when do I use which and how should it be done correctly?
A:
if you want to manipulate the DOM the definetely use <body onload="">. this way the event will be triggered when the DOM is loaded. Else there is lag between window.onload event and DOM loading so you could wind up manipulating object that doesnot exists.
i would suggest using jquery and the $(document).ready(function(){}). This will work for the best
Mote
2008-10-10 13:09:06
That's incorrect. window.onload is only invoked when the page has finished loading.
KernelM
2008-10-10 13:17:55
A:
There is no difference ...
So principially you could use both (one at a time !-)
But for the sake of readability and for the cleanliness of the html-code I always prefer the window.onload !o]
roenving
2008-10-10 13:11:25
A:
Another option is to use self invoking anonymous methods
<script>
(function(){
//code here
})();
</script>
Causas
2008-10-10 13:16:06
A:
If you're trying to write unobtrusive JS code (and you should be), then you shouldn't use <body onload="">.
It is my understanding that different browsers handle these two slightly differently but they operate similarly. In most browsers, if you define both, one will be ignored.
Dr. Bob
2008-10-10 13:18:36
+3
A:
I prefer, generally, to not use the <body onload=""> event. I think it's cleaner to keep behavior separated from content as much as possible.
That said, there are occasions (usually pretty rare for me) where using body onload can give a slight speed boost.
I like to use Prototype so I generally put something like this in the <head> of my page:
document.observe("dom:loadeed", function(){
alert('The DOM is loaded!');
});
or
Event.observe(window, 'load', function(){
alert('Window onload');
});
The above are tricks I learned here. I'm very fond of the concept of attach event handlers outside of the HTML.
Mark Biek
2008-10-10 13:19:47
A:
They both work the same. However, note that if both are defined, only one of them will be invoked. I generally avoid using either of them directly. Instead, you can attach an event handler to the load event. This way you can incorporate more easily other JS packages which might also need to attach a callback to the onload event.
Any JS framework will have cross-browser methods for event handlers.
KernelM
2008-10-10 13:20:59
+12
A:
window.onload = myOnloadFunc and <body onload="myOnloadFunc();"> are different ways of using the same event. Using window.onload is less obtrusive though - it takes your JavaScript out of the HTML.
All of the common JavaScript libraries, Prototype, ExtJS, Dojo, JQuery, YUI, etc. provide nice wrappers around events that occur as the document is loaded. You can listen for the window onLoad event, and react to that, but onLoad is not fired until all resources have been downloaded, so your event handler won't be executed until that last huge image has been fetched. In some cases that's exactly what you want, in others you might find that listening for when the DOM is ready is more appropriate - this event is similar to onLoad but fires without waiting for images, etc. to download.
Richard Turner
2008-10-10 13:39:24
A:
It is a accepted standard to have content, layout and behavior separate. So window.onload() will be more suitable to use than <body onload=""> though both do the same work.
Rajeshwaran S P
2008-10-10 13:44:48
A:
Think of onload like any other attribute. On an input box, for example, you could put:
<input id="test1" value="something"/>
Or you could call:
document.getElementById('test1').value = "somethingelse";
The onload attribute works the same way, except that it takes a function as its value instead of a string like the value attribute does. That also explains why you can "only use one of them" - calling window.onload reassigns the value of the onload attribute for the body tag.
Also, like others here are saying, usually it is cleaner to keep style and javascript separated from the content of the page, which is why most people advise to use window.onload or like jQuery's ready function.
Soldarnal
2008-10-10 14:11:16
A:
<body onload=""> should override window.onload.
With <body onload="">, document.body.onload might be null, undefined or a function depending on the browser (although getAttribute("onload") should be somewhat consistent for getting the body of the anonymous function as a string). With window.onload, when you assign a function to it, window.onload will be a function consistently across browsers. If that matters to you, use window.onload.
window.onload is better for separating the JS from your content anyway. There's not much reason to use <body onload=""> anyway when you can use window.onload.
In Opera, the event target for window.onload and <body onload=""> (and even window.addEventListener("load", func, false)) will be the window instead of the document like in Safari and Firefox. But, 'this' will be the window across browsers.
What this means is that, when it matters, you should wrap the crud and make things consistent or use a library that does it for you.
Shadow2531
2008-10-10 14:32:12
+2
A:
There is no difference, but you should not use either.
In many browsers, window.onload event is not triggered until all images have loaded, which is not what you want. Standards based browsers have an event called "DomContentReady" which fires earlier, but it is not supported by IE. I'd recommend using a javascript library which supports a cross browser DomContentReady feature, or finding a well written function you can use. jQuery's $(document).ready(), is a good example.
John C
2008-10-10 15:02:50
+4
A:
'so many subjective answers to an objective question. "Unobtrusive" JavaScript is superstition like the old rule to never use gotos. Write code in a way that helps you reliably accomplish your goal, not according to someone's trendy religious beliefs.
Anyone who finds:
<body onload="body_onload();">
to be overly distracting is overly pretentious and doesn't have their priorities straight.
I normally put my JavaScript code in a separate .js file, but I find nothing cumbersome about hooking event handlers in HTML, which is valid HTML by the way.
A:
If we use both window.onload and body onload,
From this it execute only body onload. If we use any function under window.onload it will not exectue.
kumar
2010-03-17 08:31:46
+1
A:
window.onload can work without body, like this.. Create page with only the sciprt tages and open it in browser. The page doesn't contain any body still it works..
function testSp() { alert("hit"); } window.onload=testSp;
john Joseph
2010-04-22 12:39:46